U Kc,!@s4UddlmZddlmmZddlmZmZmZm Z m Z m Z ddl m Z ddl mZddl mZddlZddZdd Zd d Zd d ZddZejejfeejejejfeejejfeejejejfeejejfeejejejfeejejfeejejejfeejejejfeejej ejfeej ejfeej!ejejfeej"ejejfeej#ej$ejfeej%ejfeej&ejfeiZ'e eeej(effe)d<dddZ*ddZ+ddZ,ddZ-ejejfe,eejejejffe-eejejfe,eejejejffe-eejejfe,eejejejffe-eejejfe+ejejejfe+ejejejfe+ejejej fe,eejej fe+ej!ejejfe+ej"ejejfe+ej#ejej$fe,eejej%fe,eejej&fe,eiZ.e e eej(effe)d<ddZ/d e e e e eej(effdddZ0dS)!N)UnionCallableTupleDictOptionalType)Pattern)get_combined_dict) MatchAllNodecCs|j|jkstdtjtjtjtjtjtj i}|r|j |j ksHtd|j sVtd|j sdtd|t|d}|dk r|||Std||fntj||SdS)aGiven the conv and bn modules, fuses them and returns the fused module Args: is_qat: a flag for whether we are using quantization aware training fusion or post training quantization fusion conv: Module instance of type conv2d/conv3d bn: Spatial BN instance that needs to be fused with the conv Examples:: >>> m1 = nn.Conv2d(10, 20, 3) >>> b1 = nn.BatchNorm2d(20) >>> # xdoctest: +SKIP >>> m2 = fuse_conv_bn(m1, b1) :Conv and BN both must be in the same mode (train or eval).z?Output channel of Conv2d must match num_features of BatchNorm2dz7Only support fusing BatchNorm2d with affine set to TruezGOnly support fusing BatchNorm2d with tracking_running_stats set to TrueNCannot fuse train modules: {})trainingAssertionErrornnConv1dnniZConvBn1dConv2dZConvBn2dConv3dZConvBn3d num_features out_channelsaffinetrack_running_statsgettypeNotImplementedErrorformatutilsfuse_conv_bn_eval)is_qatconvbnZfused_module_class_mapZfused_module_classr!O/tmp/pip-unpacked-wheel-gikjz4vx/torch/ao/quantization/fuser_method_mappings.py fuse_conv_bn s& r#cCs|j|jkr|jks$ntdd}|rtjtjtjtjtjtj i}|j |j ks\td|j sjtd|j sxtd|t|d}|dk r||||Std|||fndtjtjtjtjtjtji}|t|d}|dk rtjj||}|||Std|||fdS)aGiven the conv and bn modules, fuses them and returns the fused module Args: is_qat: a flag for whether we are using quantization aware training fusion or post training quantization fusion conv: Module instance of type conv2d/conv3d bn: Spatial BN instance that needs to be fused with the conv Examples:: >>> m1 = nn.Conv2d(10, 20, 3) >>> b1 = nn.BatchNorm2d(20) >>> r1 = nn.ReLU(inplace=False) >>> # xdoctest: +SKIP >>> m2 = fuse_conv_bn_relu(m1, b1, r1) r Nz;Output channel of Conv must match num_features of BatchNormz5Only support fusing BatchNorm with affine set to TruezEOnly support fusing BatchNorm with tracking_running_stats set to Truer zCannot fuse eval modules: {})r rrrrZ ConvBnReLU1drZ ConvBnReLU2drZ ConvBnReLU3drrrrrrrr ConvReLU1d ConvReLU2d ConvReLU3drfusionr)rrr ZreluZ fused_moduleZmap_to_fused_module_trainZmap_to_fused_module_evalZ fused_convr!r!r"fuse_conv_bn_relu0s>   r(cCsh|j|jkstd|rT|j|jks,td|js:td|jsHtdt||Stj j ||SdS)aGiven the linear and bn modules, fuses them and returns the fused module Args: is_qat: a flag for whether we are using quantization aware training fusion or post training quantization fusion linear: Module instance of type Linear bn: BatchNorm1d instance that needs to be fused with the linear layer Examples:: >>> m1 = nn.Linear(20, 10) >>> b1 = nn.BatchNorm1d(10) >>> # xdoctest: +SKIP >>> m2 = fuse_linear_bn(m1, b1) z>> m1 = nn.ConvTranspose2d(10, 20, 3) >>> b1 = nn.BatchNorm2d(20) >>> # xdoctest: +SKIP >>> m2 = fuse_convtranspose_bn(m1, b1) zCConvTranspose and BN both must be in the same mode (train or eval).z8Fusing ConvTranspose+BatchNorm not yet supported in QAT.T)Z transposeN)r r Exceptionrrr'r)rZconvtr r!r!r"fuse_convtranspose_bn|s  r+csfdd}|S)z Given a sequential class for two modules, return a function that takes is_qat, and then two modules as argument, that ignores the is_qat flag and always returns the sequential that combines the two input modules cs ||SNr!rm1m2 sequentialr!r" fuser_methodsz)sequential_wrapper2..fuser_methodr!r1r2r!r0r"sequential_wrapper2s r4DEFAULT_OP_LIST_TO_FUSER_METHODcCs<|dkr i}tt|}||d}|dk s8td||S)zi Get fuser method for the given list of module types, return None if fuser method does not exist N"did not find fuser method for: {} )r r5rrr)Zop_listZadditional_fuser_method_mappingZ all_mappingsr2r!r!r"get_fuser_methods r7csfdd}|S)a  Given a sequential class for two modules, return a function that takes is_qat, and then two modules as argument, that ignores the is_qat flag and always returns the sequential that combines the two input modules, with the order of two inputs reversed cs ||Sr,r!r-r0r!r"r2sz1reverse_sequential_wrapper2..fuser_methodr!r3r!r0r"reverse_sequential_wrapper2s r8csfdd}|S)Ncs |||Sr,r!)rxyfr!r"reversedszreverse2..reversedr!r<r=r!r;r"reverse2s r?csfdd}|S)Ncs|\}}||||Sr,r!)rr9wr:zr;r!r"r=szreverse3..reversedr!r>r!r;r"reverse3s rBDEFAULT_PATTERN_TO_FUSER_METHODcCsJg}t|ttfr>g}|D]}|t|qttj|}n|tg}|S)a Returns a list of valid patterns generated from the op_pattern, since MatchAllNode can match all types of nodes, e.g. pattern (torch.nn.Conv2d, torch.add) should also be able to match keys like (MatchAllNode, torch.add) and (torch.nn.Conv2d, MatchAllNode) Example Input: (torch.add, (torch.nn.ReLU, torch.nn.Conv2d)) Example Output: [(torch.add, (torch.nn.ReLU, torch.nn.Conv2d)), (torch.add, (torch.nn.ReLU, MatchAllNode)), (torch.add, (MatchAllNode, torch.nn.Conv2d)), (torch.add, (MatchAllNode, MatchAllNode)), (MatchAllNode, (torch.nn.ReLU, torch.nn.Conv2d)), (MatchAllNode, (torch.nn.ReLU, MatchAllNode)), (MatchAllNode, (MatchAllNode, torch.nn.Conv2d)), (MatchAllNode, (MatchAllNode, MatchAllNode)), ] ) isinstancetuplelistappendget_valid_patterns itertoolsproductr ) op_patternresultZ sub_combsZ sub_patternr!r!r"rHsrH)rKfuser_method_mappingcCsT|dkr t}t|}d}|D]}||d}|dk rq:q|dk sPtd||S)z This will be made defult after we deparate the get_fuser_method Would like to implement this first and have a separate PR for deprecation Nr6)rCrHrrr)rKrMZ op_patternsr2r!r!r"get_fuser_method_news rN)N)N)1Ztorch.nnrZtorch.nn.intrinsicZ intrinsicrtypingrrrrrrZtorch.ao.quantization.utilsrr r rIr#r(r)r+r4rZ BatchNorm1dZReLUrZ BatchNorm2drZ BatchNorm3dr$r%r&ZLinearZ LinearReLUZBNReLU2dZBNReLU3dZConvTranspose1dZConvTranspose2dZConvTranspose3dr5Z Sequential__annotations__r7r8r?rBrCrHrNr!r!r!r"s     %/                            !