
    %VjiЩ                        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' G d de$          Z( G d de(          Z) G d de(          Z* G d de(          Z+dS ) zQuantized convolution modules.    )ClassVarLiteralOptionalN)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 ]2|                     fdt          d          D                        3|S )Nc              3   4   K   | ]}z
  d z
           V  dS )r   N ).0_Nidxr   s     \/root/voice-cloning/.venv/lib/python3.11/site-packages/torch/ao/nn/quantized/modules/conv.py	<genexpr>z*_reverse_repeat_padding.<locals>.<genexpr>#   s0      /W/WC!0D/W/W/W/W/W/W       )lenrangeextend)r    _reversed_padding_repeated_twicer   r   s   ` @@r    _reverse_repeat_paddingr(      sl    24$GAQxx X X(///W/W/W/W/W/WeTUhh/W/W/WWWWW++r"   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 )_ConvNdr   r   Tr   Nc                     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"   r   c                    ||d}t                                                       ||	z  dk    rt          d          ||	z  dk    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d	 |                                D             }|
r:t          j        |fd
t          j        id |                                D             nd }|                     ||           d| _        d| _        d S )Nr8   r9   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_pointr9   c                 &    i | ]\  }}|d k    ||S r9   r   r   kvs      r    
<dictcomp>z!_ConvNd._init.<locals>.<dictcomp>h   s#    GGG1!w,,q!,,,r"   r9   c                 &    i | ]\  }}|d k    ||S r@   r   rA   s      r    rD   z!_ConvNd._init.<locals>.<dictcomp>n   s#    KKKDAqa7ll1alllr"   g      ?)superr:   
ValueErrorr0   r1   r2   r3   r   r4   
transposedoutput_paddingr5   _SUPPORTED_PADDINGr7   torch_empty_affine_quantizedlistqint8itemsr   floatset_weight_biasr=   r>   )r/   r0   r1   r2   r3   r   r4   rH   rI   r5   r6   r7   r8   r9   factory_kwargsweight_shapeqweight
bias_float	__class__s                     r    _initz_ConvNd._init9   s     %+U;;1$$FGGG& A%%GHHH&(& $,111Z,ZZZ   )? 	F')DELL(+*DEL/4,,,
+	
 

 HG 4 4 6 6GGG
 
 EK k LKN$8$8$:$:KKK    	 	Wj111
r"   c                     t           r,   r-   )r/   rT   rU   s      r    rQ   z_ConvNd.set_weight_biasx       !!r"   c                     t           r,   r-   r/   s    r    r6   z_ConvNd.bias{   rY   r"   c                     t           r,   r-   r[   s    r    _weight_biasz_ConvNd._weight_bias~   rY   r"   c                 Z   d}| j         dt          | j                   z  k    r|dz  }| j        dt          | j                  z  k    r|dz  }| j        dt          | j                  z  k    r|dz  }| j        dk    r|dz  }|                                 |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=Falser   )r   r$   r4   rI   r5   r6   format__dict__)r/   ss     r    
extra_reprz_ConvNd.extra_repr   s    H 	
 <4#dl"3"3333&&A=D3t}#5#5555((A$T-@)A)A"AAA44A;!$$A99;;Aqx(($-(((r"   c                    t                                          |||           |                                 \  }}|||dz   <   |||dz   <   t          j        | j                  ||dz   <   t          j        | j                  ||dz   <   d S )Nweightr6   r=   r>   )rF   _save_to_state_dictr]   rK   tensorr=   r>   )r/   destinationprefix	keep_varswbrV   s         r    re   z_ConvNd._save_to_state_dict   s    ##KCCC""$$A)*FX%&'(FVO$(-TZ(@(@FW$%-2\$/-J-JF\)***r"   c                     |                                  \  }}| j        | j        | j        | j        | j        | j        | j        | j        | j	        | j
        ||| j        | j        | j        fS r,   )r]   r0   r1   r2   r3   r   r4   rH   rI   r5   r7   r=   r>   trainingr/   rj   rk   s      r    __getstate__z_ConvNd.__getstate__   sm    ""$$AKLMOKJOM
 	
