o I h@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_NidxrrV/var/www/vscode/kcb/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_PADDINGr2torch_empty_affine_quantizedlistqint8itemsrfloatset_weight_biasr7r8)r*r+r,r-r.rr/rBrCr0r1r2r3r4factory_kwargs weight_shapeqweight bias_float __class__rr_init9sZ         z _ConvNd._initcCr&r'r()r*rNrOrrrrKxz_ConvNd.set_weight_biascCr&r'r(r*rrrr1{rSz _ConvNd.biascCr&r'r(rTrrr _weight_bias~rSz_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_dictrUrEtensorr7r8)r* destinationprefix keep_varswbrPrrr[s    z_ConvNd._save_to_state_dictcCsH|\}}|j|j|j|j|j|j|j|j|j |j |||j |j |j fSr')rUr+r,r-r.rr/rBrCr0r2r7r8trainingr*r`rarrr __getstate__s" z_ConvNd.__getstate__c s|||d||d||d||dt||d|_||dt||d|_||dt|||d|||dS)NrZr1r7r8F)rKpoprJr7intr8r@_load_from_state_dict)r* state_dictr^local_metadatastrict missing_keysunexpected_keys error_msgsrPrrrgs  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/rBrCr0r2rKr7r8rb)r*staterrr __setstate__s            z_ConvNd.__setstate__cCs6t|t|}tjj||}|||Sr')type__new__rEnnModuler5rdr{)r*memo new_instancerzrrr __deepcopy__s  z_ConvNd.__deepcopy__cCs |iSr')rrTrrr__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)qconfigrZr4rErHr rJr+r,r-r.rr/r0r1r2rKcalculate_qparamsr7rfr8)clsmodactivation_post_processweight_post_processrNqconv 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)hasattrr|_NNIQAT_CONV_BN_MODULEr rZr1bn running_mean running_varepsrr _FLOAT_MODULE__name__str_NNI_CONV_RELU_MODULE_NNI_CONV_ADD_MODULE_NNI_CONV_ADD_RELU_MODULErr)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/r0r1r2rZr3r4get_quantized_weightrKrJr7rfr8)r ref_qconv output_scaleoutput_zero_pointrrNrrrfrom_referenceDs$    z_ConvNd.from_referencer rr r TrNN)rNN)rNr'F)r __module__ __qualname__r5rRrKr1rUrYr[rEjitexportrdrgr{rr classmethodr staticmethodrr __classcell__rrrPrr%'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@rR r*r+r,r-r.rr/r0r1r2r3r4rLrPrrr5s(  zConv1d.__init__cCdS)NQuantizedConv1drrTrrr _get_namerSzConv1d._get_namer`rarcCX|jdkrtjj|||j|j|j|j|_ dStjj|||jt d|j|j|_ dSNrr) r2rEr quantizedconv1d_prepackr.rr/r0_packed_paramsrrcrrrrK   zConv1d.set_weight_biascCtjj|j\}}||fSr')rErr conv1d_unpackrrcrrrrUzConv1d._weight_biascC |dSNrrUrTrrrrZ z Conv1d.weightcCrNr rrTrrrr1rz Conv1d.biascCs\t|jdkr td|jdkr"t|jdd}tj|||jd}tj ||j |j |j S)Nrn Input shape must be `(N, C, L)`!rr mode)r shaperAr2r$rFpadrrconv1drr7r8r*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__r~r rrr|__annotations__nniqatConvBn1drrrnni ConvReLU1drrrrfrboolrr5rrETensorrKrUrZr1rrrrrrrPrr 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@rRrrPrrr5s(  zConv2d.__init__cCr)NQuantizedConv2drrTrrrr2rSzConv2d._get_namer`rarcCrr) r2rErrconv2d_prepackr.rr/r0rrrcrrrrK5rzConv2d.set_weight_biascC |jSr'runpackrTrrrrU?rzConv2d._weight_biascCrrrrTrrrrZBrz Conv2d.weightcCrrrrTrrrr1Erz Conv2d.biascCTt|jdkr td|jdkrt|j}tj|||jd}tj ||j |j |j S)Nro#Input shape must be `(N, C, H, W)`!rr)r rrAr2r$rrrrrconv2drr7r8rrrrrH  zConv2d.forwardFcCrrrrrrrrVrzConv2d.from_floatrr)"rrrrr~rrrr|rrConvBn2drrrr ConvReLU2dr ConvAdd2dr ConvAddReLU2drr5rrErrKrUrZr1rrrrrrrPrrs0 %$ 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@rRrrPrrr5s*  zConv3d.__init__cCr)NQuantizedConv3drrTrrrrrSzConv3d._get_namer`rarcCrr) r2rErrconv3d_prepackr.rr/r0rrrcrrrrKrzConv3d.set_weight_biascCrr'rrTrrrrUrzConv3d._weight_biascCrrrrTrrrrZrz Conv3d.weightcCrrrrTrrrr1rz Conv3d.biascCr)Nrpz&Input shape must be `(N, C, D, H, W)`!rr)r rrAr2r$rrrrrconv3drr7r8rrrrrrzConv3d.forwardFcCrrrrrrrrrzConv3d.from_floatrr) rrrrr~rrrr|rrConvBn3drrrr ConvReLU3drrrr5rrErrKrUrZr1rrrrrrrPrrcs0 %% 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)rArQrr@rR)r*r+r,r-r.rr/rBrCr0r1r2r3r4rLrPrrr5s(   z_ConvTransposeNd.__init__r-r/rrcCsNtjttg}tt|D]}||||d||}||q|Sr)rErannotaterGrfr!r append)r*r-r/rreskdxrrrr_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 rrrrrNr)rrr|rrrZr4rErHr rJr+r,r-r.rrCr0r1r/r2rKrrr7rfr8) rrrmsgrrNrrrrrrrsJ      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/r2rZr3r4rrKrJr7rfr8)r ref_qconvtrrrrNrrrrIs&   z_ConvTransposeNd.from_reference)NNr)rrrrr|r~modulesconvr%rr5rGrfrrrrrrrrrPrrs$ &  .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/r2r3r4rLrPrrr5*  zConvTranspose1d.__init__cCr)NQuantizedConvTranspose1drrTrrrrrSzConvTranspose1d._get_namer`rarc C*tjj|||j|j|j|j|j|_ dSr') rErrconv_transpose1d_prepackr.rrCr/r0rrcrrrrK zConvTranspose1d.set_weight_biascCrr')rErrconv_transpose1d_unpackrrcrrrrUrzConvTranspose1d._weight_biascC|\}}|Sr'rr*r`rrrrrZ zConvTranspose1d.weightcC|\}}|Sr'rr*rrarrrr1rzConvTranspose1d.biascCs0t|jdkr tdtjj||j|j|j S)Nrnr) r rrArErrconv_transpose1drr7r8r*rrrrrs zConvTranspose1d.forwardcCt||||Sr'rrrrrrrrrrzConvTranspose1d.from_reference r rrr Tr rNN)rrrrr~rrrr|rr5rrErrrKrUrZr1rrrrrrrPrrg* +%  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@r5rrPrrr5rzConvTranspose2d.__init__cCr)NQuantizedConvTranspose2drrTrrrr5rSzConvTranspose2d._get_namer`rarc Crr') rErrconv_transpose2d_prepackr.rrCr/r0rrcrrrrK8rzConvTranspose2d.set_weight_biascCrr')rErr conv2d_unpackrrcrrrrUCrzConvTranspose2d._weight_biascCrr'rrrrrrZGrzConvTranspose2d.weightcCrr'rrrrrr1KrzConvTranspose2d.biascC.t|jdkr tdtj||j|j|jS)Nror) r rrArrconv_transpose2drr7r8rrrrrO zConvTranspose2d.forwardcCrr'r r rrrrXr zConvTranspose2d.from_referencer )rrrrr~rrrr|rr5rrErrrKrUrZr1rrrrrrrPrrs* )%  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@r5rrPrrr5rzConvTranspose3d.__init__cCr)NQuantizedConvTranspose3drrTrrrrrSzConvTranspose3d._get_namer`rarc Crr') rErrconv_transpose3d_prepackr.rrCr/r0rrcrrrrKrzConvTranspose3d.set_weight_biascCrr')rErr conv3d_unpackrrcrrrrUrzConvTranspose3d._weight_biascCrr'rrrrrrZrzConvTranspose3d.weightcCrr'rrrrrr1rzConvTranspose3d.biascCr)Nrpz&Input shape must be `(N, C, T, H, W)`!) r rrArrconv_transpose3drr7r8rrrrrrzConvTranspose3d.forwardcCrr'r r rrrrr zConvTranspose3d.from_referencer )rrrrr~rrrr|rr5rrErrrKrUrZr1rrrrrrrPrr_r r)+rtypingrrrEtorch.ao.nn.intrinsicaor~ intrinsicrtorch.ao.nn.intrinsic.qatqatrtorch.nntorch.nn.functional functionalr torch._opsrtorch.nn.common_typesrtorch.nn.modules.utilsrrrtorch.nn.utilsr utilsr r __all__rDrGrfr$r%r rrrrrrrrrrs8     <}{