U dɕ@sfdZddlmZmZmZddlZddlmZddlmm Z ddl mm Z ddlmm mZddlmZddlmZddlmZmZmZddlmZmZddlmZd d hZeeeed d d Z GdddeZ!Gddde!Z"Gddde!Z#Gddde!Z$edej%j&j!dZ'Gddde!Z(Gddde(Z)Gddde(Z*Gddde(Z+dS) zQuantized convolution modules.)OptionalListTypeVarN)ops) _size_1_t)_single_pair_triple)_quantize_weightWeightedQuantizedModule)fuse_conv_bn_weightszerosreflect)paddingreturncCsBg}t|}t|D](}tdD]}||||dq q|S)N)lenrangeappend)r _reversed_padding_repeated_twiceNidx_rC/tmp/pip-unpacked-wheel-ua33x9lu/torch/nn/quantized/modules/conv.py_reverse_repeat_paddings   rcseZdZd%ddZd&ddfd d Zd d Zd dZddZddZfddZ e j j ddZ fddZe j j ddZddZddZed'dd Zed!d"Zed#d$ZZS)(_ConvNdrrTr Nc CstdSNNotImplementedError) self in_channels out_channels kernel_sizestriderdilationgroupsbias padding_modedevicedtyperrr__init__!sz_ConvNd.__init__)rcs4| | d}tt||| dkr,td|| dkr@td||_||_||_||_||_||_ ||_ ||_ | |_ | t krtd| | |_|j r|||j g}n|||j g}tj|t|fddtjddd |D}| rtj|fd tjid d |Dnd}|||d |_d|_dS) Nr*r+rz'in_channels must be divisible by groupsz(out_channels must be divisible by groupsz;'padding_mode' {} is not supported by quantized convolutionr)scale zero_pointr+cSsi|]\}}|dkr||qSr+r.0kvrrr Isz!_ConvNd._init..r+cSsi|]\}}|dkr||qSr0rr1rrrr5Lsg?)superrr, ValueErrorr"r#r$r%rr& transposedoutput_paddingr'_SUPPORTED_PADDINGformatr)torchZ_empty_affine_quantizedlistqint8itemsr floatset_weight_biasr.r/)r!r"r#r$r%rr&r8r9r'r(r)r*r+factory_kwargsZ weight_shapeqweight bias_float __class__rr_init'sN     z _ConvNd._initcCstdSrr)r!rCrDrrrrARsz_ConvNd.set_weight_biascCstdSrrr!rrrr(Usz _ConvNd.biascCstdSrrrHrrr _weight_biasXsz_ConvNd._weight_biascCsd}|jdt|jkr |d7}|jdt|jkr<|d7}|jdt|jkrX|d7}|jdkrj|d7}|dkr~|d 7}|jf|jS) Nzq{in_channels}, {out_channels}, kernel_size={kernel_size}, stride={stride}, scale={scale}, zero_point={zero_point})rz, padding={padding})rz, dilation={dilation}z!, output_padding={output_padding}rz, groups={groups}z , bias=False)rrr&r9r'r(r;__dict__)r!srrr extra_repr[s  z_ConvNd.extra_reprcsdtt|||||\}}|||d<|||d<t|j||d<t|j||d<dS)Nweightr(r.r/)r6r_save_to_state_dictrIr<Ztensorr.r/)r!Z destinationprefixZ keep_varswbrErrrNvs    z_ConvNd._save_to_state_dictcCsH|\}}|j|j|j|j|j|j|j|j|j |j |||j |j |j fSr)rIr"r#r$r%rr&r8r9r'r)r.r/trainingr!rPrQrrr __getstate__~s" z_ConvNd.__getstate__c s|||d||d||d||dt||d|_||dt||d|_||dtt||||d|||dS)NrMr(r.r/F) rApopr@r.intr/r6r_load_from_state_dict)r!Z state_dictrOZlocal_metadatastrictZ missing_keysZunexpected_keysZ error_msgsrErrrWs&  z_ConvNd._load_from_state_dictcCs|d|_|d|_|d|_|d|_|d|_|d|_|d|_|d|_|d |_|d |_ | |d |d |d |_ |d|_ |d|_ dS)Nrrr )r"r#r$r%rr&r8r9r'r)rAr.r/rR)r!staterrr __setstate__s            z_ConvNd.__setstate__cCs6t|t|}tjj||}|||Sr)type__new__r<nnModuler,rTrf)r!memoZ new_instancererrr __deepcopy__s  z_ConvNd.__deepcopy__cCs |iSr)rlrHrrr__copy__sz_ConvNd.__copy__c Cs|dkr|j}||j|jtjks0tdt|j|}||j|j |j |j |j |j |j|jdk |j }|||j|dks|jtjkr|S|\}}t||_t||_|SdS)z/Creates a qconv object and returns it. N*Weight observer must have a dtype of qint8)qconfigrMr+r<r>AssertionErrorr r@r"r#r$r%rr&r'r(r)rAcalculate_qparamsr.rVr/)clsmodactivation_post_processweight_post_processrCqconv act_scaleact_zprrr get_qconvs,     z_ConvNd.get_qconvcCst|drlt||jkrLt|j|j|jj|jj|jj |jj|jj\|_|_t|ds^t d|j }|j }n~t||j kst d|jd|j jdtt|t|dst dt|dsdn|j }t||jkr|d }|j}||||S) Nweight_fake_quantrtz,Input QAT module must have observer attached nnq..from_float only works for z but got:ro-Input float module must have qconfig defined.r)hasattrrg_NNIQAT_CONV_BN_MODULEr rMr(ZbnZ running_meanZ running_varZepsrprzrt _FLOAT_MODULE__name__str_NNI_CONV_RELU_MODULErory)rrrsrurtrrr from_floatsL       z_ConvNd.from_floatc Csj||j|j|j|j|j|j|j|jdk |j|j j |j j d }| }| ||jt||_t||_|SaCreate a (fbgemm/qnnpack) quantized module from a reference quantized module Args: ref_module (Module): a reference quantized module, either produced by torch.ao.quantization utilities or provided by the user output_scale (float): scale for output Tensor output_zero_point (int): zero point for output Tensor Nr-)r"r#r$r%rr&r'r(r)rMr*r+get_quantized_weightrAr@r.rVr/)rrZ ref_qconv output_scaleoutput_zero_pointrvrCrrrfrom_references$    z_ConvNd.from_reference)rrrrTr NN)r NN)N)r __module__ __qualname__r,rGrAr(rIrLrNr<jitexportrTrWrfrlrm classmethodry staticmethodrr __classcell__rrrErr sB +      rc seZdZdZejZejZ e j Z de e eeeee eed fdd Zd d Zejeejdd d dZddZddZddZddZeddZZS)Conv1daApplies a 1D convolution over a quantized input signal composed of several quantized input planes. For details on input arguments, parameters, and implementation see :class:`~torch.nn.Conv1d`. .. note:: Only `zeros` is supported for the :attr:`padding_mode` argument. .. note:: Only `torch.quint8` is supported for the input data type. Attributes: weight (Tensor): packed tensor derived from the learnable weight parameter. scale (Tensor): scalar for the output scale zero_point (Tensor): scalar for the output zero point See :class:`~torch.nn.Conv1d` for other attributes. Examples:: >>> m = nn.quantized.Conv1d(16, 33, 3, stride=2) >>> input = torch.randn(20, 16, 100) >>> # quantize input to quint8 >>> q_input = torch.quantize_per_tensor(input, scale=1.0, zero_point=0, dtype=torch.quint8) >>> output = m(q_input) rrTr N) r"r#r$r%rr&r'r(r)c sh| | d} t|}t|}t|tr(|nt|}t|}tt|j||||||dtd||| f | dSNr-Fr)r isinstancerr6rrG r!r"r#r$r%rr&r'r(r)r*r+rBrErrr,0s(  zConv1d.__init__cCsdS)NZQuantizedConv1drrHrrr _get_nameHszConv1d._get_namerPrQrcCsV|jdkr.tjj|||j|j|j|j|_ n$tjj|||jt d|j|j|_ dSNr r) r)r<r quantizedZconv1d_prepackr%rr&r'_packed_paramsrrSrrrrAKs" zConv1d.set_weight_biascCstjj|j\}}||fSr)r<rrZ conv1d_unpackrrSrrrrITszConv1d._weight_biascCs |dSNrrIrHrrrrMXsz Conv1d.weightcCs |dSNrrrHrrrr([sz Conv1d.biascCs\t|jdkrtd|jdkrDt|jdd}tj|||jd}tj ||j |j |j S)NrY Input shape must be `(N, C, L)`!r rmode)rshaper7r)rrFpadrrZconv1drr.r/r!inputrrrrforward^s zConv1d.forwardcCs t||SzCreates a quantized module from a float module or qparams_dict. Args: mod (Module): a float module, either produced by torch.ao.quantization utilities or provided by the user rrrrrsrrrrjszConv1d.from_float)rrrrTr NN)rrr__doc__rirrnniqatZConvBn1drnniZ ConvReLU1drrVrboolrr,rr<TensorrrArIrMr(rrrrrrrErr s>   rcseZdZdZejZejZ e j Z dfdd Z d d Zejeejdd d d ZddZddZddZddZeddZZS)Conv2daZApplies a 2D convolution over a quantized input signal composed of several quantized input planes. For details on input arguments, parameters, and implementation see :class:`~torch.nn.Conv2d`. .. note:: Only `zeros` is supported for the :attr:`padding_mode` argument. .. note:: Only `torch.quint8` is supported for the input data type. Attributes: weight (Tensor): packed tensor derived from the learnable weight parameter. scale (Tensor): scalar for the output scale zero_point (Tensor): scalar for the output zero point See :class:`~torch.nn.Conv2d` for other attributes. Examples:: >>> # With square kernels and equal stride >>> m = nn.quantized.Conv2d(16, 33, 3, stride=2) >>> # non-square kernels and unequal stride and with padding >>> m = nn.quantized.Conv2d(16, 33, (3, 5), stride=(2, 1), padding=(4, 2)) >>> # non-square kernels and unequal stride and with padding and dilation >>> m = nn.quantized.Conv2d(16, 33, (3, 5), stride=(2, 1), padding=(4, 2), dilation=(3, 1)) >>> input = torch.randn(20, 16, 50, 100) >>> # quantize input to quint8 >>> q_input = torch.quantize_per_tensor(input, scale=1.0, zero_point=0, dtype=torch.quint8) >>> output = m(q_input) rrTr Nc sZ| | d} t|}t|}t|}t|}tt|j||||||dtd||| f | dSr)rr6rrGrrErrr,s(  zConv2d.__init__cCsdS)NZQuantizedConv2drrHrrrrszConv2d._get_namercCsV|jdkr.tjj|||j|j|j|j|_ n$tjj|||jt d|j|j|_ dSr) r)r<rrZconv2d_prepackr%rr&r'rrrSrrrrAs" zConv2d.set_weight_biascCs |jSrrunpackrHrrrrIszConv2d._weight_biascCs |dSrrrHrrrrMsz Conv2d.weightcCs |dSrrrHrrrr(sz Conv2d.biascCsTt|jdkrtd|jdkr>> # With square kernels and equal stride >>> m = nn.quantized.Conv3d(16, 33, 3, stride=2) >>> # non-square kernels and unequal stride and with padding >>> m = nn.quantized.Conv3d(16, 33, (3, 5, 5), stride=(1, 2, 2), padding=(1, 2, 2)) >>> # non-square kernels and unequal stride and with padding and dilation >>> m = nn.quantized.Conv3d(16, 33, (3, 5, 5), stride=(1, 2, 2), padding=(1, 2, 2), dilation=(1, 2, 2)) >>> input = torch.randn(20, 16, 56, 56, 56) >>> # quantize input to quint8 >>> q_input = torch.quantize_per_tensor(input, scale=1.0, zero_point=0, dtype=torch.quint8) >>> output = m(q_input) rrTr Nc sj| dkstd| | d} t|}t|}t|}t|}tt|j||||||dtd||| f | dS)Nrz*Conv3d does not support reflection paddingr-Fr)rpr r6rrGrrErrr,s*  zConv3d.__init__cCsdS)NZQuantizedConv3drrHrrrr szConv3d._get_namercCsV|jdkr.tjj|||j|j|j|j|_ n$tjj|||jt d|j|j|_ dSr) r)r<rrZconv3d_prepackr%rr&r'rr rSrrrrAs" zConv3d.set_weight_biascCs |jSrrrHrrrrIszConv3d._weight_biascCs |dSrrrHrrrrMsz Conv3d.weightcCs |dSrrrHrrrr(sz Conv3d.biascCsTt|jdkrtd|jdkrs$  z_ConvTransposeNd.__init__)r$r&rrcCsNtjttg}tt|D]*}||||d||}||q|Sr)r<rZannotaterrVrrr)r!r$r&rresZkdxrrrr_input_paddingKs  z_ConvTransposeNd._input_paddingc Csd|jd|jj}t||jks,t|t|ds>td|j}||j|jtj ksftdt |j |}||j |j |j|j|j|j|j|jdk |j|j }|||jt|dr|jjtj kr|S|j\}}t ||_t||_|SdS)zCreates a quantized module from a float module or qparams_dict. Args: mod (Module): a float module, either produced by torch.ao.quantization utilities or provided by the user r{r|ror}rnNrt)rrrgrpr~rorMr+r<r>r r@r"r#r$r%rr9r'r(r&r)rArtrqr.rVr/)rrrsmsgrurCrvrwrxrrrrRs:      z_ConvTransposeNd.from_floatcCsn||j|j|j|j|j|j|j|jdk |j|j |j j |j j d }| }|||jt||_t||_|Sr)r"r#r$r%rr9r'r(r&r)rMr*r+rrAr@r.rVr/)rr ref_qconvtrrrvrCrrrrqs&    z_ConvTransposeNd.from_reference)NN)rrrrrr,rrVrrrrrrrrrErr:s $ rc sveZdZdZejZdfdd Zd d Ze j e e j dd d d Z ddZ ddZddZddZeddZZS)ConvTranspose1daApplies a 1D transposed convolution operator over an input image composed of several input planes. For details on input arguments, parameters, and implementation see :class:`~torch.nn.ConvTranspose1d`. .. note:: Currently only the QNNPACK engine is implemented. Please, set the `torch.backends.quantized.engine = 'qnnpack'` For special notes, please, see :class:`~torch.nn.quantized.Conv1d` Attributes: weight (Tensor): packed tensor derived from the learnable weight parameter. scale (Tensor): scalar for the output scale zero_point (Tensor): scalar for the output zero point See :class:`~torch.nn.ConvTranspose2d` for other attributes. Examples:: >>> torch.backends.quantized.engine = 'qnnpack' >>> # With square kernels and equal stride >>> m = nnq.ConvTranspose1d(16, 33, 3, stride=2) >>> # non-square kernels and unequal stride and with padding >>> m = nnq.ConvTranspose1d(16, 33, (3, 5), stride=(2, 1), padding=(4, 2)) >>> input = torch.randn(20, 16, 50) >>> q_input = torch.quantize_per_tensor(input, scale=1.0, zero_point=0, dtype=torch.quint8) >>> output = m(q_input) >>> # exact output size can be also specified as an argument >>> input = torch.randn(1, 16, 12) >>> q_input = torch.quantize_per_tensor(input, scale=1.0, zero_point=0, dtype=torch.quint8) >>> downsample = nnq.Conv1d(16, 16, 3, stride=2, padding=1) >>> upsample = nnq.ConvTranspose1d(16, 16, 3, stride=2, padding=1) >>> h = downsample(q_input) >>> h.size() torch.Size([1, 16, 6]) >>> output = upsample(h, output_size=input.size()) >>> output.size() torch.Size([1, 16, 12]) rrTr Nc  s^| | d} t|}t|}t|}t| } t|}tt|j|||||| d|||| f | dSNr-T)rr6rr,r!r"r#r$r%rr9r'r(r&r)r*r+rBrErrr,s*  zConvTranspose1d.__init__cCsdS)NZQuantizedConvTranpose1drrHrrrrszConvTranspose1d._get_namerc Cs*tjj|||j|j|j|j|j|_ dSr) r<rrZconv_transpose1d_prepackr%rr9r&r'rrSrrrrAszConvTranspose1d.set_weight_biascCstjj|j\}}||fSr)r<rrZconv_transpose1d_unpackrrSrrrrIszConvTranspose1d._weight_biascCs|\}}|Srrr!rPrrrrrMs zConvTranspose1d.weightcCs|\}}|Srrr!rrQrrrr(s zConvTranspose1d.biascCs0t|jdkrtdtjj||j|j|j S)NrYr) rrr7r<rrZconv_transpose1drr.r/r!rrrrrszConvTranspose1d.forwardcCst||||SrrrrrrrrrrrrszConvTranspose1d.from_reference) rrrrTrr NN)rrrrrirrr,rr<rrrArIrMr(rrrrrrrErrs((rc sveZdZdZejZdfdd Zd d Ze j e e j dd d d Z ddZ ddZddZddZeddZZS)ConvTranspose2daApplies a 2D transposed convolution operator over an input image composed of several input planes. For details on input arguments, parameters, and implementation see :class:`~torch.nn.ConvTranspose2d`. For special notes, please, see :class:`~torch.nn.quantized.Conv2d` Attributes: weight (Tensor): packed tensor derived from the learnable weight parameter. scale (Tensor): scalar for the output scale zero_point (Tensor): scalar for the output zero point See :class:`~torch.nn.ConvTranspose2d` for other attributes. Examples:: >>> # QNNPACK or FBGEMM as backend >>> torch.backends.quantized.engine = 'qnnpack' >>> # With square kernels and equal stride >>> m = nnq.ConvTranspose2d(16, 33, 3, stride=2) >>> # non-square kernels and unequal stride and with padding >>> m = nnq.ConvTranspose2d(16, 33, (3, 5), stride=(2, 1), padding=(4, 2)) >>> input = torch.randn(20, 16, 50, 100) >>> q_input = torch.quantize_per_tensor(input, scale=1.0, zero_point=0, dtype=torch.quint8) >>> output = m(q_input) >>> # exact output size can be also specified as an argument >>> input = torch.randn(1, 16, 12, 12) >>> q_input = torch.quantize_per_tensor(input, scale=1.0, zero_point=0, dtype=torch.quint8) >>> downsample = nnq.Conv2d(16, 16, 3, stride=2, padding=1) >>> upsample = nnq.ConvTranspose2d(16, 16, 3, stride=2, padding=1) >>> h = downsample(q_input) >>> h.size() torch.Size([1, 16, 6, 6]) >>> output = upsample(h, output_size=input.size()) >>> output.size() torch.Size([1, 16, 12, 12]) rrTr Nc  s^| | d} t|}t|}t|}t| } t|}tt|j|||||| d|||| f | dSr)rr6rr,rrErrr,s*  zConvTranspose2d.__init__cCsdS)NZQuantizedConvTranpose2drrHrrrrszConvTranspose2d._get_namerc Cs*tjj|||j|j|j|j|j|_ dSr) r<rrZconv_transpose2d_prepackr%rr9r&r'rrSrrrrA!szConvTranspose2d.set_weight_biascCstjj|j\}}||fSr)r<rrZ conv2d_unpackrrSrrrrI&szConvTranspose2d._weight_biascCs|\}}|SrrrrrrrM*s zConvTranspose2d.weightcCs|\}}|Srrrrrrr(.s zConvTranspose2d.biascCs.t|jdkrtdtj||j|j|jS)NrZr) rrr7rrZconv_transpose2drr.r/rrrrr2szConvTranspose2d.forwardcCst||||Srrrrrrr:szConvTranspose2d.from_reference) rrrrTrr NN)rrrrrirrr,rr<rrrArIrMr(rrrrrrrErrs(&rc sveZdZdZejZdfdd Zd d Ze j e e j dd d d Z ddZ ddZddZddZeddZZS)ConvTranspose3da8Applies a 3D transposed convolution operator over an input image composed of several input planes. For details on input arguments, parameters, and implementation see :class:`~torch.nn.ConvTranspose3d`. .. note:: Currently only the FBGEMM engine is implemented. Please, set the `torch.backends.quantized.engine = 'fbgemm'` For special notes, please, see :class:`~torch.nn.quantized.Conv3d` Attributes: weight (Tensor): packed tensor derived from the learnable weight parameter. scale (Tensor): scalar for the output scale zero_point (Tensor): scalar for the output zero point See :class:`~torch.nn.ConvTranspose3d` for other attributes. Examples:: >>> torch.backends.quantized.engine = 'fbgemm' >>> # With cubic kernels and equal stride >>> m = nnq.ConvTranspose3d(16, 33, 3, stride=2) >>> # non-cubic kernels and unequal stride and with padding >>> m = nnq.ConvTranspose3d(16, 33, (3, 3, 5), stride=(2, 1, 1), padding=(4, 2, 2)) >>> input = torch.randn(20, 16, 50, 100, 100) >>> q_input = torch.quantize_per_tensor(input, scale=1.0, zero_point=0, dtype=torch.quint8) >>> output = m(q_input) >>> # exact output size can be also specified as an argument >>> input = torch.randn(1, 16, 12, 12, 12) >>> q_input = torch.quantize_per_tensor(input, scale=1.0, zero_point=0, dtype=torch.quint8) >>> downsample = nnq.Conv3d(16, 16, 3, stride=2, padding=1) >>> upsample = nnq.ConvTranspose3d(16, 16, 3, stride=2, padding=1) >>> h = downsample(q_input) >>> h.size() torch.Size([1, 16, 6, 6, 6]) >>> output = upsample(h, output_size=input.size()) >>> output.size() torch.Size([1, 16, 12, 12, 12]) rrTr Nc  s^| | d} t|}t|}t|}t| } t|}tt|j|||||| d|||| f | dSr)r r6rr,rrErrr,is*  zConvTranspose3d.__init__cCsdS)NZQuantizedConvTranpose3drrHrrrrwszConvTranspose3d._get_namerc Cs*tjj|||j|j|j|j|j|_ dSr) r<rrZconv_transpose3d_prepackr%rr9r&r'rrSrrrrAzszConvTranspose3d.set_weight_biascCstjj|j\}}||fSr)r<rrZ conv3d_unpackrrSrrrrIszConvTranspose3d._weight_biascCs|\}}|SrrrrrrrMs zConvTranspose3d.weightcCs|\}}|Srrrrrrr(s zConvTranspose3d.biascCs.t|jdkrtdtj||j|j|jS)Nr[z&Input shape must be `(N, C, T, H, W)`!) rrr7rrZconv_transpose3drr.r/rrrrrszConvTranspose3d.forwardcCst||||SrrrrrrrszConvTranspose3d.from_reference) rrrrTrr NN)rrrrrirrr,rr<rrrArIrMr(rrrrrrrErr>s((r),rtypingrrrr<Ztorch.nnriZtorch.nn.functionalZ functionalrZtorch.nn.intrinsicZ intrinsicrZtorch.nn.intrinsic.qatZqatrZ torch._opsrZtorch.nn.common_typesrZtorch.nn.modules.utilsrrr Z torch.nn.quantized.modules.utilsr r Ztorch.nn.utilsr r:rVrrrrrmodulesconvrrrrrrrrrs2    ljabSZW