Ë
    P/æj>¦  ã                   óì  — d Z ddlmZmZmZ ddlZddlmc mc m	Z
 ddlmc mc m	c mZ ddlmZ ddlmc mZ ddlmZ ddlmZ ddlmZmZmZ ddlmZ dd	lmZmZ g d
¢ZddhZ dee!   dee!   fd„Z" G d„ de«      Z# G d„ de#«      Z$ G d„ de#«      Z% G d„ de#«      Z& edejN                  jP                  jF                  ¬«      Z) G d„ de#«      Z* G d„ de*«      Z+ G d„ de*«      Z, G d „ d!e*«      Z-y)"zQuantized convolution modules.é    )ÚListÚOptionalÚTypeVarN)Úops)Ú	_size_1_t)Ú_pairÚ_singleÚ_triple)Úfuse_conv_bn_weightsé   )Ú_quantize_weightÚWeightedQuantizedModule)ÚConv1dÚConv2dÚConv3dÚConvTranspose1dÚConvTranspose2dÚConvTranspose3dÚzerosÚreflectÚpaddingÚreturnc                 ó”   — g }t        | «      }t        |«      D ],  }t        d«      D ]  }|j                  | ||z
  dz
     «       Œ Œ. |S )Né   r   )ÚlenÚrangeÚappend)r   Ú _reversed_padding_repeated_twiceÚNÚidxÚ_s        úe/root/repos/pocs/video-evals/.venv/lib/python3.12/site-packages/torch/ao/nn/quantized/modules/conv.pyÚ_reverse_repeat_paddingr#      s^   € Ø24Ð$ÜˆG‹€AÜ�Q‹xò JˆÜ�q“ò 	JˆAØ,×3Ñ3°G¸AÀ¹GÀa¹KÑ4HÕIñ	JðJð ,Ð+ó    c                   ó  ‡ — e Zd Z	 	 	 	 	 	 	 	 dd„Z	 	 	 d	 dˆ fd„Zd„ Zd„ Zd„ Zd„ Zˆ fd„Z	e
j                  j                  d„ «       Zˆ fd	„Ze
j                  j                  d
„ «       Zd„ Zd„ Zedd„«       Zedd„«       Zed„ «       Zˆ xZS )Ú_ConvNdc                 ó   — t         ‚©N©ÚNotImplementedError)ÚselfÚin_channelsÚout_channelsÚkernel_sizeÚstrider   ÚdilationÚgroupsÚbiasÚpadding_modeÚdeviceÚdtypes               r"   Ú__init__z_ConvNd.__init__)   s
   € ô "Ð!r$   c           
      óD  •— ||dœ}t         ‰| �  «        ||	z  dk7  rt        d«      ‚||	z  dk7  rt        d«      ‚|| _        || _        || _        || _        || _        || _        || _	        || _
        |	| _        |t        vrt        d|› d�«      ‚|| _        | j                  r||| j                  z  g}n||| j                  z  g}t        j                  |t!        |«      z   fddt        j"                  dœ|j%                  «       D ��ci c]  \  }}|d	k7  sŒ||“Œ c}}¤Ž}|
rNt        j&                  |fd	t        j(                  i|j%                  «       D ��ci c]  \  }}|d	k7  sŒ||“Œ c}}¤Žnd }| j+                  ||«       d
| _        d| _        y c c}}w c c}}w )N©r4   r5   r   z'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_pointr5   r5   g      ð?)Úsuperr6   Ú
ValueErrorr,   r-   r.   r/   r   r0   Ú
transposedÚoutput_paddingr1   Ú_SUPPORTED_PADDINGr3   ÚtorchÚ_empty_affine_quantizedÚlistÚqint8Úitemsr   ÚfloatÚset_weight_biasr9   r:   )r+   r,   r-   r.   r/   r   r0   r=   r>   r1   r2   r3   r4   r5   Úfactory_kwargsÚweight_shapeÚkÚvÚqweightÚ
bias_floatÚ	__class__s                       €r"   Ú_initz_ConvNd._init:   sÈ  ø€ ð  %+°UÑ;ˆÜ‰ÑÔà˜Ñ 1Ò$ÜÐFÓGÐGØ˜&Ñ  AÒ%ÜÐGÓHÐHØ&ˆÔØ(ˆÔØ&ˆÔØˆŒØˆŒØ ˆŒØ$ˆŒØ,ˆÔØˆŒØÔ1Ñ1ÜØ! , Ð/YÐZóð ð )ˆÔà�?Š?Ø'¨¸¿¹Ñ)DÐE‰Là(¨+¸¿¹Ñ*DÐEˆLÜ×/Ñ/Øœ4 Ó,Ñ,ð
àØÜ—+‘+ñ	
ð
 !/× 4Ñ 4Ó 6×G™˜˜1¸!¸w»,ˆq�!‰tÓGñ
