U Kc@svdZddlmZmZmZddlZddlmZddlmm Z ddl mm Z ddlmm mZddlmZddlmZddlmZmZmZddlmZdd lmZmZd d d d ddgZddhZee ee dddZ!GdddeZ"Gdd d e"Z#Gdd d e"Z$Gdd d e"Z%edej&j'j"dZ(Gddde"Z)Gdd d e)Z*Gddde)Z+Gd dde)Z,dS)!zQuantized convolution modules.)OptionalListTypeVarN)ops) _size_1_t)_single_pair_triple)fuse_conv_bn_weights)_quantize_weightWeightedQuantizedModuleConv1dConv2dConv3dConvTranspose1dConvTranspose2dConvTranspose3dzerosreflect)paddingreturncCsBg}t|}t|D](}tdD]}||||dq q|S)Nr )lenrangeappend)r _reversed_padding_repeated_twiceNidx_r F/tmp/pip-unpacked-wheel-gikjz4vx/torch/ao/nn/quantized/modules/conv.py_reverse_repeat_paddings   r"cseZdZd%ddZd&ddfd d Zd d Zd dZddZddZfddZ e j j ddZ fddZe j j ddZddZddZed'dd Zed!d"Zed#d$ZZS)(_ConvNdr rTrNc CstdSNNotImplementedError) self in_channels out_channels kernel_sizestriderdilationgroupsbias padding_modedevicedtyper r r!__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) Nr0r1rz'in_channels must be divisible by groupsz(out_channels must be divisible by groupsz;'padding_mode' {} is not supported by quantized convolutionr )scale zero_pointr1cSsi|]\}}|dkr||qSr1r .0kvr r r! Msz!_ConvNd._init..r1cSsi|]\}}|dkr||qSr6r r7r r r!r;Psg?)superr#r2 ValueErrorr(r)r*r+rr, transposedoutput_paddingr-_SUPPORTED_PADDINGformatr/torchZ_empty_affine_quantizedlistqint8itemsrfloatset_weight_biasr4r5)r'r(r)r*r+rr,r>r?r-r.r/r0r1factory_kwargsZ weight_shapeqweight bias_float __class__r r!_init+sN     z _ConvNd._initcCstdSr$r%)r'rIrJr r r!rGVsz_ConvNd.set_weight_biascCstdSr$r%r'r r r!r.Ysz _ConvNd.biascCstdSr$r%rNr r r! _weight_bias\sz_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})r z, dilation={dilation}z!, output_padding={output_padding}r z, groups={groups}z , bias=False)rrr,r?r-r.rA__dict__)r'sr r r! extra_repr_s  z_ConvNd.extra_reprcsdtt|||||\}}|||d<|||d<t|j||d<t|j||d<dS)Nweightr.r4r5)r<r#_save_to_state_dictrOrBZtensorr4r5)r'Z destinationprefixZ keep_varswbrKr r!rTzs    z_ConvNd._save_to_state_dictcCsH|\}}|j|j|j|j|j|j|j|j|j |j |||j |j |j fSr$)rOr(r)r*r+rr,r>r?r-r/r4r5trainingr'rVrWr r r! __getstate__s" z_ConvNd.__getstate__c s|||d||d||d||dt||d|_||dt||d|_||dtt||||d|||dS)NrSr.r4r5F) rGpoprFr4intr5r<r#_load_from_state_dict)r'Z state_dictrUZlocal_metadatastrictZ missing_keysZunexpected_keysZ error_msgsrKr r!r]s&  z_ConvNd._load_from_state_dictcCs|d|_|d|_|d|_|d|_|d|_|d|_|d|_|d|_|d |_|d |_ | |d |d |d |_ |d|_ |d|_ dS)Nrr r )r(r)r*r+rr,r>r?r-r/rGr4r5rX)r'stater r r! __setstate__s            z_ConvNd.__setstate__cCs6t|t|}tjj||}|||Sr$)type__new__rBnnModuler2rZrl)r'memoZ new_instancerkr r r! __deepcopy__s  z_ConvNd.__deepcopy__cCs |iSr$)rrrNr r r!__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)qconfigrSr1rBrDAssertionErrorr rFr(r)r*r+rr,r-r.r/rGcalculate_qparamsr4r\r5)clsmodactivation_post_processweight_post_processrIqconv act_scaleact_zpr r r! 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_quantrzz,Input QAT module must have observer attached nnq..from_float only works for z but got:ru-Input float module must have qconfig defined.r)hasattrrm_NNIQAT_CONV_BN_MODULEr rSr.ZbnZ running_meanZ running_varZepsrvrrz _FLOAT_MODULE__name__str_NNI_CONV_RELU_MODULErur)rxryr{rzr r r! 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 Nr3)r(r)r*r+rr,r-r.r/rSr0r1get_quantized_weightrGrFr4r\r5)rxZ ref_qconv output_scaleoutput_zero_pointr|rIr r r!from_references$    z_ConvNd.from_reference)r rr r TrNN)rNN)N)r __module__ __qualname__r2rMrGr.rOrRrTrBjitexportrZr]rlrrrs classmethodr staticmethodrr __classcell__r r rKr!r#$sB +      r#c seZdZdZejZejZ e j Z de e eeeee eed fdd Zd d Zejeejdd d dZddZddZddZddZeddZZS)ra#Applies 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 >>> # xdoctest: +SKIP >>> q_input = torch.quantize_per_tensor(input, scale=1.0, zero_point=0, ... dtype=torch.quint8) >>> output = m(q_input) r rTrN) r(r)r*r+rr,r-r.r/c sh| | d} t|}t|}t|tr(|nt|}t|}tt|j||||||dtd||| f | dSNr3Fr)r isinstancerr<rrM r'r(r)r*r+rr,r-r.r/r0r1rHrKr r!r26s(  zConv1d.__init__cCsdS)NZQuantizedConv1dr rNr r r! _get_nameNszConv1d._get_namerVrWrcCsV|jdkr.tjj|||j|j|j|j|_ n$tjj|||jt d|j|j|_ dSNrr) r/rBr quantizedZconv1d_prepackr+rr,r-_packed_paramsrrYr r r!rGQs" zConv1d.set_weight_biascCstjj|j\}}||fSr$)rBrrZ conv1d_unpackrrYr r r!rOZszConv1d._weight_biascCs |dSNrrOrNr r r!rS^sz Conv1d.weightcCs |dSNr rrNr r r!r.asz Conv1d.biascCs\t|jdkrtd|jdkrDt|jdd}tj|||jd}tj ||j |j |j S)Nr_ Input shape must be `(N, C, L)`!rr mode)rshaper=r/r"rFpadrrZconv1drr4r5r'inputrr r r!forwardds 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 r#rrxryr r r!rpszConv1d.from_float)r rr r TrNN)rrr__doc__rorrnniqatZConvBn1drnniZ ConvReLU1drr\rboolrr2rrBTensorrrGrOrSr.rrrrr r rKr!rs>!  cseZdZdZejZejZ e j Z dfdd Z d d Zejeejdd d d ZddZddZddZddZeddZZS)raxApplies 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 >>> # xdoctest: +SKIP >>> q_input = torch.quantize_per_tensor(input, scale=1.0, zero_point=0, dtype=torch.quint8) >>> output = m(q_input) r rTrNc sZ| | d} t|}t|}t|}t|}tt|j||||||dtd||| f | dSr)rr<rrMrrKr r!r2s(  zConv2d.__init__cCsdS)NZQuantizedConv2dr rNr r r!rszConv2d._get_namercCsV|jdkr.tjj|||j|j|j|j|_ n$tjj|||jt d|j|j|_ dSr) r/rBrrZconv2d_prepackr+rr,r-rrrYr r r!rGs" zConv2d.set_weight_biascCs |jSr$runpackrNr r r!rOszConv2d._weight_biascCs |dSrrrNr r r!rSsz Conv2d.weightcCs |dSrrrNr r r!r.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 >>> # xdoctest: +SKIP >>> q_input = torch.quantize_per_tensor(input, scale=1.0, zero_point=0, dtype=torch.quint8) >>> output = m(q_input) r rTrNc sj| dkstd| | d} t|}t|}t|}t|}tt|j||||||dtd||| f | dS)Nrz*Conv3d does not support reflection paddingr3Fr)rvr r<rrMrrKr r!r2s*  zConv3d.__init__cCsdS)NZQuantizedConv3dr rNr r r!rszConv3d._get_namercCsV|jdkr.tjj|||j|j|j|j|_ n$tjj|||jt d|j|j|_ dSr) r/rBrrZconv3d_prepackr+rr,r-rr rYr r r!rGs" zConv3d.set_weight_biascCs |jSr$rrNr r r!rO szConv3d._weight_biascCs |dSrrrNr r r!rS#sz Conv3d.weightcCs |dSrrrNr r r!r.&sz Conv3d.biascCsTt|jdkrtd|jdkrr?r-r.r/r0r1rHrKr r!r2Gs$  z_ConvTransposeNd.__init__)r*r,rrcCsNtjttg}tt|D]*}||||d||}||q|Sr)rBrZannotaterr\rrr)r'r*r,rresZkdxrr r r!_input_paddingTs  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 rrrurrtNrz)rrrmrvrrurSr1rBrDr rFr(r)r*r+rr?r-r.r,r/rGrzrwr4r\r5)rxrymsgr{rIr|r}r~r r r!r[s:      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+rr?r-r.r,r/rSr0r1rrGrFr4r\r5)rx ref_qconvtrrr|rIr r r!rzs&    z_ConvTransposeNd.from_reference)NN)rrrrrr2rr\rrrrrrr r rKr!rCs $ rc sveZdZdZejZdfdd Zd d Ze j e e j dd d d Z ddZ ddZddZddZeddZZS)raApplies 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:: >>> # xdoctest: +REQUIRES(env:TORCH_DOCTEST_QENGINE) >>> torch.backends.quantized.engine = 'qnnpack' >>> from torch.nn import quantized as nnq >>> # 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]) >>> # xdoctest: +SKIP("FIXME: output_size is not a parameter) >>> output = upsample(h, output_size=input.size()) >>> output.size() torch.Size([1, 16, 12]) r rTrNc  s^| | d} t|}t|}t|}t| } t|}tt|j|||||| d|||| f | dSNr3T)rr<rr2r'r(r)r*r+rr?r-r.r,r/r0r1rHrKr r!r2s*  zConvTranspose1d.__init__cCsdS)NZQuantizedConvTranpose1dr rNr r r!rszConvTranspose1d._get_namerc Cs*tjj|||j|j|j|j|j|_ dSr$) rBrrZconv_transpose1d_prepackr+rr?r,r-rrYr r r!rGszConvTranspose1d.set_weight_biascCstjj|j\}}||fSr$)rBrrZconv_transpose1d_unpackrrYr r r!rOszConvTranspose1d._weight_biascCs|\}}|Sr$rr'rVrr r r!rSs zConvTranspose1d.weightcCs|\}}|Sr$rr'rrWr r r!r.s zConvTranspose1d.biascCs0t|jdkrtdtjj||j|j|j S)Nr_r) rrr=rBrrZconv_transpose1drr4r5r'rr r r!rszConvTranspose1d.forwardcCst||||Sr$rrrxrrrr r r!rszConvTranspose1d.from_reference) r rrr Tr rNN)rrrrrorrr2rrBrrrGrOrSr.rrrrr r rKr!rs(+c sveZdZdZejZdfdd Zd d Ze j e e j dd d d Z ddZ ddZddZddZeddZZS)raxApplies 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:: >>> # xdoctest: +REQUIRES(env:TORCH_DOCTEST_QENGINE) >>> # QNNPACK or FBGEMM as backend >>> torch.backends.quantized.engine = 'qnnpack' >>> # With square kernels and equal stride >>> import torch.nn.quantized as nnq >>> 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]) >>> # xdoctest: +SKIP("FIXME: output_size is not a parameter) >>> output = upsample(h, output_size=input.size()) >>> output.size() torch.Size([1, 16, 12, 12]) r rTrNc  s^| | d} t|}t|}t|}t| } t|}tt|j|||||| d|||| f | dSr)rr<rr2rrKr r!r2 s*  zConvTranspose2d.__init__cCsdS)NZQuantizedConvTranpose2dr rNr r r!r.szConvTranspose2d._get_namerc Cs*tjj|||j|j|j|j|j|_ dSr$) rBrrZconv_transpose2d_prepackr+rr?r,r-rrYr r r!rG1szConvTranspose2d.set_weight_biascCstjj|j\}}||fSr$)rBrrZ conv2d_unpackrrYr r r!rO6szConvTranspose2d._weight_biascCs|\}}|Sr$rrr r r!rS:s zConvTranspose2d.weightcCs|\}}|Sr$rrr r r!r.>s zConvTranspose2d.biascCs.t|jdkrtdtj||j|j|jS)Nr`r) rrr=rrZconv_transpose2drr4r5rr r r!rBszConvTranspose2d.forwardcCst||||Sr$rrr r r!rJszConvTranspose2d.from_reference) r rrr Tr rNN)rrrrrorrr2rrBrrrGrOrSr.rrrrr r rKr!rs()c sveZdZdZejZdfdd Zd d Ze j e e j dd d d Z ddZ ddZddZddZeddZZS)raApplies 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:: >>> # xdoctest: +REQUIRES(env:TORCH_DOCTEST_QENGINE) >>> torch.backends.quantized.engine = 'fbgemm' >>> from torch.nn import quantized as nnq >>> # 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]) >>> # xdoctest: +SKIP("FIXME: output_size is not a parameter) >>> output = upsample(h, output_size=input.size()) >>> output.size() torch.Size([1, 16, 12, 12, 12]) r rTrNc  s^| | d} t|}t|}t|}t| } t|}tt|j|||||| d|||| f | dSr)r r<rr2rrKr r!r2}s*  zConvTranspose3d.__init__cCsdS)NZQuantizedConvTranpose3dr rNr r r!rszConvTranspose3d._get_namerc Cs*tjj|||j|j|j|j|j|_ dSr$) rBrrZconv_transpose3d_prepackr+rr?r,r-rrYr r r!rGszConvTranspose3d.set_weight_biascCstjj|j\}}||fSr$)rBrrZ conv3d_unpackrrYr r r!rOszConvTranspose3d._weight_biascCs|\}}|Sr$rrr r r!rSs zConvTranspose3d.weightcCs|\}}|Sr$rrr r r!r.s zConvTranspose3d.biascCs.t|jdkrtdtj||j|j|jS)Nraz&Input shape must be `(N, C, T, H, W)`!) rrr=rrZconv_transpose3drr4r5rr r r!rszConvTranspose3d.forwardcCst||||Sr$rrr r r!rszConvTranspose3d.from_reference) r rrr Tr rNN)rrrrrorrr2rrBrrrGrOrSr.rrrrr r rKr!rOs(+)-rtypingrrrrBZtorch.nnroZtorch.nn.functionalZ functionalrZtorch.nn.intrinsicZ intrinsicrZtorch.nn.intrinsic.qatZqatrZ torch._opsrZtorch.nn.common_typesrZtorch.nn.modules.utilsrrr Ztorch.nn.utilsr utilsr r __all__r@r\r"r#rrrmodulesconvrrrrrr r r r!s4     mkbcT][