r"   c           	         |                      ||dz            ||dz                       |                    |dz              |                    |dz              t          ||dz                      | _        |                    |dz              t	          ||dz                      | _        |                    |dz              t                                          |||d|||           d S )Nrd   r6   r=   r>   F)rQ   poprP   r=   intr>   rF   _load_from_state_dict)	r/   
state_dictrh   local_metadatastrictmissing_keysunexpected_keys
error_msgsrV   s	           r    rs   z_ConvNd._load_from_state_dict   s     	Z(9:JvPV<WXXXv()))v''':fw&6788
v'(((j,)>?@@v,---%%	
 	
 	
 	
 	
r"   c                    |d         | _         |d         | _        |d         | _        |d         | _        |d         | _        |d         | _        |d         | _        |d         | _        |d	         | _        |d
         | _	        | 
                    |d         |d                    |d         | _        |d         | _        |d         | _        d S )Nr   r   r#                     	   
               )r0   r1   r2   r3   r   r4   rH   rI   r5   r7   rQ   r=   r>   rm   )r/   states     r    __setstate__z_ConvNd.__setstate__   s     8!!H 8AhQxa(#AhAh!!HU2Yb	2222Y
)b	r"   c                     t          |                               t          |                     }t          j        j                            |           |                                 }|                    |           |S r,   )type__new__rK   nnModuler:   ro   r   )r/   memonew_instancer   s       r    __deepcopy__z_ConvNd.__deepcopy__   sd    Dzz))$t**55  ...!!##!!%(((r"   c                 ,    |                      i           S r,   )r   r[   s    r    __copy__z_ConvNd.__copy__   s      $$$r"   c                 R   ||j                                         } ||j                   |j        t          j        k    s
J d            t          |j                                        |          } | |j        |j        |j	        |j
        |j        |j        |j        |j        du|j        	  	        }|                    ||j                   ||j        t          j        k    r|S |                                \  }}t          |          |_        t'          |          |_        |S )z&Creates a qconv object and returns it.N*Weight observer must have a dtype of qint8)qconfigrd   r9   rK   rN   r   rP   r0   r1   r2   r3   r   r4   r5   r6   r7   rQ   calculate_qparamsr=   rr   r>   )clsmodactivation_post_processweight_post_processrT   qconv	act_scaleact_zps           r    	get_qconvz_ConvNd.get_qconv   s$    &"%+"4"4"6"6CJ'''"(EK7778 877 #3:#3#3#5#57JKKOOJKLJHD 

 

 	gsx000#+&,;;L 7 I I K KIv	**EK"6{{ELr"   Fc           	      0   t          |d          rt          |          | j        k    r^t          |j        |j        |j        j        |j        j        |j        j	        |j        j        |j        j                  \  |_        |_        t          |d          s
J d            |j
        }|j        }nt          |          | j        k    sBJ 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                                        }|                     |||          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   rd   r6   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+,, )	7 CyyC666';JHF'F&FJFMFK( ($
CH 3 9::  > : #&"7&)&A##99 1111,/0 #,- 	
 d3ii..! 211 3	**  ? *
 s$=>>10 $
 Cyy)(-  
 !f"%+"4"4"6"6}}S"9;NOOOr"   c                 f    | |j         |j        |j        |j        |j        |j        |j        |j        du|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
        Nr<   )r0   r1   r2   r3   r   r4   r5   r6   r7   rd   r8   r9   get_quantized_weightrQ   rP   r=   rr   r>   )r   	ref_qconvoutput_scaleoutput_zero_pointr   rT   s         r    from_referencez_ConvNd.from_referenceD  s     !"!N$&"#*"(
 
 
 0022gy~666L))011r"   r   r   r   r   Tr   NN)r   NN)r   Nr,   F)r   
__module____qualname__r:   rW   rQ   r6   r]   rb   re   rK   jitexportro   rs   r   r   r   classmethodr   staticmethodr   r   __classcell__rV   s   @r    r*   r*   '   s        " " " ": = 
= = = = = =~" " "" " "" " ") ) ):K K K K K Y
 
 
.
 
 
 
 
6 Y" " "   % % %    [B +P +P +P \+PZ   [    r"   r*   c                       e Zd ZU dZej        Zeeej                          e	d<   e
j        Zeeeej                                   e	d<   ej        Zeeeej                                   e	d<   dZeeeej                                   e	d<   dZeeeej                                   e	d<   	 	 	 	 	 	 	 	 d"dededededededededed         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)

    r   r   r   Nr   r   r   r   Tr   r0   r1   r2   r3   r   r4   r5   r6   r7   )r   r   	replicatecircularc                    |