ˆñ ô �K‰KØñä—k‘kðð %3×$8Ñ$8Ó$:×K™D˜A˜q¸aÀ7»l�1�a‘4ÓKòð ð 	ð 	×Ñ˜W jÔ1ØˆŒ
Øˆ�ùó Hùó Ls   Ä
FÄFÅFÅ(Fc                 ó   — t         ‚r(   r)   )r+   rK   rL   s      r"   rF   z_ConvNd.set_weight_biasy   ó   € Ü!Ð!r$   c                 ó   — t         ‚r(   r)   ©r+   s    r"   r2   z_ConvNd.bias|   rP   r$   c                 ó   — t         ‚r(   r)   rR   s    r"   Ú_weight_biasz_ConvNd._weight_bias   rP   r$   c                 óŒ  — d}| j                   dt        | j                   «      z  k7  r|dz  }| j                  dt        | j                  «      z  k7  r|dz  }| j                  dt        | j                  «      z  k7  r|dz  }| j                  dk7  r|dz  }| j                  «       €|d	z  } |j                  d
i | j                  ¤ŽS )Nzq{in_channels}, {out_channels}, kernel_size={kernel_size}, stride={stride}, scale={scale}, zero_point={zero_point})r   z, padding={padding})r   z, dilation={dilation}z!, output_padding={output_padding}r   z, groups={groups}z, bias=False© )r   r   r0   r>   r1   r2   ÚformatÚ__dict__)r+   Úss     r"   Ú
extra_reprz_ConvNd.extra_repr‚   sÇ   € ðHð 	
ð �<‰<˜4¤# d§l¡lÓ"3Ñ3Ò3ØÐ&Ñ&ˆAØ�=‰=˜D¤3 t§}¡}Ó#5Ñ5Ò5ØÐ(Ñ(ˆAØ×Ñ $¬¨T×-@Ñ-@Ó)AÑ"AÒAØÐ4Ñ4ˆAØ�;‰;˜!ÒØÐ$Ñ$ˆAØ�9‰9‹;ÐØ�ÑˆAØˆq�x‰xÑ(˜$Ÿ-™-Ñ(Ð(r$   c                 ó  •— t         ‰| �  |||«       | j                  «       \  }}|||dz   <   |||dz   <   t        j                  | j
                  «      ||dz   <   t        j                  | j                  «      ||dz   <   y )NÚweightr2   r9   r:   )r;   Ú_save_to_state_dictrT   r@   Útensorr9   r:   )r+   ÚdestinationÚprefixÚ	keep_varsÚwÚbrM   s         €r"   r]   z_ConvNd._save_to_state_dictŸ   s{   ø€ Ü‰Ñ# K°¸ÔCØ×"Ñ"Ó$‰ˆˆAØ)*ˆ�F˜XÑ%Ñ&Ø'(ˆ�F˜V‘OÑ$Ü(-¯©°T·Z±ZÓ(@ˆ�F˜WÑ$Ñ%Ü-2¯\©\¸$¿/¹/Ó-Jˆ�F˜\Ñ)Ò*r$   c                 óN  — | j                  «       \  }}| j                  | j                  | j                  | j                  | j
                  | j                  | j                  | j                  | j                  | j                  ||| j                  | j                  | j                  fS r(   )rT   r,   r-   r.   r/   r   r0   r=   r>   r1   r3   r9   r:   Útraining©r+   rb   rc   s      r"   Ú__getstate__z_ConvNd.__getstate__§   s‰   € à×"Ñ"Ó$‰ˆˆAà×ÑØ×ÑØ×ÑØ�K‰KØ�L‰LØ�M‰MØ�O‰OØ×ÑØ�K‰KØ×ÑØØØ�J‰JØ�O‰OØ�M‰Mð
