
    shh!                        S r SSKrSSKrSSKJr  SSKJrJrJ	r	J
r
  \R                  R                  R                  r\R                  S5        S\;   a"  \" \\\	\
/5      (       a  \R                  S5         SS jrSS\R$                  4S jrS	 rSS
\R$                  4S jrS\R,                  4S jrS rS r\S 5       r\S 5       rS rS rS rS rS r S r!S r"S r#S r$g)z`Importing this file includes common utility methods for checking quantized
tensors and modules.
    N)contextmanager)TEST_WITH_TSANIS_PPCIS_MACOS
IS_WINDOWSnoneqnnpackc                 p    [         R                  " U SU-  -   U-
  US-
  US-
  -  -
  U-  5      SU-  -   S-   $ )z7Computes the output shape given convolution parameters.      )npfloor)
input_sizekernel_sizepaddingstridedilationoutput_paddings         |/Users/tiagomarins/Projetos/claudeai/copy_bank/venv/lib/python3.13/site-packages/torch/testing/_internal/common_quantized.py_conv_output_shaper      s\     88Z!g+-;{Q 1?& &)/0 134~3EFHIJ J    c                 R   Uc   [         R                  " U5      R                  nUc   [         R                  " U5      R                  n[         R                  " X-  U-   5      R                  [         R                  5      n[         R                  " XcU5      nUR                  U5      nU$ )zQuantizes a numpy array.)r   iinfominmaxroundastypeint64clip)xscale
zero_pointqminqmaxdtypeqxs          r   	_quantizer'      sy    |xx""|xx""	!)j(	)	0	0	:B	4	 B	5	BIr   c                 <    U R                  [        5      U-
  U-  nU$ )zDequantizes a numpy array.)r   float)r&   r!   r"   r    s       r   _dequantizer*   %   s    	5	J	&%/AHr      c                 |    X-  R                  5       U-   n[        R                  " XcU5      R                  U5      nU$ )zdRequantizes a numpy array, i.e., intermediate int32 or int16 values are
