o Zh@sfdZddlmZmZddlZddlmmmZ ddl mmmm Z ddl mZddlmmZddlmZddlmZddlmZmZmZddlmZdd lmZmZgd Zd d hZd e e!de e!fddZ"GdddeZ#Gddde#Z$Gddde#Z%Gddde#Z&Gddde#Z'Gddde'Z(Gddde'Z)Gdd d e'Z*dS)!zQuantized convolution modules.)ClassVarOptionalN)ops) _size_1_t)_pair_single_triple)fuse_conv_bn_weights)_quantize_weightWeightedQuantizedModule)Conv1dConv2dConv3dConvTranspose1dConvTranspose2dConvTranspose3dzerosreflectpaddingreturncs>g}ttD]|fddtdDq |S)Nc3s |] }dVqdS)r N).0_NidxrrQ/var/www/auris/lib/python3.10/site-packages/torch/ao/nn/quantized/modules/conv.py #sz*_reverse_repeat_padding..)lenrangeextend)r _reversed_padding_repeated_twicerrr_reverse_repeat_paddings  "r$cseZdZ        d&ddZ   d' d(fd d Zd d Zd dZddZddZfddZ e j j ddZ fddZe j j ddZddZddZed)dd Zed*d"d#Zed$d%ZZS)+_ConvNdr rTrNc CtNNotImplementedError) self in_channels out_channels kernel_sizestriderdilationgroupsbias padding_modedevicedtyperrr__init__(sz_ConvNd.__init__rcs0| | d}t|| dkrtd|| dkrtd||_||_||_||_||_||_||_ ||_ | |_ | t vrEtd| d| |_ |j rS|||j g}n|||j g}tj|t|fddtjdd d |D}| rtj|fd tjid d |Dnd}|||d |_d|_dS)Nr3r4rz'in_channels must be divisible by groupsz(out_channels must be divisible by groupsz'padding_mode' z* is not supported by quantized convolutionr )scale zero_pointr4cSi|] \}}|dkr||qSr4rrkvrrr hz!_ConvNd._init..r4cSr9r:rr;rrrr>nr?g?)superr5 ValueErrorr+r,r-r.rr/ transposedoutput_paddingr0_SUPPORTED_PADDINGr2torchZ_empty_affine_quantizedlistqint8itemsrfloatset_weight_biasr7r8)r*r+r,r-r.rr/rBrCr0r1r2r3r4factory_kwargsZ weight_shapeqweight bias_float __class__rr_init9sZ         z _ConvNd._initcCr&r'r()r*rLrMrrrrJxz_ConvNd.set_weight_biascCr&r'r(r*rrrr1{rQz _ConvNd.biascCr&r'r(rRrrr _weight_bias~rQz_ConvNd._weight_biascCsd}|jdt|jkr|d7}|jdt|jkr|d7}|jdt|jkr,|d7}|jdkr5|d7}|dur?|d 7}|jd i|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=Falser)rr r/rCr0r1format__dict__)r*srrr extra_reprs  z_ConvNd.extra_reprcs`t||||\}}|||d<|||d<t|j||d<t|j||d<dS)Nweightr1r7r8)r@_save_to_state_dictrSrEZtensorr7r8)r* destinationprefixZ keep_varswbrNrrrYs    z_ConvNd._save_to_state_dictcCsH|\}}|j|j|j|j|j|j|j|j|j |j |||j |j |j fSr')rSr+r,r-r.rr/rBrCr0r2r7r8trainingr*r\r]rrr __getstate__s" z_ConvNd.__getstate__c s|||d||d||d||dt||d|_||dt||d|_||dt|||d|||dS)NrXr1r7r8F)rJpoprIr7intr8r@_load_from_state_dict)r*Z state_dictr[Zlocal_metadatastrictZ missing_keysZunexpected_keys error_msgsrNrrrcs  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/rBrCr0r2rJr7r8r^)r*staterrr __setstate__s            z_ConvNd.__setstate__cCs6t|t|}tjj||}|||Sr')type__new__rEnnModuler5r`rs)r*memoZ new_instancerrrrr __deepcopy__s  z_ConvNd.__deepcopy__cCs |iSr')ryrRrrr__copy__ z_ConvNd.__copy__c Cs|dur |j}||j|jtjksJdt|j|}||j|j|j |j |j |j |j |jdu|j }|||j|dusH|jtjkrJ|S|\}}t||_t||_|S)z&Creates a qconv object and returns it.N*Weight observer must have a dtype of qint8)qconfigrXr4rErGr rIr+r,r-r.rr/r0r1r2rJcalculate_qparamsr7rbr8)clsmodactivation_post_processweight_post_processrLqconv act_scaleact_zprrr get_qconvs4       z_ConvNd.get_qconvFcCst|dr6t||jkr&t|j|j|jj|jj|jj |jj|jj\|_|_t|ds/Jd|j }|j }nDt||j ksRJd|j d|j j dtt|t|ds[Jdt|dsbdn|j }t||j|j|jfvru|d }|j}||||S) Nweight_fake_quantrz,Input QAT module must have observer attached nnq..from_float only works for z but got:r}-Input float module must have qconfig defined.r)hasattrrt_NNIQAT_CONV_BN_MODULEr rXr1ZbnZ running_meanZ running_varZepsrr _FLOAT_MODULE__name__str_NNI_CONV_RELU_MODULE_NNI_CONV_ADD_MODULE_NNI_CONV_ADD_RELU_MODULEr}r)rruse_precomputed_fake_quantrrrrr from_floats`     z_ConvNd.from_floatc Csj||j|j|j|j|j|j|j|jdu|j|j j |j j d }| }| ||jt||_t||_|S)aCreate a (fbgemm/qnnpack) quantized module from a reference quantized module Args: ref_qconv (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 Nr6)r+r,r-r.rr/r0r1r2rXr3r4get_quantized_weightrJrIr7rbr8)rZ ref_qconv output_scaleoutput_zero_pointrrLrrrfrom_referenceDs$    z_ConvNd.from_referencer rr r TrNN)rNN)rNr'F)r __module__ __qualname__r5rPrJr1rSrWrYrEjitZexportr`rcrsryrz classmethodr staticmethodrr __classcell__rrrNrr%'sD ?     ! -r%cs2eZdZUdZejZeeeje d<e j Z ee eeje d<ejZee eeje d<dZee eeje d<dZee eeje d<     d)d ed edededededededeffdd ZddZdejde ejddfddZddZd d!Zd"d#Zd$d%Z e!d*d'd(Z"Z#S)+r a`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:: >>> # xdoctest: +REQUIRES(env:TORCH_DOCTEST_QENGINE) >>> 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) rrrNrrr rTrr+r,r-r.rr/r0r1r2c sh| | d} t|}t|}t|tr|nt|}t|}tj||||||dtd||| f i| dSNr6Fr)r isinstancerr@rP r*r+r,r-r.rr/r0r1r2r3r4rKrNrrr5s(  zConv1d.__init__cCdS)NZQuantizedConv1drrRrrr _get_namerQzConv1d._get_namer\r]rcCX|jdkrtjj|||j|j|j|j|_ dStjj|||jt d|j|j|_ dSNrr) r2rEr quantizedZconv1d_prepackr.rr/r0_packed_paramsrr_rrrrJ   zConv1d.set_weight_biascCtjj|j\}}||fSr')rErrZ conv1d_unpackrr_rrrrSzConv1d._weight_biascC |dSNrrSrRrrrrX z Conv1d.weightcCrNr rrRrrrr1rz Conv1d.biascCs\t|jdkr td|jdkr"t|jdd}tj|||jd}tj ||j |j |j S)Nrf Input shape must be `(N, C, L)`!rr mode)r shaperAr2r$rFpadrrZconv1drr7r8r*inputr#rrrforwards zConv1d.forwardFcCtj|||dSzCreates 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 )rr%rrrrrrrrzConv1d.from_floatrr)$rrr__doc__rvr rrrt__annotations__nniqatZConvBn1drrrwnniZ ConvReLU1drrrrbrboolrr5rrETensorrJrSrXr1rrrrrrrNrr asT "  % r cseZdZUdZejZeeeje d<e j Z ee eeje d<ejZee eeje d<ejZeeeje d<ejZeeeje d<     d fd d ZddZdejde ejdd fddZddZddZddZddZed!ddZ Z!S)"raApplies 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:: >>> # xdoctest: +REQUIRES(env:TORCH_DOCTEST_QENGINE) >>> # 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) rrrrrr rTrNc sZ| | d} t|}t|}t|}t|}tj||||||dtd||| f i| dSr)rr@rPrrNrrr5s(  zConv2d.__init__cCr)NZQuantizedConv2drrRrrrr2rQzConv2d._get_namer\r]rcCrr) r2rErrZconv2d_prepackr.rr/r0rrr_rrrrJ5rzConv2d.set_weight_biascC |jSr'runpackrRrrrrS?r{zConv2d._weight_biascCrrrrRrrrrXBrz Conv2d.weightcCrrrrRrrrr1Erz Conv2d.biascCTt|jdkr td|jdkrt|j}tj|||jd}tj ||j |j |j S)Nrg#Input shape must be `(N, C, H, W)`!rr)r rrAr2r$rrrrrZconv2drr7r8rrrrrH  zConv2d.forwardFcCrrrrrrrrVrzConv2d.from_floatrr)"rrrrrvrrrrtrrZConvBn2drrrwrZ ConvReLU2drZ ConvAdd2drZ ConvAddReLU2drr5rrErrJrSrXr1rrrrrrrNrrs0 %$ rcs eZdZUdZejZeeeje d<e j Z ee eeje d<ejZee eeje d<dZee eeje d<dZee eeje d<     d fd d ZddZdejde ejddfddZddZddZddZddZed!ddZZS)"raApplies a 3D convolution over a quantized input signal composed of several quantized input planes. For details on input arguments, parameters, and implementation see :class:`~torch.nn.Conv3d`. .. 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.Conv3d` for other attributes. Examples:: >>> # xdoctest: +REQUIRES(env:TORCH_DOCTEST_QENGINE) >>> # 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) rrrNrrr rTrc sj| dksJd| | d} t|}t|}t|}t|}tj||||||dtd||| f i| dS)Nrz*Conv3d does not support reflection paddingr6Fr)rr@rPrrNrrr5s*  zConv3d.__init__cCr)NZQuantizedConv3drrRrrrrrQzConv3d._get_namer\r]rcCrr) r2rErrZconv3d_prepackr.rr/r0rrr_rrrrJrzConv3d.set_weight_biascCrr'rrRrrrrSr{zConv3d._weight_biascCrrrrRrrrrXrz Conv3d.weightcCrrrrRrrrr1rz Conv3d.biascCr)Nrhz&Input shape must be `(N, C, D, H, W)`!rr)r rrAr2r$rrrrrZconv3drr7r8rrrrrrzConv3d.forwardFcCrrrrrrrrrzConv3d.from_floatrr) rrrrrvrrrrtrrZConvBn3drrrwrZ ConvReLU3drrrr5rrErrJrSrXr1rrrrrrrNrrcs0 %% rc s~eZdZUeeejjje d<  dfdd Z de e de e de e de e fd d Z edd d ZeddZZS)_ConvTransposeNdrNc sP| dkr td|jj| | d}tj||||||||| | | f i|dS)Nrz+Only "zeros" padding mode is supported for r6)rArOrr@rP)r*r+r,r-r.rr/rBrCr0r1r2r3r4rKrNrrr5s(   z_ConvTransposeNd.__init__r-r/rrcCsNtjttg}tt|D]}||||d||}||q|Sr)rErZannotaterFrbr!r append)r*r-r/rresZkdxrrrr_input_paddings  z_ConvTransposeNd._input_paddingFc Csd|jd|jj}t||jksJ|t|dsJd|j}||j|jtjks3Jdt |j |}||j |j |j |j|j|j|j|jdu|j|j }|||jt|drg|jjtj kri|S|j\}}t ||_t||_|S)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 rrr}rr|Nr)rrrtrr}rXr4rErGr rIr+r,r-r.rrCr0r1r/r2rJrr~r7rbr8) rrrmsgrrLrrrrrrrsJ      z_ConvTransposeNd.from_floatcCsn||j|j|j|j|j|j|j|jdu|j|j |j j |j j d }| }|||jt||_t||_|S)aCreate a (fbgemm/qnnpack) quantized module from a reference quantized module Args: ref_qconvt (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 Nr6)r+r,r-r.rrCr0r1r/r2rXr3r4rrJrIr7rbr8)r ref_qconvtrrrrLrrrrIs&   z_ConvTransposeNd.from_reference)NNr)rrrrrtrvmodulesconvr%rr5rFrbrrrrrrrrrNrrs$ &  .rceZdZUdZejZeeeje d<         dfdd Z d d Z d e j d ee j ddfddZddZddZddZddZeddZZS)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.ao.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.ao.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]) rr rTrNc  ^| | d} t|}t|}t|}t| } t|}tj|||||| d|||| f i| dSNr6T)rr@r5r*r+r,r-r.rrCr0r1r/r2r3r4rKrNrrr5*  zConvTranspose1d.__init__cCr)NZQuantizedConvTranspose1drrRrrrrrQzConvTranspose1d._get_namer\r]rc C*tjj|||j|j|j|j|j|_ dSr') rErrZconv_transpose1d_prepackr.rrCr/r0rr_rrrrJ zConvTranspose1d.set_weight_biascCrr')rErrZconv_transpose1d_unpackrr_rrrrSrzConvTranspose1d._weight_biascC|\}}|Sr'rr*r\rrrrrX zConvTranspose1d.weightcC|\}}|Sr'rr*rr]rrrr1rzConvTranspose1d.biascCs0t|jdkr tdtjj||j|j|j S)Nrfr) r rrArErrZconv_transpose1drr7r8r*rrrrrs zConvTranspose1d.forwardcCt||||Sr'rrrrrrrrrrzConvTranspose1d.from_reference r rrr Tr rNN)rrrrrvrrrrtrr5rrErrrJrSrXr1rrrrrrrNrrg* +%  rcr)ra~Applies 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.ao.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.ao.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]) rr rTrNc  rr)rr@r5rrNrrr5rzConvTranspose2d.__init__cCr)NZQuantizedConvTranspose2drrRrrrr5rQzConvTranspose2d._get_namer\r]rc Crr') rErrZconv_transpose2d_prepackr.rrCr/r0rr_rrrrJ8rzConvTranspose2d.set_weight_biascCrr')rErrZ conv2d_unpackrr_rrrrSCrzConvTranspose2d._weight_biascCrr'rrrrrrXGrzConvTranspose2d.weightcCrr'rrrrrr1KrzConvTranspose2d.biascC.t|jdkr tdtj||j|j|jS)Nrgr) r rrArrZconv_transpose2drr7r8rrrrrO zConvTranspose2d.forwardcCrr'rrrrrrXrzConvTranspose2d.from_referencer)rrrrrvrrrrtrr5rrErrrJrSrXr1rrrrrrrNrrs* )%  rcr)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.ao.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.ao.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]) rr rTrNc  rr)rr@r5rrNrrr5rzConvTranspose3d.__init__cCr)NZQuantizedConvTranspose3drrRrrrrrQzConvTranspose3d._get_namer\r]rc Crr') rErrZconv_transpose3d_prepackr.rrCr/r0rr_rrrrJrzConvTranspose3d.set_weight_biascCrr')rErrZ conv3d_unpackrr_rrrrSrzConvTranspose3d._weight_biascCrr'rrrrrrXrzConvTranspose3d.weightcCrr'rrrrrr1rzConvTranspose3d.biascCr)Nrhz&Input shape must be `(N, C, T, H, W)`!) r rrArrZconv_transpose3drr7r8rrrrrrzConvTranspose3d.forwardcCrr'rrrrrrrzConvTranspose3d.from_referencer)rrrrrvrrrrtrr5rrErrrJrSrXr1rrrrrrrNrr_rr)+rtypingrrrEZtorch.ao.nn.intrinsicZaorvZ intrinsicrZtorch.ao.nn.intrinsic.qatZqatrZtorch.nnZtorch.nn.functionalZ functionalrZ torch._opsrZtorch.nn.common_typesrZtorch.nn.modules.utilsrrrZtorch.nn.utilsr utilsr r __all__rDrFrbr$r%r rrrrrrrrrrs8     <}{