ð 	
r$   c           	      ód  •— | j                  ||dz      ||dz      «       |j                  |dz   «       |j                  |dz   «       t        ||dz      «      | _        |j                  |dz   «       t	        ||dz      «      | _        |j                  |dz   «       t        ‰| �  |||d|||«       y )Nr\   r2   r9   r:   F)rF   ÚpoprE   r9   Úintr:   r;   Ú_load_from_state_dict)	r+   Ú
state_dictr`   Úlocal_metadataÚstrictÚmissing_keysÚunexpected_keysÚ
error_msgsrM   s	           €r"   rk   z_ConvNd._load_from_state_dict¿   sº   ø€ ð 	×Ñ˜Z¨°Ñ(9Ñ:¸JÀvÐPVÁÑ<WÔXØ�‰�v Ñ(Ô)Ø�‰�v ‘Ô'Ü˜: f¨wÑ&6Ñ7Ó8ˆŒ
Ø�‰�v Ñ'Ô(Ü˜j¨°,Ñ)>Ñ?Ó@ˆŒØ�‰�v Ñ,Ô-Ü‰Ñ%ØØØØØØØõ	
r$   c                 ó8  — |d   | _         |d   | _        |d   | _        |d   | _        |d   | _        |d   | _        |d   | _        |d   | _        |d	   | _        |d
   | _	        | j                  |d   |d   «       |d   | _        |d   | _        |d   | _        y )Nr   r   r   é   é   é   é   é   é   é	   é
   é   é   é   é   )r,   r-   r.   r/   r   r0   r=   r>   r1   r3   rF   r9   r:   re   )r+   Ústates     r"   Ú__setstate__z_ConvNd.__setstate__Ú   s®   € à  ™8ˆÔØ! !™HˆÔØ  ™8ˆÔØ˜A‘hˆŒØ˜Q‘xˆŒØ˜a™ˆŒØ ™(ˆŒØ# A™hˆÔØ˜A‘hˆŒØ! !™HˆÔØ×Ñ˜U 2™Y¨¨b©	Ô2Ø˜2‘YˆŒ
Ø ™)ˆŒØ˜b™	ˆ�r$   c                 óà   — t        | «      j                  t        | «      «      }t        j                  j                  j                  |«       | j                  «       }|j                  |«       |S r(   )ÚtypeÚ__new__r@   ÚnnÚModuler6   rg   r€   )r+   ÚmemoÚnew_instancer   s       r"   Ú__deepcopy__z_ConvNd.__deepcopy__ë   sR   € Ü˜D“z×)Ñ)¬$¨t«*Ó5ˆÜ�‰�‰× Ñ  Ô.Ø×!Ñ!Ó#ˆØ×!Ñ! %Ô(ØÐr$   c                 ó$   — | j                  i «      S r(   )rˆ   rR   s    r"   Ú__copy__z_ConvNd.__copy__ò   s   € Ø× Ñ  Ó$Ð$r$   c                 óª  — |€|j                   j                  «       } ||j                  «       |j                  t        j                  k(  sJ d«       ‚t        |j                  j                  «       |«      } | |j                  |j                  |j                  |j                  |j                  |j                  |j                  |j                  du|j                  «	      }|j!                  ||j                  «       |�|j                  t        j                  k(  r|S |j#                  «       \  }}t        |«      |_        t'        |«      |_        |S )z&Creates a qconv object and returns it.Nú*Weight observer must have a dtype of qint8)Úqconfigr\   r5   r@   rC   r   rE   r,   r-   r.   r/   r   r0   r1   r2   r3   rF   Úcalculate_qparamsr9   rj   r:   )ÚclsÚmodÚactivation_post_processÚweight_post_processrK   ÚqconvÚ	act_scaleÚact_zps           r"   Ú	get_qconvz_ConvNd.get_qconvõ   s  € ð Ð&Ø"%§+¡+×"4Ñ"4Ó"6ÐÙ˜CŸJ™JÔ'à×%Ñ%¬¯©Ò4ð	8à7ó	8Ø4ä" 3§:¡:×#3Ñ#3Ó#5Ð7JÓKˆáØ�O‰OØ×ÑØ�O‰OØ�J‰JØ�K‰KØ�L‰LØ�J‰JØ�H‰H˜DÐ Ø×Ñó

ˆð 	×Ñ˜g s§x¡xÔ0à#Ð+Ø&×,Ñ,´·±Ò;àˆLà 7× IÑ IÓ KÑˆI�vÜ 	Ó*ˆEŒKÜ" 6›{ˆEÔØˆLr$   c           	      ó¤  — t        |d«      rÚt        |«      | j                  k(  r–t        |j                  |j
                  |j                  j                  |j                  j                  |j                  j                  |j                  j                  |j                  j
                  «      \  |_        |_        t        |d«      sJ d«       ‚|j                  }|j                  }nØt        |«      | j                  k(  sFJ d| j                  z   dz   | j                  j                  z   dz   t        t        |«      «      z   «       ‚t        |d«      sJ d«       ‚t        |d«      sd n|j                  }t        |«      | j                  | j                   | j"                  fv r|d	   }|j$                  j	                  «       }| j'                  |||«      S )
NÚweight_fake_quantr‘   z,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   r\   r2   ÚbnÚrunning_meanÚrunning_varÚepsr˜   r‘   Ú_FLOAT_MODULEÚ__name__ÚstrÚ_NNI_CONV_RELU_MODULEÚ_NNI_CONV_ADD_MODULEÚ_NNI_CONV_ADD_RELU_MODULEr�   r–   )r�   r�   Úuse_precomputed_fake_quantr’   r‘   s        r"   Ú
from_floatz_ConvNd.from_float  sÃ  € ä�3Ð+Ô,ô �C‹y˜C×6Ñ6Ò6Ü';Ø—J‘JØ—H‘HØ—F‘F×'Ñ'Ø—F‘F×&Ñ&Ø—F‘F—J‘JØ—F‘F—M‘MØ—F‘F—K‘Kó(Ñ$�”
˜CœHô ØÐ.ôð >à=ó>ð ð #&×"7Ñ"7ÐØ&)×&AÑ&AÑ#ä˜“9 × 1Ñ 1Ò1ð ØØ—,‘,ñà/ñ0ð ×#Ñ#×,Ñ,ñ-ð ñ	ô
 ”d˜3“i“.ñ!óÐ1ô Ø�Yôð ?à>ó?ð ô
 ˜sÐ$=Ô>ñ à×0Ñ0ð $ô
 �C‹yØ×)Ñ)Ø×(Ñ(Ø×-Ñ-ðñ ð
 ˜!‘f�Ø"%§+¡+×"4Ñ"4Ó"6ÐØ�}‰}˜SÐ"9Ð;NÓOÐOr$   c                 óÌ  —  | |j                   |j                  |j                  |j                  |j                  |j
                  |j                  |j                  du|j                  |j                  j                  |j                  j                  ¬«      }|j                  «       }|j                  ||j                  «       t        |«      |_        t!        |«      |_        |S )a‰  Create 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
        Nr8   )r,   r-   r.   r/   r   r0   r1   r2   r3   r\   r4   r5   Úget_quantized_weightrF   rE   r9   rj   r:   )r�   Ú	ref_qconvÚoutput_scaleÚoutput_zero_pointr“   rK   s         r"   Úfrom_referencez_ConvNd.from_referenceE  sÃ   € ñ Ø×!Ñ!Ø×"Ñ"Ø×!Ñ!Ø×ÑØ×ÑØ×ÑØ×ÑØ�N‰N $Ð&Ø×"Ñ"Ø×#Ñ#×*Ñ*Ø×"Ñ"×(Ñ(ô
ˆð ×0Ñ0Ó2ˆØ×Ñ˜g y§~¡~Ô6Ü˜LÓ)ˆŒÜÐ0Ó1ˆÔØˆr$   ©r   r   r   r   Tr   NN)r   NN)r   Nr(   ©F)r£   Ú
__module__Ú__qualname__r6   rN   rF   r2   rT   rZ   r]   r@   ÚjitÚexportrg   rk   r€   rˆ   rŠ   Úclassmethodr–   Ústaticmethodr©   r¯   Ú__classcell__©rM   s   @r"   r&   r&   (   sâ   ø„ ð ØØØØØØØó"ð: ØØð=ð 
õ=ò~"ò"ò"ò)ô:Kð ‡Y�Y×Ññ
ó ð
ô.
ð6 ‡Y�Y×Ññ"ó ð"ò ò%ð òó ððB ò+Pó ð+PðZ ñó ôr$   r&   c                   ó2  ‡ — e Zd ZU dZej
                  Zej                  Z	e
j                  ZdZded<   dZded<   	 	 	 	 	 	 	 	 ddedededed	ed
edededefˆ fd„Zd„ Zdej.                  deej.                     ddfd„Zd„ Zd„ Zd„ Zd„ Zedd„«       Zˆ x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)

    Nr¦   r§   r,   r-   r.   r/   r   r0   r1   r2   r3   c                 óÒ   •— |
|dœ}t        |«      }t        |«      }t        |t        «      r|n
t        |«      }t        |«      }t        ‰| �  ||||||dt        d«      |||	fi |¤Ž y ©Nr8   Fr   )r	   Ú
isinstancer¤   r;   rN   ©r+   r,   r-   r.   r/   r   r0   r1   r2   r3   r4   r5   rG   rM   s                €r"   r6   zConv1d.__init__‹  s~   ø€ ð %+°UÑ;ˆÜ˜kÓ*ˆÜ˜“ˆÜ'¨´Ô5‘'¼7À7Ó;KˆÜ˜8Ó$ˆô 	‰‰ØØØØØØØÜ�A‹JØØØñ	
ð ó	
r$   c                  ó   — y)NÚQuantizedConv1drV   rR   s    r"   Ú	_get_namezConv1d._get_name°  ó   € Ø r$   rb   rc   r   c                 óŽ  — | j                   dk(  r\t        j                  j                  j	                  ||| j
                  | j                  | j                  | j                  «      | _	        y t        j                  j                  j	                  ||| j
                  t        d«      | j                  | j                  «      | _	        y ©Nr   r   )r3   r@   r   Ú	quantizedÚconv1d_prepackr/   r   r0   r1   Ú_packed_paramsr   rf   s      r"   rF   zConv1d.set_weight_bias³  ó†   € Ø×Ñ Ò'Ü"'§)¡)×"5Ñ"5×"DÑ"DØ�1�d—k‘k 4§<¡<°·±ÀÇÁó#ˆDÕô #(§)¡)×"5Ñ"5×"DÑ"DØ�1�d—k‘k¤5¨£8¨T¯]©]¸D¿K¹Kó#ˆDÕr$   c                 óv   — t         j                  j                  j                  | j                  «      \  }}||fS r(   )r@   r   rÅ   Úconv1d_unpackrÇ   rf   s      r"   rT   zConv1d._weight_bias½  ó/   € Ü�y‰y×"Ñ"×0Ñ0°×1DÑ1DÓE‰ˆˆ1Ø�!ˆtˆr$   c                 ó(   — | j                  «       d   S ©Nr   ©rT   rR   s    r"   r\   zConv1d.weightÁ  ó   € Ø× Ñ Ó" 1Ñ%Ð%r$   c                 ó(   — | j                  «       d   S ©Nr   rÎ   rR   s    r"   r2   zConv1d.biasÄ  rÏ   r$   c                 óZ  — t        |j                  «      dk7  rt        d«      ‚| j                  dk7  r:t	        | j
                  d d «      }t        j                  ||| j                  ¬«      }t        j                  j                  || j                  | j                  | j                  «      S )Nrs   ú Input shape must be `(N, C, L)`!r   r   ©Úmode)r   Úshaper<   r3   r#   r   ÚFÚpadr   rÅ   Úconv1drÇ   r9   r:   ©r+   Úinputr   s      r"   ÚforwardzConv1d.forwardÇ  s“   € ô ˆu�{‰{Ó˜qÒ ÜÐ?Ó@Ð@Ø×Ñ Ò'ä/FÀtÇ|Á|ÐTVÐUVÐGWÓ/XÐ,Ü—E‘EØÐ7¸d×>OÑ>OôˆEô �}‰}×#Ñ#Ø�4×&Ñ&¨¯
©
°D·O±Oó
ð 	
r$   c                 ó2   — t         j                  | ||¬«      S ©zÚCreates 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&   r©   ©r�   r�   r¨   s      r"   r©   zConv1d.from_floatÖ  ó$   € ô ×!Ñ!Ø�Ð1Kð "ó 
ð 	
r$   r°   r±   )!r£   r²   r³   Ú__doc__r„   r   r¢   ÚnniqatÚConvBn1dr�   ÚnniÚ
ConvReLU1dr¥   r¦   Ú__annotations__r§   rj   r   Úboolr¤   r6   rÁ   r@   ÚTensorr   rF   rT   r\   r2   rÜ   r¶   r©   r¸   r¹   s   @r"   r   r   b  s
  ø… ñ ðD —I‘I€MØ#Ÿ_™_ÐØŸN™NÐØ!%Ð˜$Ó%Ø&*Ð˜tÓ*ð ØØØØØ#ØØñ#
àð#
ð ð#
ð ð	#
ð
 ð#
ð ð#
ð ð#
ð ð#
ð ð#
ð õ#
òJ!ð §¡ð °(¸5¿<¹<Ñ2Hð ÈTó òò&ò&ò
ð ò	
ó ô	
r$   r   c                   ó  ‡ — e Zd ZdZej
                  Zej                  Z	e
j                  Ze
j                  Ze
j                  Z	 	 	 	 	 	 	 	 dˆ fd„	Zd„ Zdej(                  deej(                     ddfd„Zd	„ Zd
„ Zd„ Zd„ Zedd„«       Zˆ xZS )r   aµ  Applies 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)

    Nc                 ó®   •— |
|dœ}t        |«      }t        |«      }t        |«      }t        |«      }t        ‰| �  ||||||dt        d«      |||	fi |¤Ž y r¼   )r   r;   rN   r¾   s                €r"   r6   zConv2d.__init__  sq   ø€ ð %+°UÑ;ˆÜ˜KÓ(ˆÜ�v“ˆÜ˜“.ˆÜ˜“?ˆô 	‰‰ØØØØØØØÜ�!‹HØØØñ	
ð ó	
r$   c                  ó   — y)NÚQuantizedConv2drV   rR   s    r"   rÁ   zConv2d._get_name3  rÂ   r$   rb   rc   r   c                 óŽ  — | j                   dk(  r\t        j                  j                  j	                  ||| j
                  | j                  | j                  | j                  «      | _	        y t        j                  j                  j	                  ||| j
                  t        d«      | j                  | j                  «      | _	        y rÄ   )r3   r@   r   rÅ   Úconv2d_prepackr/   r   r0   r1   rÇ   r   rf   s      r"   rF   zConv2d.set_weight_bias6  rÈ   r$   c                 ó6   — | j                   j                  «       S r(   ©rÇ   ÚunpackrR   s    r"   rT   zConv2d._weight_bias@  ó   € Ø×"Ñ"×)Ñ)Ó+Ð+r$   c                 ó(   — | j                  «       d   S rÍ   rÎ   rR   s    r"   r\   zConv2d.weightC  rÏ   r$   c                 ó(   — | j                  «       d   S rÑ   rÎ   rR   s    r"   r2   zConv2d.biasF  rÏ   r$   c                 óT  — t        |j                  «      dk7  rt        d«      ‚| j                  dk7  r7t	        | j
                  «      }t        j                  ||| j                  ¬«      }t        j                  j                  || j                  | j                  | j                  «      S )Nrt   ú#Input shape must be `(N, C, H, W)`!r   rÔ   )r   rÖ   r<   r3   r#   r   r×   rØ   r   rÅ   Úconv2drÇ   r9   r:   rÚ   s      r"   rÜ   zConv2d.forwardI  sŠ   € ô ˆu�{‰{Ó˜qÒ ÜÐBÓCÐCØ×Ñ Ò'Ü/FÀtÇ|Á|Ó/TÐ,Ü—E‘EØÐ7¸d×>OÑ>OôˆEô �}‰}×#Ñ#Ø�4×&Ñ&¨¯
©
°D·O±Oó
ð 	
r$   c                 ó2   — t         j                  | ||¬«      S rÞ   rß   rà   s      r"   r©   zConv2d.from_floatW  rá   r$   r°   r±   )r£   r²   r³   râ   r„   r   r¢   rã   ÚConvBn2dr�   rå   Ú
ConvReLU2dr¥   Ú	ConvAdd2dr¦   ÚConvAddReLU2dr§   r6   rÁ   r@   ré   r   rF   rT   r\   r2   rÜ   r¶   r©   r¸   r¹   s   @r"   r   r   ã  s²   ø„ ñ$ðJ —I‘I€MØ#Ÿ_™_ÐØŸN™NÐØŸ=™=ÐØ #× 1Ñ 1Ðð ØØØØØØØõ"
òH!ð §¡ð °(¸5¿<¹<Ñ2Hð ÈTó ò,ò&ò&ò
ð ò	
ó ô	
r$   r   c                   ó  ‡ — e Zd ZU dZej
                  Zej                  Z	e
j                  ZdZded<   dZded<   	 	 	 	 	 	 	 	 dˆ fd„	Zd„ Zdej&                  deej&                     d	dfd
„Zd„ Zd„ Zd„ Zd„ Zedd„«       Zˆ xZS )r   aÍ  Applies 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)

    Nr¦   r§   c                 óÆ   •— |	dk7  sJ d«       ‚|
|dœ}t        |«      }t        |«      }t        |«      }t        |«      }t        ‰| �  ||||||dt        d«      |||	fi |¤Ž y )Nr   z*Conv3d does not support reflection paddingr8   Fr   )r
   r;   rN   r¾   s                €r"   r6   zConv3d.__init__�  s‡   ø€ ð ˜yÒ(ÐVÐ*VÓVÐ(Ø$*°UÑ;ˆÜ˜kÓ*ˆÜ˜“ˆÜ˜'Ó"ˆÜ˜8Ó$ˆô 	‰‰ØØØØØØØÜ�A‹JØØØñ	
ð ó	
r$   c                  ó   — y)NÚQuantizedConv3drV   rR   s    r"   rÁ   zConv3d._get_nameµ  rÂ   r$   rb   rc   r   c                 óŽ  — | j                   dk(  r\t        j                  j                  j	                  ||| j
                  | j                  | j                  | j                  «      | _	        y t        j                  j                  j	                  ||| j
                  t        d«      | j                  | j                  «      | _	        y rÄ   )r3   r@   r   rÅ   Úconv3d_prepackr/   r   r0   r1   rÇ   r
   rf   s      r"   rF   zConv3d.set_weight_bias¸  s†   € Ø×Ñ Ò'Ü"'§)¡)×"5Ñ"5×"DÑ"DØ�1�d—k‘k 4§<¡<°·±ÀÇÁó#ˆDÕô #(§)¡)×"5Ñ"5×"DÑ"DØ�1�d—k‘k¤7¨1£:¨t¯}©}¸d¿k¹kó#ˆDÕr$   c                 ó6   — | j                   j                  «       S r(   rñ   rR   s    r"   rT   zConv3d._weight_biasÂ  ró   r$   c                 ó(   — | j                  «       d   S rÍ   rÎ   rR   s    r"   r\   zConv3d.weightÅ  rÏ   r$   c                 ó(   — | j                  «       d   S rÑ   rÎ   rR   s    r"   r2   zConv3d.biasÈ  rÏ   r$   c                 óT  — t        |j                  «      dk7  rt        d«      ‚| j                  dk7  r7t	        | j
                  «      }t        j                  ||| j                  ¬«      }t        j                  j                  || j                  | j                  | j                  «      S )Nru   z&Input shape must be `(N, C, D, H, W)`!r   rÔ   )r   rÖ   r<   r3   r#   r   r×   rØ   r   rÅ   Úconv3drÇ   r9   r:   rÚ   s      r"   rÜ   zConv3d.forwardË  sŠ   € ô ˆu�{‰{Ó˜qÒ ÜÐEÓFÐFØ×Ñ Ò'Ü/FÀtÇ|Á|Ó/TÐ,Ü—E‘EØÐ7¸d×>OÑ>OôˆEô �}‰}×#Ñ#Ø�4×&Ñ&¨¯
©
°D·O±Oó
ð 	
r$   c                 ó2   — t         j                  | ||¬«      S rÞ   rß   rà   s      r"   r©   zConv3d.from_floatÙ  rá   r$   r°   r±   )r£   r²   r³   râ   r„   r   r¢   rã   ÚConvBn3dr�   rå   Ú
ConvReLU3dr¥   r¦   rç   r§   r6   rÁ   r@   ré   r   rF   rT   r\   r2   rÜ   r¶   r©   r¸   r¹   s   @r"   r   r   d  s²   ø… ñ$ðJ —I‘I€MØ#Ÿ_™_ÐØŸN™NÐØ!%Ð˜$Ó%Ø&*Ð˜tÓ*ð ØØØØØØØõ#
òJ!ð §¡ð °(¸5¿<¹<Ñ2Hð ÈTó ò,ò&ò&ò
ð ò	
ó ô	
r$   r   ÚMOD)Úboundc            	       óz   ‡ — e Zd ZeZ	 	 d	ˆ fd„	Zdee   dee   dee   dee   fd„Ze	d
d„«       Z
ed„ «       Zˆ xZS )Ú_ConvTransposeNdc                 ó’   •— |dk7  r"t        d| j                  j                  › �«      ‚||dœ}t        ‰| �  |||||||||	|
|fi |¤Ž y )Nr   z+Only "zeros" padding mode is supported for r8   )r<   rM   r£   r;   rN   )r+   r,   r-   r.   r/   r   r0   r=   r>   r1   r2   r3   r4   r5   rG   rM   s                  €r"   r6   z_ConvTransposeNd.__init__í  st   ø€ ð  ˜7Ò"ÜØ=¸d¿n¹n×>UÑ>UÐ=VÐWóð ð %+°UÑ;ˆô 	‰‰ØØØØØØØØØØØñ	
ð ó	
r$   r.   r0   r   r   c                 óØ   — t         j                  j                  t        t           g «      }t        t        |«      «      D ]'  }||   ||   dz
  z  ||   z
  }|j                  |«       Œ) |S rÑ   )r@   r´   Úannotater   rj   r   r   r   )r+   r.   r0   r   ÚresÚkdxrØ   s          r"   Ú_input_paddingz_ConvTransposeNd._input_padding  sj   € ô �i‰i× Ñ ¤¤c¡¨BÓ/ˆÜœ˜[Ó)Ó*ò 	ˆCØ˜3‘- ;¨sÑ#3°aÑ#7Ñ8¸7À3¹<ÑGˆCØ�J‰J�s�Oð	ð ˆ
r$   c                 ó®  — d| j                   z   dz   | j                  j                   z   }t        |«      | j                  k(  sJ |«       ‚t        |d«      sJ d«       ‚|j                  j                  «       } ||j
                  «       |j                  t        j                  k(  sJ d«       ‚t        |j
                  j                  «       |«      } | |j                  |j                  |j                  |j                  |j                  |j                   |j"                  |j$                  du|j&                  |j(                  «
      }|j+                  ||j$                  «       t        |d«      r'|j,                  j                  t        j                  k(  r|S |j,                  j/                  «       \  }}t        |«      |_        t3        |«      |_        |S )zÙCreates 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š   r�   r›   rŒ   Nr‘   )r£   r¢   r‚   rœ   r�   r\   r5   r@   rC   r   rE   r,   r-   r.   r/   r   r>   r1   r2   r0   r3   rF   r‘   rŽ   r9   rj   r:   )	r�   r�   r¨   Úmsgr’   rK   r“   r”   r•   s	            r"   r©   z_ConvTransposeNd.from_float  s•  € ð Ø�l‰lñà+ñ,ð ×Ñ×(Ñ(ñ)ð 	ô �C‹y˜C×-Ñ-Ò-Ð2¨sÓ2Ð-Ü�s˜IÔ&ÐWÐ(WÓWÐ&Ø!Ÿk™k×0Ñ0Ó2ÐÙ˜CŸJ™JÔ'à×%Ñ%¬¯©Ò4ð	8à7ó	8Ø4ä" 3§:¡:×#3Ñ#3Ó#5Ð7JÓKˆáØ�O‰OØ×ÑØ�O‰OØ�J‰JØ�K‰KØ×ÑØ�J‰JØ�H‰H˜DÐ Ø�L‰LØ×Ñó
ˆð 	×Ñ˜g s§x¡xÔ0ä˜Ð6Ô7Ø×*Ñ*×0Ñ0´E·K±KÒ?àˆLà #× ;Ñ ;× MÑ MÓ OÑˆI�vÜ 	Ó*ˆEŒKÜ" 6›{ˆEÔØˆLr$   c                 óâ  —  | |j                   |j                  |j                  |j                  |j                  |j
                  |j                  |j                  du|j                  |j                  |j                  j                  |j                  j                  ¬«      }|j                  «       }|j                  ||j                  «       t        |«      |_        t#        |«      |_        |S )a‹  Create 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
        Nr8   )r,   r-   r.   r/   r   r>   r1   r2   r0   r3   r\   r4   r5   r«   rF   rE   r9   rj   r:   )r�   Ú
ref_qconvtr­   r®   r“   rK   s         r"   r¯   z_ConvTransposeNd.from_referenceK  sÌ   € ñ Ø×"Ñ"Ø×#Ñ#Ø×"Ñ"Ø×ÑØ×ÑØ×%Ñ%Ø×ÑØ�O‰O 4Ð'Ø×ÑØ×#Ñ#Ø×$Ñ$×+Ñ+Ø×#Ñ#×)Ñ)ô
ˆð ×1Ñ1Ó3ˆØ×Ñ˜g z§¡Ô7Ü˜LÓ)ˆŒÜÐ0Ó1ˆÔØˆr$   )NNr±   )r£   r²   r³   r  r¢   r6   r   rj   r  r¶   r©   r·   r¯   r¸   r¹   s   @r"   r  r  ê  st   ø„ Ø€Mð Øõ$
ðLØ ™9ðØ04°S±	ðØDHÈÁIðà	ˆc‰óð ò,ó ð,ð\ ñó ôr$   r  c                   ó¾   ‡ — e Zd ZdZej
                  Z	 	 	 	 	 	 	 	 	 dˆ fd„	Zd„ Zde	j                  dee	j                     ddfd„Zd	„ Zd
„ Zd„ Zd„ Zed„ «       Zˆ xZS )r   aÏ  Applies 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])
    Nc                 ó²   •— ||dœ}t        |«      }t        |«      }t        |«      }t        |	«      }	t        |«      }t        ‰| �  ||||||	d||||
fi |¤Ž y ©Nr8   T)r	   r;   r6   ©r+   r,   r-   r.   r/   r   r>   r1   r2   r0   r3   r4   r5   rG   rM   s                 €r"   r6   zConvTranspose1d.__init__—  óx   ø€ ð %+°UÑ;ˆÜ˜kÓ*ˆÜ˜“ˆÜ˜'Ó"ˆÜ˜8Ó$ˆÜ  Ó0ˆä‰ÑØØØØØØØØØØØñ	
ð ó	
r$   c                  ó   — y)NÚQuantizedConvTranspose1drV   rR   s    r"   rÁ   zConvTranspose1d._get_name¼  ó   € Ø)r$   rb   rc   r   c           	      óÐ   — t         j                  j                  j                  ||| j                  | j
                  | j                  | j                  | j                  «      | _	        y r(   )
r@   r   rÅ   Úconv_transpose1d_prepackr/   r   r>   r0   r1   rÇ   rf   s      r"   rF   zConvTranspose1d.set_weight_bias¿  óJ   € Ü#Ÿi™i×1Ñ1×JÑJØØØ�K‰KØ�L‰LØ×ÑØ�M‰MØ�K‰Kó
ˆÕr$   c                 óv   — t         j                  j                  j                  | j                  «      \  }}||fS r(   )r@   r   rÅ   Úconv_transpose1d_unpackrÇ   rf   s      r"   rT   zConvTranspose1d._weight_biasÊ  s/   € Ü�y‰y×"Ñ"×:Ñ:¸4×;NÑ;NÓO‰ˆˆ1Ø�!ˆtˆr$   c                 ó,   — | j                  «       \  }}|S r(   rÎ   ©r+   rb   r!   s      r"   r\   zConvTranspose1d.weightÎ  ó   € Ø×"Ñ"Ó$‰ˆˆAØˆr$   c                 ó,   — | j                  «       \  }}|S r(   rÎ   ©r+   r!   rc   s      r"   r2   zConvTranspose1d.biasÒ  r)  r$   c                 óÜ   — t        |j                  «      dk7  rt        d«      ‚t        j                  j
                  j                  || j                  | j                  | j                  «      S )Nrs   rÓ   )
r   rÖ   r<   r@   r   rÅ   Úconv_transpose1drÇ   r9   r:   ©r+   rÛ   s     r"   rÜ   zConvTranspose1d.forwardÖ  sU   € ô ˆu�{‰{Ó˜qÒ ÜÐ?Ó@Ð@Ü�y‰y×"Ñ"×3Ñ3Ø�4×&Ñ&¨¯
©
°D·O±Oó
ð 	
r$   c                 ó2   — t         j                  | |||«      S r(   ©r  r¯   ©r�   r  r­   r®   s       r"   r¯   zConvTranspose1d.from_referenceß  ó   € ä×.Ñ.Ø�˜\Ð+<ó
ð 	
r$   ©	r   r   r   r   Tr   r   NN)r£   r²   r³   râ   r„   r   r¢   r6   rÁ   r@   ré   r   rF   rT   r\   r2   rÜ   r¶   r¯   r¸   r¹   s   @r"   r   r   i  ó�   ø„ ñ)ðV ×&Ñ&€Mð ØØØØØØØØõ#
òJ*ð	
 §¡ð 	
°(¸5¿<¹<Ñ2Hð 	
ÈTó 	
òòòò
ð ñ
ó ô
r$   r   c                   ó¾   ‡ — e Zd ZdZej
                  Z	 	 	 	 	 	 	 	 	 dˆ fd„	Zd„ Zde	j                  dee	j                     ddfd„Zd	„ Zd
„ Zd„ Zd„ Zed„ «       Zˆ xZS )r   a~  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])
    Nc                 ó²   •— ||dœ}t        |«      }t        |«      }t        |«      }t        |	«      }	t        |«      }t        ‰| �  ||||||	d||||
fi |¤Ž y r  )r   r;   r6   r  s                 €r"   r6   zConvTranspose2d.__init__  sv   ø€ ð %+°UÑ;ˆÜ˜KÓ(ˆÜ�v“ˆÜ˜“.ˆÜ˜“?ˆÜ˜~Ó.ˆä‰ÑØØØØØØØØØØØñ	
ð ó	
r$   c                  ó   — y)NÚQuantizedConvTranspose2drV   rR   s    r"   rÁ   zConvTranspose2d._get_name7  r!  r$   rb   rc   r   c           	      óÐ   — t         j                  j                  j                  ||| j                  | j
                  | j                  | j                  | j                  «      | _	        y r(   )
r@   r   rÅ   Úconv_transpose2d_prepackr/   r   r>   r0   r1   rÇ   rf   s      r"   rF   zConvTranspose2d.set_weight_bias:  r$  r$   c                 óv   — t         j                  j                  j                  | j                  «      \  }}||fS r(   )r@   r   rÅ   Úconv2d_unpackrÇ   rf   s      r"   rT   zConvTranspose2d._weight_biasE  rË   r$   c                 ó,   — | j                  «       \  }}|S r(   rÎ   r(  s      r"   r\   zConvTranspose2d.weightI  r)  r$   c                 ó,   — | j                  «       \  }}|S r(   rÎ   r+  s      r"   r2   zConvTranspose2d.biasM  r)  r$   c                 óÈ   — t        |j                  «      dk7  rt        d«      ‚t        j                  j                  || j                  | j                  | j                  «      S )Nrt   r÷   )	r   rÖ   r<   r   rÅ   Úconv_transpose2drÇ   r9   r:   r.  s     r"   rÜ   zConvTranspose2d.forwardQ  sO   € ô ˆu�{‰{Ó˜qÒ ÜÐBÓCÐCÜ�}‰}×-Ñ-Ø�4×&Ñ&¨¯
©
°D·O±Oó
ð 	
r$   c                 ó2   — t         j                  | |||«      S r(   r0  r1  s       r"   r¯   zConvTranspose2d.from_referenceZ  r2  r$   r3  )r£   r²   r³   râ   r„   r   r¢   r6   rÁ   r@   ré   r   rF   rT   r\   r2   rÜ   r¶   r¯   r¸   r¹   s   @r"   r   r   æ  s�   ø„ ñ'ðR ×&Ñ&€Mð ØØØØØØØØõ#
òJ*ð	
 §¡ð 	
°(¸5¿<¹<Ñ2Hð 	
ÈTó 	
òòòò
ð ñ
ó ô
r$   r   c                   ó¾   ‡ — e Zd ZdZej
                  Z	 	 	 	 	 	 	 	 	 dˆ fd„	Zd„ Zde	j                  dee	j                     ddfd„Zd	„ Zd
„ Zd„ Zd„ Zed„ «       Zˆ xZS )r   aó  Applies 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])
    Nc                 ó²   •— ||dœ}t        |«      }t        |«      }t        |«      }t        |	«      }	t        |«      }t        ‰| �  ||||||	d||||
fi |¤Ž y r  )r
   r;   r6   r  s                 €r"   r6   zConvTranspose3d.__init__�  r  r$   c                  ó   — y)NÚQuantizedConvTranspose3drV   rR   s    r"   rÁ   zConvTranspose3d._get_name´  r!  r$   rb   rc   r   c           	      óÐ   — t         j                  j                  j                  ||| j                  | j
                  | j                  | j                  | j                  «      | _	        y r(   )
r@   r   rÅ   Úconv_transpose3d_prepackr/   r   r>   r0   r1   rÇ   rf   s      r"   rF   zConvTranspose3d.set_weight_bias·  r$  r$   c                 óv   — t         j                  j                  j                  | j                  «      \  }}||fS r(   )r@   r   rÅ   Úconv3d_unpackrÇ   rf   s      r"   rT   zConvTranspose3d._weight_biasÂ  rË   r$   c                 ó,   — | j                  «       \  }}|S r(   rÎ   r(  s      r"   r\   zConvTranspose3d.weightÆ  r)  r$   c                 ó,   — | j                  «       \  }}|S r(   rÎ   r+  s      r"   r2   zConvTranspose3d.biasÊ  r)  r$   c                 óÈ   — t        |j                  «      dk7  rt        d«      ‚t        j                  j                  || j                  | j                  | j                  «      S )Nru   z&Input shape must be `(N, C, T, H, W)`!)	r   rÖ   r<   r   rÅ   Úconv_transpose3drÇ   r9   r:   r.  s     r"   rÜ   zConvTranspose3d.forwardÎ  sO   € ô ˆu�{‰{Ó˜qÒ ÜÐEÓFÐFÜ�}‰}×-Ñ-Ø�4×&Ñ&¨¯
©
°D·O±Oó
ð 	
r$   c                 ó2   — t         j                  | |||«      S r(   r0  r1  s       r"   r¯   zConvTranspose3d.from_reference×  r2  r$   r3  )r£   r²   r³   râ   r„   r   r¢   r6   rÁ   r@   ré   r   rF   rT   r\   r2   rÜ   r¶   r¯   r¸   r¹   s   @r"   r   r   a  r4  r$   r   ).râ   Útypingr   r   r   r@   Útorch.ao.nn.intrinsicÚaor„   Ú	intrinsicrå   Útorch.ao.nn.intrinsic.qatÚqatrã   Útorch.nnÚtorch.nn.functionalÚ
functionalr×   Ú
torch._opsr   Útorch.nn.common_typesr   Útorch.nn.modules.utilsr   r	   r
   Útorch.nn.utilsr   Úutilsr   r   Ú__all__r?   rj   r#   r&   r   r   r   ÚmodulesÚconvr  r  r   r   r   rV   r$   r"   ú<module>r`     sþ   ðá %ç *Ñ *ã ß #Ó #ß *Ö *Ý ß Ð Ý Ý +ß :Ñ :Ý /ç <ò€ð ˜yÐ)Ð ð, T¨#¡Yð ,°4¸±9ó ,ôwÐ%ô wôt	~
ˆWô ~
ôB~
ˆWô ~
ôB
ˆWô 
ñF ˆe˜2Ÿ:™:Ÿ?™?×2Ñ2Ô3€ô|�wô |ô~z
Ð&ô z
ôzx
Ð&ô x
ôvz
Ð&õ z
r$   