converted back to given type)r   r   r   r   )r    
multiplierr"   r#   r$   qtyper&   s          r   _requantizer/   +   s9     .			!J	.B	4	 	'	'	.BIr   Fc                    U[         R                  [         R                  4;   d   eU[         R                  :X  a  U[         R                  :X  d   e[	        U [         R
                  5      (       a  U R                  5       n U[         R                  :X  a  U(       a  Su  pEOSu  pEOU(       a  Su  pEOSu  pEU R                  5       nU R                  5       nU[         R                  :H  nXg:X  a  Sn	Sn
OU(       aS  [        Xv* 5      nU* nXv-
  XT-
  -  n	[        U	[        R                  " [        R                  5      R                  5      n	Sn
O[        US5      n[        US5      nXv-
  XT-
  -  n	[        U	[        R                  " [        R                  5      R                  5      n	U[        Xi-  5      -
  n
[        XJ5      n
[        XZ5      n
[        U	5      [        U
5      /$ )tCalculate the dynamic quantization parameters (scale, zero_point)
according to the min and max element of the tensor)i?   )i   )r   r3   )r   r+         ?r           )torchper_tensor_affineper_tensor_symmetricqint8
isinstanceTensornumpyr   r   r   finfofloat32epsr   r)   int)Xr%   reduce_rangeqschemer#   r$   min_valmax_valis_symmetricr!   r"   s              r   _calculate_dynamic_qparamsrG   2   s    u..0J0JKKKK%,,,###!U\\""GGI JD$"JD$JD$JDeegGeegGu999L
'8,GhG&4;7Erxx

3778EJ'3'G'3'G&4;7Erxx

3778Ego 66JT.JT.J%L#j/**r   c                 l   [        U [        R                  5      (       a  U R                  5       n [        R                  " U5      R
                  [        R                  " U5      R                  p2X2-
  n[        R                  " U R                  S   [        R                  S9n[        R                  " U R                  S   [        R                  S9n[        UR                  S   5       H  nU R                  5       nU R                  5       n	X:X  a
  SXW'   SXg'   M2  [        U	S5      n	[        US5      nX-
  U-  XW'   [        XW   [        R                  " [        R                  5      R                  5      XW'   U[!        XU   -  5      -
  Xg'   [        X&U   5      Xg'   [        X6U   5      Xg'   M     XV4$ )r1   r   )r%   r4   r5   )r:   r6   r;   r<   r   r   r   r   zerosshapefloat64r   ranger=   r>   r?   r   )
rA   r%   r#   r$   n_levelsr!   r"   irD   rE   s
             r   &_calculate_dynamic_per_channel_qparamsrO   [   sU    !U\\""GGIU#''U);)?)?${HHHQWWQZrzz2E!''!*BHH5J:##A&'%%'%%'EHJM'3'G'3'G)X5EH58RXXbjj%9%=%=>EH 58);#<<JMm4JMm4JM ( r   c                    [        U [        [        45      (       aN  [        U 5      [        U5      :X  d   e[	        [        U 5      5       Vs/ s H  n[        X   X   5      PM     nnU$ UR                  (       a  UR                  5       nU R                  (       a  U R                  5       n X-
  R                  5       nUS:X  a  S[        S5      [        S5      4$ U R                  5       nXT-  nSUR                  5       -  nXTU4$ s  snf )a  Calculates the signal to noise ratio and returns the signal and noise
power, as well as the SNR in dB.
If the input is a list/tuple this function is called recursively on each
element. The result will have the same nested structure as the inputs.

Args:
    x, x_hat: Either a tensor or a nested list/tuple of tensors.
Returns:
    signal, noise, SNR(in dB): Either floats or a nested list of floats
r   r5   inf   )r:   listtuplelenrL   _snris_quantized
dequantizenormr)   log10)r    x_hatidxresnoisesignalsnrsnr_dbs           r   rV   rV   u   s     !dE]##1vU###38Q=A=CtAFEJ'=A
  "~~LLNYEzE%L%,..VVXF
.C#))+F&   Bs   Dc              #   "  #    [         R                  R                  R                  nU [         R                  R                  l         S v   U[         R                  R                  l        g ! U[         R                  R                  l        f = f7fNr6   backends	quantizedengine)qenginepreviouss     r   override_quantized_enginerj      sX     ~~''..H&-ENN#3*2  '(  's   ABA+  B+!BBc              #     #     U (       a  [         R                  R                  5         S v   U (       a  [         R                  R                  5         g g ! U (       a  [         R                  R                  5         f f = f7frc   )r6   _C!_set_default_mobile_cpu_allocator#_unset_default_mobile_cpu_allocator)qengine_is_qnnpacks    r   "override_cpu_allocator_for_qnnpackrp      sQ     ;HH668HH88: HH88: s   A?)A 'A?(A<<A?c                    ^  U 4S jnU$ )Nc                  |   > [          H  n[        U5         T" U 0 UD6  S S S 5        M!     g ! , (       d  f       M3  = frc   )supported_qenginesrj   )argskwargsrh   	qfunctions      r   test_fn"override_qengines.<locals>.test_fn   s1    )G*734*6* 43 *33s   	,
;	 )rv   rw   s   ` r   override_qenginesrz      s    +
 Nr   c                  P    [         R                  R                  R                  S:H  $ )Nfbgemmrd   ry   r   r   qengine_is_fbgemmr}          >>##**h66r   c                  P    [         R                  R                  R                  S:H  $ )Nr	   rd   ry   r   r   ro   ro      s    >>##**i77r   c                  P    [         R                  R                  R                  S:H  $ )Nonednnrd   ry   r   r   qengine_is_onednnr      r~   r   c                  P    [         R                  R                  R                  S:H  $ )Nx86rd   ry   r   r   qengine_is_x86r      s    >>##**e33r   c                     [        [        U R                  5       5      5      nSX!'   XS'   U R                  [	        U5      5      nX24$ )Nr   )rS   rL   dimpermuterT   )rA   axisnew_axis_listys       r   _permute_to_axis_zeror      sB    quuw(MM!			%&'Ar   c           	         U R                   n[        U R                  [        R                  5      U5      u  p[        R
                  " U 5      n[        U R                  5       S   5       HI  n	[        R                  " [        R                  " X	   SX   -  -  X)   -   5      XE5      X)   -
  X   -  X'   MK     UR                  [        U5      5      n
U
R                  U5      $ Nr   r4   )r%   r   tor6   r>   
zeros_likerL   sizeclampr   r   rT   )rA   per_channel_scaleper_channel_zero_pointr   	quant_min	quant_maxr%   permute_axis_listr]   rN   outs              r   +_fake_quantize_per_channel_affine_referencer      s    GGE0emm1DdKA


1
C1668A;++ekk!$#8I8L2L*M(++, -.7DF\F_`ctcwx   ++e-.
/C66%=r   c                    UR                   n[        UR                  [        R                  5      U5      u  p[        R
                  " U5      n	[        UR                  5       S   5       H*  n
[        R                  " X   SX*   -  -  X:   -   5      X'   M,     U	R                  [        U5      5      n	X:  X:*  -  n[        R
                  " U 5      nX   X'   UR                  U5      $ r   )r%   r   r   r6   r>   r   rL   r   r   r   rT   )dYrA   r   r   r   r   r   r%   r   XqrN   maskr]   s                r   0_fake_quantize_per_channel_affine_grad_referencer      s    GGE0emm1DdKA			!	B1668A;ADC*;*>$>?BXB[[\  	E+,	-BO0D


2
CCI66%=r   c                    [        U [        R                  5      (       d  [        R                  " U 5      n OU R	                  5       R                  5       n U R                  [        R                  " U5      [        R                  S9$ )N)devicer%   )	r:   r6   r;   tensordetachcloner   r   r>   )rA   r   s     r   	to_tensorr      sT    a&&LLOHHJ44u||F+5==4AAr   )r   )%__doc__r<   r   r6   
contextlibr   $torch.testing._internal.common_utilsr   r   r   r   re   rf   supported_enginesrs   removeanyr   uint8r'   r*   r/   r7   rG   rO   rV   rj   rp   rz   r}   ro   r   r   r   r   r   r   ry   r   r   <module>r      s     % ] ]^^--??    & ! ""sFNHj+Y'Z'Zi( '(J *.D 	 12288  7<UE\E\ '+R4!6 3 3 ; ;7874

Br   