|d}t          |          }t          |          }t          |t                    r|nt          |          }t          |          } t                      j        ||||||dt          d          |||	fi | d S Nr<   Fr   )r	   
isinstancer   rF   rW   r/   r0   r1   r2   r3   r   r4   r5   r6   r7   r8   r9   rR   rV   s                r    r:   zConv1d.__init__  s     %+U;;k**'55K''77;K;K8$$ 	AJJ	
 	
 	
 	
 	
 	
 	
r"   c                     dS )NQuantizedConv1dr   r[   s    r    	_get_namezConv1d._get_name        r"   rj   rk   r   c                 8   | j         dk    rDt          j        j                            ||| j        | j        | j        | j                  | _	        d S t          j        j                            ||| j        t          d          | j        | j                  | _	        d S Nr   r   )r7   rK   r   	quantizedconv1d_prepackr3   r   r4   r5   _packed_paramsr   rn   s      r    rQ   zConv1d.set_weight_bias      ''"')"5"D"D1dk4<# #D #()"5"D"D1dk588T]DK# #Dr"   c                 b    t           j        j                            | j                  \  }}||fS r,   )rK   r   r   conv1d_unpackr   rn   s      r    r]   zConv1d._weight_bias  *    y"001DEE1!tr"   c                 6    |                                  d         S Nr   r]   r[   s    r    rd   zConv1d.weight        ""1%%r"   c                 6    |                                  d         S Nr   r   r[   s    r    r6   zConv1d.bias  r   r"   c                 8   t          |j                  dk    rt          d          | j        dk    r8t	          | j        d d                   }t          j        ||| j                  }t          j	        
                    || j        | j        | j                  S )Nr{    Input shape must be `(N, C, L)`!r   r   mode)r$   shaperG   r7   r(   r   Fpadr   r   conv1dr   r=   r>   r/   inputr'   s      r    forwardzConv1d.forward  s     u{q  ?@@@''/Ft|TVUVTVGW/X/X,E7d>O  E }##4&
DO
 
 	
r"   Fc                 <    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
        )r   r*   r   r   r   r   s      r    r   zConv1d.from_float  )     !!1K " 
 
 	
r"   r   r   )$r   r   r   __doc__r   r   r   r   r   __annotations__nniqatConvBn1dr   r   r   nni
ConvReLU1dr   r   r   rr   r   boolr   r:   r   rK   TensorrQ   r]   rd   r6   r   r   r   r   r   s   @r    r   r   a  s           D 02yM8DO,888BH/HXd29o%>?QQQAD8HT")_$=>OOO@D(8DO#<=DDDEIxbi(ABIII MT#
 #
#
 #
 	#

 #
 #
 #
 #
 #
 IJ#
 #
 #
 #
 #
 #
J! ! ! (5<2H T      & & && & &
 
 
 	
 	
 	
 [	
 	
 	
 	
 	
r"   r   c                       e Zd ZU dZej        Zeeej                          e	d<   e
j        Zeeeej                                   e	d<   ej        Zeeeej                                   e	d<   ej        Zeeej                          e	d<   ej        Zeeej                          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 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   r   r   r   r   r   r   Tr   Nc                     |
|d}t          |          }t          |          }t          |          }t          |          } t                      j        ||||||dt          d          |||	fi | d S r   )r   rF   rW   r   s                r    r:   zConv2d.__init__  s     %+U;;K((v..?? 	!HH	
 	
 	
 	
 	
 	
 	
r"   c                     dS )NQuantizedConv2dr   r[   s    r    r   zConv2d._get_name3  r   r"   rj   rk   r   c                 8   | j         dk    rDt          j        j                            ||| j        | j        | j        | j                  | _	        d S t          j        j                            ||| j        t          d          | j        | j                  | _	        d S r   )r7   rK   r   r   conv2d_prepackr3   r   r4   r5   r   r   rn   s      r    rQ   zConv2d.set_weight_bias6  r   r"   c                 4    | j                                         S r,   r   unpackr[   s    r    r]   zConv2d._weight_bias@      "))+++r"   c                 6    |                                  d         S r   r   r[   s    r    rd   zConv2d.weightC  r   r"   c                 6    |                                  d         S r   r   r[   s    r    r6   zConv2d.biasF  r   r"   c                 (   t          |j                  dk    rt          d          | j        dk    r0t	          | j                  }t          j        ||| j                  }t          j	        
                    || j        | j        | j                  S )Nr|   #Input shape must be `(N, C, H, W)`!r   r   )r$   r   rG   r7   r(   r   r   r   r   r   conv2dr   r=   r>   r   s      r    r   zConv2d.forwardI  s     u{q  BCCC''/Ft|/T/T,E7d>O  E }##4&
