U yhM@sdZddlmZmZmZddlZddlmZddlmm Z ddl m mm Zddlm mm mZddlmZddlmZddlmZmZmZddlmZdd lmZmZd d d d ddgZddhZ ee!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 T/var/www/html/venv/lib/python3.8/site-packages/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"d#Zed$d%ZZS)*_ConvNdr rTrNc CstdSNNotImplementedError) self in_channels out_channels kernel_sizestriderdilationgroupsbias padding_modedevicedtyper r r!__init__%sz_ConvNd.__init__)rcs2| | d}t|| dkr(td|| dkrMsz!_ConvNd._init..r1cSsi|]\}}|dkr||qSr6r r7r r r!r;Psg?)superr2 ValueErrorr(r)r*r+rr, transposedoutput_paddingr-_SUPPORTED_PADDINGr/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'rHrIr r r!rFVsz_ConvNd.set_weight_biascCstdSr$r%r'r r r!r.Ysz _ConvNd.biascCstdSr$r%rMr 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.format__dict__)r'sr r r! extra_repr_s  z_ConvNd.extra_reprcs`t||||\}}|||d<|||d<t|j||d<t|j||d<dS)Nweightr.r4r5)r<_save_to_state_dictrNrAZtensorr4r5)r'Z destinationprefixZ keep_varswbrJr r!rTzs    z_ConvNd._save_to_state_dictcCsH|\}}|j|j|j|j|j|j|j|j|j |j |||j |j |j fSr$)rNr(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|_||dt|||d|||dS)NrSr.r4r5F)rFpoprEr4intr5r<_load_from_state_dict)r'Z state_dictrUZlocal_metadatastrictZ missing_keysZunexpected_keysZ error_msgsrJr 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/rFr4r5rX)r'stater r r! __setstate__s            z_ConvNd.__setstate__cCs6t|t|}tjj||}|||Sr$)type__new__rAnnModuler2rZrl)r'memoZ new_instancerkr r r! __deepcopy__s  z_ConvNd.__deepcopy__cCs |iSr$)rrrMr 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)qconfigrSr1rArCAssertionErrorr rEr(r)r*r+rr,r-r.r/rFcalculate_qparamsr4r\r5)clsmodactivation_post_processweight_post_processrHqconv act_scaleact_zpr r r! get_qconvs,     z_ConvNd.get_qconvFcCst|drlt||jkrLt|j|j|jj|jj|jj |jj|jj\|_|_t|ds^t d|j }|j }nt||j kst d|jd|j jdtt|t|dst dt|dsdn|j }t||j|j|jfkr|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_varepsrvrrz _FLOAT_MODULE__name__str_NNI_CONV_RELU_MODULE_NNI_CONV_ADD_MODULE_NNI_CONV_ADD_RELU_MODULErur)rxryuse_precomputed_fake_quantr{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||_|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 Nr3)r(r)r*r+rr,r-r.r/rSr0r1get_quantized_weightrFrEr4r\r5)rxZ ref_qconv output_scaleoutput_zero_pointr|rHr r r!from_references$    z_ConvNd.from_reference)r rr r TrNN)rNN)N)F)r __module__ __qualname__r2rLrFr.rNrRrTrAjitZexportrZr]rlrrrs classmethodr staticmethodrr __classcell__r r rJr!r#$sB +      r#c seZdZUdZejZejZ e j Z dZ ded<dZded<deeeeeeeeed fd d Zd d ZejeejddddZddZddZddZddZedddZZ S)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:: >>> # 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) Nrrr rTr) r(r)r*r+rr,r-r.r/c sd| | d} t|}t|}t|tr(|nt|}t|}tj||||||dtd||| f | dSNr3Fr)r isinstancerr<rL r'r(r)r*r+rr,r-r.r/r0r1rGrJr r!r29s( zConv1d.__init__cCsdS)NZQuantizedConv1dr rMr r r! _get_nameQszConv1d._get_namerVrWrcCsV|jdkr.tjj|||j|j|j|j|_ n$tjj|||jt d|j|j|_ dSNrr) r/rAr quantizedZconv1d_prepackr+rr,r-_packed_paramsrrYr r r!rFTs" zConv1d.set_weight_biascCstjj|j\}}||fSr$)rArrZ conv1d_unpackrrYr r r!rN]szConv1d._weight_biascCs |dSNrrNrMr r r!rSasz Conv1d.weightcCs |dSNr rrMr r r!r.dsz 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!forwardgs zConv1d.forwardFcCstj|||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#rrxryrr r r!rsszConv1d.from_float)r rr r TrNN)F)!rrr__doc__rorrnniqatZConvBn1drnniZ ConvReLU1drr__annotations__rr\rboolrr2rrATensorrrFrNrSr.rrrrr r rJr!rsB "    cseZdZdZejZejZ e j Z e j Ze jZdfdd Zd d Zejeejdd d d ZddZddZddZddZedddZZS)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) r rTrNc sV| | d} t|}t|}t|}t|}tj||||||dtd||| f | dSr)rr<rLrrJr r!r2s( zConv2d.__init__cCsdS)NZQuantizedConv2dr rMr r r!rszConv2d._get_namercCsV|jdkr.tjj|||j|j|j|j|_ n$tjj|||jt d|j|j|_ dSr) r/rArrZconv2d_prepackr+rr,r-rrrYr r r!rFs" zConv2d.set_weight_biascCs |jSr$runpackrMr r r!rNszConv2d._weight_biascCs |dSrrrMr r r!rSsz Conv2d.weightcCs |dSrrrMr r r!r.sz Conv2d.biascCsTt|jdkrtd|jdkr>> # 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) Nrrr rTrc sf| dkstd| | d} t|}t|}t|}t|}tj||||||dtd||| f | dS)Nrz*Conv3d does not support reflection paddingr3Fr)rvr r<rLrrJr r!r2s* zConv3d.__init__cCsdS)NZQuantizedConv3dr rMr r r!rszConv3d._get_namercCsV|jdkr.tjj|||j|j|j|j|_ n$tjj|||jt d|j|j|_ dSr) r/rArrZconv3d_prepackr+rr,r-rr rYr r r!rF!s" zConv3d.set_weight_biascCs |jSr$rrMr r r!rN)szConv3d._weight_biascCs |dSrrrMr r r!rS,sz Conv3d.weightcCs |dSrrrMr r r!r./sz Conv3d.biascCsTt|jdkrtd|jdkrszConv3d.from_float)r rr r TrNN)F)rrrrrorrrZConvBn3drrZ ConvReLU3drrrrr2rrArrrFrNrSr.rrrrr r rJr!rs. %   MOD)boundcs`eZdZeZd fdd ZeeeeeeeedddZe d dd Z e d d Z Z S)_ConvTransposeNdNc sL| dkrtd|jj| | d}tj||||||||| | | f |dS)Nrz+Only "zeros" padding mode is supported for r3)r=rKrr<rL)r'r(r)r*r+rr,r>r?r-r.r/r0r1rGrJr r!r2Ps$ z_ConvTransposeNd.__init__)r*r,rrcCsNtjttg}tt|D]*}||||d||}||q|Sr)rArZannotaterr\rrr)r'r*r,rresZkdxrr r r!_input_padding]s  z_ConvTransposeNd._input_paddingFc 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)rrrmrvrrurSr1rArCr rEr(r)r*r+rr?r-r.r,r/rFrzrwr4r\r5) rxryrmsgr{rHr|r}r~r r r!rds:      z_ConvTransposeNd.from_floatcCsn||j|j|j|j|j|j|j|jdk |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 Nr3)r(r)r*r+rr?r-r.r,r/rSr0r1rrFrEr4r\r5)rx ref_qconvtrrr|rHr r r!rs&    z_ConvTransposeNd.from_reference)NN)F)rrrrrr2rr\rrrrrrr r rJr!rLs $ 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.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]) r rTrNc  sZ| | d} t|}t|}t|}t| } t|}tj|||||| d|||| f | dSNr3T)rr<r2r'r(r)r*r+rr?r-r.r,r/r0r1rGrJr r!r2s* zConvTranspose1d.__init__cCsdS)NZQuantizedConvTranspose1dr rMr r r!rszConvTranspose1d._get_namerc Cs*tjj|||j|j|j|j|j|_ dSr$) rArrZconv_transpose1d_prepackr+rr?r,r-rrYr r r!rFszConvTranspose1d.set_weight_biascCstjj|j\}}||fSr$)rArrZconv_transpose1d_unpackrrYr r r!rNszConvTranspose1d._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=rArrZconv_transpose1drr4r5r'rr r r!rszConvTranspose1d.forwardcCst||||Sr$rrrxrrrr r r!rszConvTranspose1d.from_reference) r rrr Tr rNN)rrrrrorrr2rrArrrFrNrSr.rrrrr r rJr!rs(+c sveZdZdZejZdfdd Zd d Ze j e e j dd d d Z ddZ ddZddZddZeddZZS)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]) r rTrNc  sZ| | d} t|}t|}t|}t| } t|}tj|||||| d|||| f | dSr)rr<r2rrJr r!r2)s* zConvTranspose2d.__init__cCsdS)NZQuantizedConvTranspose2dr rMr r r!r7szConvTranspose2d._get_namerc Cs*tjj|||j|j|j|j|j|_ dSr$) rArrZconv_transpose2d_prepackr+rr?r,r-rrYr r r!rF:szConvTranspose2d.set_weight_biascCstjj|j\}}||fSr$)rArrZ conv2d_unpackrrYr r r!rN?szConvTranspose2d._weight_biascCs|\}}|Sr$rrr r r!rSCs zConvTranspose2d.weightcCs|\}}|Sr$rrr r r!r.Gs zConvTranspose2d.biascCs.t|jdkrtdtj||j|j|jS)Nr`r) rrr=rrZconv_transpose2drr4r5rr r r!rKszConvTranspose2d.forwardcCst||||Sr$rrr r r!rSszConvTranspose2d.from_reference) r rrr Tr rNN)rrrrrorrr2rrArrrFrNrSr.rrrrr r rJr!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.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]) r rTrNc  sZ| | d} t|}t|}t|}t| } t|}tj|||||| d|||| f | dSr)r r<r2rrJr r!r2s* zConvTranspose3d.__init__cCsdS)NZQuantizedConvTranspose3dr rMr r r!rszConvTranspose3d._get_namerc Cs*tjj|||j|j|j|j|j|_ dSr$) rArrZconv_transpose3d_prepackr+rr?r,r-rrYr r r!rFszConvTranspose3d.set_weight_biascCstjj|j\}}||fSr$)rArrZ conv3d_unpackrrYr r r!rNszConvTranspose3d._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)rrrrrorrr2rrArrrFrNrSr.rrrrr r rJr!rXs(+).rtypingrrrrAZtorch.nnroZtorch.nn.functionalZ functionalrZtorch.ao.nn.intrinsicZaoZ intrinsicrZtorch.ao.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     mnefT][