DO
 
 	
r"   Fc                 <    t                               | ||          S r   r   r   s      r    r   zConv2d.from_floatW  r   r"   r   r   )"r   r   r   r   r   r   r   r   r   r   r   ConvBn2dr   r   r   r   
ConvReLU2dr   	ConvAdd2dr   ConvAddReLU2dr   r:   r   rK   r   rQ   r]   rd   r6   r   r   r   r   r   s   @r    r   r     s        $ $L 02yM8DO,888BH/HXd29o%>?QQQAD8HT")_$=>OOO:=-(4#67GGGCFCTxS->(?@TTT "
 "
 "
 "
 "
 "
H! ! ! (5<2H T    , , ,& & && & &
 
 
 	
 	
 	
 [	
 	
 	
 	
 	
r"   r   c                       e Zd ZU dZej        Zeeej                          e	d<   e
j        Zeeeej                                   e	d<   ej        Zeeeej                                   e	d<   dZeeeej                                   e	d<   dZeeeej                                   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)

    r   r   r   Nr   r   r   r   Tr   c                    |	dk    s
J d            |
|d}t          |          }t          |          }t          |          }t          |          } t                      j        ||||||dt          d          |||	fi | d S )Nr   z*Conv3d does not support reflection paddingr<   Fr   )r
   rF   rW   r   s                r    r:   zConv3d.__init__  s     y(((*V((($*U;;k**'""8$$ 	AJJ	
 	
 	
 	
 	
 	
 	
r"   c                     dS )NQuantizedConv3dr   r[   s    r    r   zConv3d._get_name  r   r"   rj   rk   r   c                 8   | j         dk    rDt          j        j                            ||| j        | j        | j        | j                  | _	        d S t          j        j                            ||| j        t          d          | j        | j                  | _	        d S r   )r7   rK   r   r   conv3d_prepackr3   r   r4   r5   r   r
   rn   s      r    rQ   zConv3d.set_weight_bias  s    ''"')"5"D"D1dk4<# #D #()"5"D"D1dk71::t}dk# #Dr"   c                 4    | j                                         S r,   r   r[   s    r    r]   zConv3d._weight_bias  r   r"   c                 6    |                                  d         S r   r   r[   s    r    rd   zConv3d.weight  r   r"   c                 6    |                                  d         S r   r   r[   s    r    r6   zConv3d.bias  r   r"   c                 (   t          |j                  dk    rt          d          | j        dk    r0t	          | j                  }t          j        ||| j                  }t          j	        
                    || j        | j        | j                  S )Nr}   z&Input shape must be `(N, C, D, H, W)`!r   r   )r$   r   rG   r7   r(   r   r   r   r   r   conv3dr   r=   r>   r   s      r    r   zConv3d.forward  s     u{q  EFFF''/Ft|/T/T,E7d>O  E }##4&
DO
 
 	
r"   Fc                 <    t                               | ||          S r   r   r   s      r    r   zConv3d.from_float  r   r"   r   r   ) r   r   r   r   r   r   r   r   r   r   r   ConvBn3dr   r   r   r   
ConvReLU3dr   r   r   r:   r   rK   r   rQ   r]   rd   r6   r   r   r   r   r   s   @r    r   r   d  s        $ $L 02yM8DO,888BH/HXd29o%>?QQQAD8HT")_$=>OOO@D(8DO#<=DDDEIxbi(ABIII #
 #
 #
 #
 #
 #
J! ! ! (5<2H T    , , ,& & && & &
 
 
 	
 	
 	
 [	
 	
 	
 	
 	
r"   r   c            	            e Zd ZU eeej        j        j                          e	d<   	 	 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 )_ConvTransposeNdr   Nc                     |dk    rt          d| j        j                   ||d} t                      j        |||||||||	|
|fi | d S )Nr   z+Only "zeros" padding mode is supported for r<   )rG   rV   r   rF   rW   )r/   r0   r1   r2   r3   r   r4   rH   rI   r5   r6   r7   r8   r9   rR   rV   s                  r    r:   z_ConvTransposeNd.__init__  s      7""Wdn>UWW   %+U;; 		
 	
 	
 	
 	
 	
 	
r"   r2   r4   r   r   c                    t           j                            t          t                   g           }t          t          |                    D ]4}||         ||         dz
  z  ||         z
  }|                    |           5|S r   )rK   r   annotaterM   rr   r%   r$   append)r/   r2   r4   r   reskdxr   s          r    _input_paddingz_ConvTransposeNd._input_padding  su     i  cB//[))** 	 	C3-;s#3a#7873<GCJJsOOOO
r"   Fc                 6   d| j         z   dz   | j        j         z   }t          |          | j        k    s
J |            t          |d          s
J d            |j                                        } ||j                   |j        t          j        k    s
J d            t          |j        
                                |          } | |j        |j        |j        |j        |j        |j        |j        |j        du|j        |j        
  
        }|                    ||j                   t          |d          r|j        j        t          j
        k    r|S |j                                        \  }}t          |          |_        t3          |          |_        |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
        r   r   r   r   r   Nr   )r   r   r   r   r   rd   r9   rK   rN   r   rP   r0   r1   r2   r3   r   rI   r5   r6   r4   r7   rQ   r   r   r=   rr   r>   )	r   r   r   msgr   rT   r   r   r   s	            r    r   z_ConvTransposeNd.from_float  s    l+, () 	 CyyC----s---sI&&WW(WWW&!k0022CJ'''"(EK7778 877 #3:#3#3#5#57JKKOOJKJHD L
 
 	gsx000677		*0EK??L # ; M M O OIv	**EK"6{{ELr"   c                 r    | |j         |j        |j        |j        |j        |j        |j        |j        du|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
        Nr<   )r0   r1   r2   r3   r   rI   r5   r6   r4   r7   rd   r8   r9   r   rQ   rP   r=   rr   r>   )r   
ref_qconvtr   r   r   rT   s         r    r   z_ConvTransposeNd.from_referenceK  s     "#"%O4'#$+#)
 
 
 1133gz777L))011r"   )NNr   )r   r   r   r   r   r   modulesconvr*   r   r:   rM   rr   r  r   r   r   r   r   r   s   @r    r  r    s         D!89:::: $
 $
 $
 $
 $
 $
L904S	DHI	c    , , , [,\   \    r"   r  c                        e Zd ZU dZej        Zeeej                          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             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])
    r   r   r   Tr   Nc                     ||d}t          |          }t          |          }t          |          }t          |	          }	t          |          } t                      j        ||||||	d||||
fi | d S Nr<   T)r	   rF   r:   r/   r0   r1   r2   r3   r   rI   r5   r6   r4   r7   r8   r9   rR   rV   s                 r    r:   zConvTranspose1d.__init__       %+U;;k**'""8$$ 00	
 	
 	
 	
 	
 	
 	
r"   c                     dS )NQuantizedConvTranspose1dr   r[   s    r    r   zConvTranspose1d._get_name      ))r"   rj   rk   r   c           	          t           j        j                            ||| j        | j        | j        | j        | j                  | _	        d S r,   )
rK   r   r   conv_transpose1d_prepackr3   r   rI   r4   r5   r   rn   s      r    rQ   zConvTranspose1d.set_weight_bias  E    #i1JJKLMK
 
r"   c                 b    t           j        j                            | j                  \  }}||fS r,   )rK   r   r   conv_transpose1d_unpackr   rn   s      r    r]   zConvTranspose1d._weight_bias  s*    y"::4;NOO1!tr"   c                 4    |                                  \  }}|S r,   r   r/   rj   r   s      r    rd   zConvTranspose1d.weight      ""$$Ar"   c                 4    |                                  \  }}|S r,   r   r/   r   rk   s      r    r6   zConvTranspose1d.bias  r4  r"   c                     t          |j                  dk    rt          d          t          j        j                            || j        | j        | j	                  S )Nr{   r   )
r$   r   rG   rK   r   r   conv_transpose1dr   r=   r>   r/   r   s     r    r   zConvTranspose1d.forward  sU     u{q  ?@@@y"334&
DO
 
 	
r"   c                 <    t                               | |||          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   r   r   r   r:   r   rK   r   r   rQ   r]   rd   r6   r   r   r   r   r   s   @r    r   r   i  "        ) )V 9;8JM8D!345JJJ #
 #
 #
 #
 #
 #
J* * *	
 	
(5<2H 	
T 	
 	
 	
 	
      
 
 
 
 
 [
 
 
 
 
r"   r   c                        e Zd ZU dZej        Zeeej                          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             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])
    r   r   r   Tr   Nc                     ||d}t          |          }t          |          }t          |          }t          |	          }	t          |          } t                      j        ||||||	d||||
fi | d S r'  )r   rF   r:   r(  s                 r    r:   zConvTranspose2d.__init__  s     %+U;;K((v..??~..	
 	
 	
 	
 	
 	
 	
r"   c                     dS )NQuantizedConvTranspose2dr   r[   s    r    r   zConvTranspose2d._get_name7  r,  r"   rj   rk   r   c           	          t           j        j                            ||| j        | j        | j        | j        | j                  | _	        d S r,   )
rK   r   r   conv_transpose2d_prepackr3   r   rI   r4   r5   r   rn   s      r    rQ   zConvTranspose2d.set_weight_bias:  r/  r"   c                 b    t           j        j                            | j                  \  }}||fS r,   )rK   r   r   conv2d_unpackr   rn   s      r    r]   zConvTranspose2d._weight_biasE  r   r"   c                 4    |                                  \  }}|S r,   r   r3  s      r    rd   zConvTranspose2d.weightI  r4  r"   c                 4    |                                  \  }}|S r,   r   r6  s      r    r6   zConvTranspose2d.biasM  r4  r"   c                     t          |j                  dk    rt          d          t          j                            || j        | j        | j                  S )Nr|   r  )	r$   r   rG   r   r   conv_transpose2dr   r=   r>   r9  s     r    r   zConvTranspose2d.forwardQ  sR     u{q  BCCC}--4&
DO
 
 	
r"   c                 <    t                               | |||          S r,   r;  r<  s       r    r   zConvTranspose2d.from_referenceZ  r=  r"   r>  )r   r   r   r   r   r   r   r   r   r   r:   r   rK   r   r   rQ   r]   rd   r6   r   r   r   r   r   s   @r    r   r     s"        ' 'R 9;8JM8D!345JJJ #
 #
 #
 #
 #
 #
J* * *	
 	
(5<2H 	
T 	
 	
 	
 	
      
 
 
 
 
 [
 
 
 
 
r"   r   c                        e Zd ZU dZej        Zeeej                          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             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])
    r   r   r   Tr   Nc                     ||d}t          |          }t          |          }t          |          }t          |	          }	t          |          } t                      j        ||||||	d||||
fi | d S r'  )r
   rF   r:   r(  s                 r    r:   zConvTranspose3d.__init__  r)  r"   c                     dS )NQuantizedConvTranspose3dr   r[   s    r    r   zConvTranspose3d._get_name  r,  r"   rj   rk   r   c           	          t           j        j                            ||| j        | j        | j        | j        | j                  | _	        d S r,   )
rK   r   r   conv_transpose3d_prepackr3   r   rI   r4   r5   r   rn   s      r    rQ   zConvTranspose3d.set_weight_bias  r/  r"   c                 b    t           j        j                            | j                  \  }}||fS r,   )rK   r   r   conv3d_unpackr   rn   s      r    r]   zConvTranspose3d._weight_bias  r   r"   c                 4    |                                  \  }}|S r,   r   r3  s      r    rd   zConvTranspose3d.weight  r4  r"   c                 4    |                                  \  }}|S r,   r   r6  s      r    r6   zConvTranspose3d.bias  r4  r"   c                     t          |j                  dk    rt          d          t          j                            || j        | j        | j                  S )Nr}   z&Input shape must be `(N, C, T, H, W)`!)	r$   r   rG   r   r   conv_transpose3dr   r=   r>   r9  s     r    r   zConvTranspose3d.forward  sR     u{q  EFFF}--4&
DO
 
 	
r"   c                 <    t                               | |||          S r,   r;  r<  s       r    r   zConvTranspose3d.from_reference  r=  r"   r>  )r   r   r   r   r   r   r   r   r   r   r:   r   rK   r   r   rQ   r]   rd   r6   r   r   r   r   r   s   @r    r   r   a  r?  r"   r   ),r   typingr   r   r   rK   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__rJ   rM   rr   r(   r*   r   r   r   r  r   r   r   r   r"   r    <module>ri     s   % % . . . . . . . . . .  # # # # # # # # # # # # * * * * * * * * * * * * * * *                      + + + + + + : : : : : : : : : : / / / / / / < < < < < < < <   y) ,T#Y ,49 , , , ,w w w w w% w w wt	~
 ~
 ~
 ~
 ~
W ~
 ~
 ~
B
 
 
 
 
W 
 
 
D@
 @
 @
 @
 @
W @
 @
 @
L| | | | |w | | |~z
 z
 z
 z
 z
& z
 z
 z
zx
 x
 x
 x
 x
& x
 x
 x
vz
 z
 z
 z
 z
& z
 z
 z
 z
 z
r"   