Ë
    ÌÓ^jkf  ã                   ó  — d Z ddlZddlZddlmZ ddlmZ ddlmZm	Z	m
Z
mZmZ  eej                  j                  j                   «      Zdev r ee	ee
eg«      rej'                  d«       ereD � cg c]	  } | dvsŒ| ‘Œ c} Z	 d5d„Zddej*                  fd	„Zd
„ Zddej*                  fd„Zdej2                  fd„Zd„ Zd„ Zed„ «       Zed„ «       Zd„ Zd„ Z d„ Z!d„ Z"d„ Z#d„ Z$d„ Z%d„ Z&d„ Z'de(de(fd„Z)d\  Z*Z+ e)e*d z
  «      Z,d!ed"e(d#e(defd$„Z-d!ed"e(d#e(defd%„Z.d&„ Z/dej                  fd'„Z0d6d(„Z1dej                  fd)„Z2d*„ Z3dej                  fd+„Z4d,\  Z5Z6d-„ Z7	 	 d7d.ej                  d/e(d0e8fd1„Z9d2ejt                  d3fd4„Z;yc c} w )8z`Importing this file includes common utility methods for checking quantized
tensors and modules.
é    N)ÚTensor)Úcontextmanager)ÚTEST_WITH_TSANÚIS_PPCÚIS_MACOSÚ
IS_WINDOWSÚIS_ARM64Úqnnpack)ÚfbgemmÚx86c                 ón   — t        j                  | d|z  z   |z
  |dz
  |dz
  z  z
  |z  «      d|z  z   dz   S )z7Computes the output shape given convolution parameters.é   é   )ÚnpÚfloor)Ú
input_sizeÚkernel_sizeÚpaddingÚstrideÚdilationÚoutput_paddings         ús/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/torch/testing/_internal/common_quantized.pyÚ_conv_output_shaper      s\   € ô �8‰8�Z ! g¡+Ñ-°Ñ;¸{ÈQ¹Ø  1™ñ?&ñ &Ø)/ñ0ó 1Ø34°~Ñ3EñFØHIñJð Jó    c                 óJ  — |€t        j                  |«      j                  }|€t        j                  |«      j                  }t        j                  | |z  |z   «      j                  t         j                  «      }t        j                  |||«      }|j                  |«      }|S )zQuantizes a numpy array.)r   ÚiinfoÚminÚmaxÚroundÚastypeÚint64Úclip)ÚxÚscaleÚ
zero_pointÚqminÚqmaxÚdtypeÚqxs          r   Ú	_quantizer*      s}   € à€|Ü�x‰x˜‹×"Ñ"ˆØ€|Ü�x‰x˜‹×"Ñ"ˆÜ	�‰�!�e‘)˜jÑ(Ó	)×	0Ñ	0´·±Ó	:€BÜ	�‰��T˜4Ó	 €BØ	�‰�5Ó	€BØ€Ir   c                 ó<   — | j                  t        «      |z
  |z  }|S )zDequantizes a numpy array.)r    Úfloat)r)   r$   r%   r#   s       r   Ú_dequantizer-   )   s   € à	�‰”5Ó	˜JÑ	&¨%Ñ/€AØ€Hr   éÿ   c                 ó~   — | |z  j                  «       |z   }t        j                  |||«      j                  |«      }|S )zhRequantizes 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   Ú_requantizer2   /   s=   € ð ˆj‰.×	Ñ	Ó	! JÑ	.€BÜ	�‰��T˜4Ó	 ×	'Ñ	'¨Ó	.€BØ€Ir   Fc                 óÔ  — |t         j                  t         j                  fvrt        d|› �«      ‚|t         j                  k(  r!|t         j                  k7  rt        d|› �«      ‚t        | t         j                  «      r| j                  «       } |t         j                  k(  r|rd\  }}nd\  }}n|rd\  }}nd\  }}| j                  «       }| j                  «       }|t         j                  k(  }||k(  rd}	d}
nÚ|rUt        || «      }| }||z
  ||z
  z  }	t        |	t        j                  t        j                  «      j                  «      }	d}
nƒt        |d	«      }t        |d	«      }||z
  ||z
  z  }	t        |	t        j                  t        j                  «      j                  «      }	|t        ||	z  «      z
  }
t        ||
«      }
t        ||
«      }
t        |	«      t!        |
«      gS )
úxCalculate the dynamic quantization parameters (scale, zero_point)
    according to the min and max element of the tensorzFExpected qscheme to be per_tensor_affine or per_tensor_symmetric, got z<Expected dtype to be torch.qint8 for symmetric qscheme, got )iÀÿÿÿé?   )i€ÿÿÿé   )r   r6   )r   r.   ç      ð?r   ç        )ÚtorchÚper_tensor_affineÚper_tensor_symmetricÚAssertionErrorÚqint8Ú
isinstancer   Únumpyr   r   r   ÚfinfoÚfloat32Úepsr   r,   Úint)ÚXr(   Úreduce_rangeÚqschemer&   r'   Úmin_valÚmax_valÚis_symmetricr$   r%   s              r   Ú_calculate_dynamic_qparamsrJ   6   sÉ  € ð ”u×.Ñ.´×0JÑ0JÐKÑKÜØTÐU\ÐT]Ð^ó
ð 	
ð ”%×,Ñ,Ò,Ø”E—K‘KÒÜ ØNÈuÈgÐVóð ô �!”U—\‘\Ô"Ø�G‰G‹IˆØ”—‘ÒÙØ ‰JˆD‘$à"‰JˆD‘$áØ‰JˆD‘$à‰JˆD�$Ø�e‰e‹g€GØ�e‰e‹g€GØœu×9Ñ9Ñ9€LØ�'ÒØˆØ‰
áÜ˜' G 8Ó,ˆGØ�hˆGØ˜wÑ&¨4°$©;Ñ7ˆEÜ˜œrŸx™x¬¯
©
Ó3×7Ñ7Ó8ˆEØ‰Jä˜' 3Ó'ˆGÜ˜' 3Ó'ˆGØ˜wÑ&¨4°$©;Ñ7ˆEÜ˜œrŸx™x¬¯
©
Ó3×7Ñ7Ó8ˆEØ¤ g°¡oÓ 6Ñ6ˆJÜ˜T :Ó.ˆJÜ˜T :Ó.ˆJÜ�%‹Lœ#˜j›/Ð*Ð*r   c                 ó|  — t        | t        j                  «      r| j                  «       } t        j                  |«      j
                  t        j                  |«      j                  }}||z
  }t        j                  | j                  d   t        j                  ¬«      }t        j                  | j                  d   t        j                  ¬«      }t        |j                  d   «      D ]Í  }| j                  «       }| j                  «       }	||	k(  rd||<   d||<   Œ3t        |	d«      }	t        |d«      }|	|z
  |z  ||<   t        ||   t        j                  t        j                  «      j                  «      ||<   |t!        |||   z  «      z
  ||<   t        |||   «      ||<   t        |||   «      ||<   ŒÏ ||fS )r4   r   ©r(   r7   r8   )r>   r9   r   r?   r   r   r   r   ÚzerosÚshapeÚfloat64r!   Úranger@   rA   rB   r   )
rD   r(   r&   r'   Ún_levelsr$   r%   ÚirG   rH   s
             r   Ú&_calculate_dynamic_per_channel_qparamsrS   e   sw  € ô �!”U—\‘\Ô"Ø�G‰G‹IˆÜ—‘˜UÓ#×'Ñ'¬¯©°UÓ);×)?Ñ)?ˆ$€DØ�d‰{€HÜ�H‰H�Q—W‘W˜Q‘Z¤r§z¡zÔ2€EÜ—‘˜!Ÿ'™' !™*¬B¯H©HÔ5€JÜ�:×#Ñ# AÑ&Ó'ò 5ˆØ—%‘%“'ˆØ—%‘%“'ˆØ�gÒØˆE�!‰HØˆJ�qŠMä˜' 3Ó'ˆGÜ˜' 3Ó'ˆGØ 'Ñ)¨XÑ5ˆE�!‰HÜ˜5 ™8¤R§X¡X¬b¯j©jÓ%9×%=Ñ%=Ó>ˆE�!‰HØ ¤5¨°5¸±8Ñ);Ó#<Ñ<ˆJ�q‰MÜ  j°¡mÓ4ˆJ�q‰MÜ  j°¡mÓ4ˆJ�qŠMð5ð �*ÐÐr   c                 ó:  — t        | t        t        f«      rmt        | «      t        |«      k7  r#t	        dt        | «      › dt        |«      › �«      ‚t        t        | «      «      D �cg c]  }t        | |   ||   «      ‘Œ }}|S |j                  r|j                  «       }| j                  r| j                  «       } | |z
  j                  «       }|dk(  rdt        d«      t        d«      fS | j                  «       }||z  }d|j                  «       z  }|||fS c c}w )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
    z#Expected len(x) == len(x_hat), got z != r   r8   Úinfé   )r>   ÚlistÚtupleÚlenr<   rP   Ú_snrÚis_quantizedÚ
dequantizeÚnormr,   Úlog10)r#   Úx_hatÚidxÚresÚnoiseÚsignalÚsnrÚsnr_dbs           r   rZ   rZ      s  € ô �!”dœE�]Ô#Üˆq‹6”S˜“ZÒÜ Ð#FÄsÈ1ÃvÀhÈdÔSVÐW\ÓS]ÐR^Ð!_Ó`Ð`Ü38¼¸Q»³=ÖA¨CŒt�A�c‘F˜E #™JÕ'ÐAˆÐAØˆ
Ø×ÒØ× Ñ Ó"ˆØ‡~‚~Ø�L‰L‹NˆØ�‰Y×ÑÓ€EØ�‚zØ”E˜%“L¤%¨£,Ð.Ð.Ø�V‰V‹X€FØ
�5‰.€CØ�#—)‘)“+Ñ€FØ�5˜&Ð Ð ùò Bs   Á'Dc              #   ó"  K  — t         j                  j                  j                  }| t         j                  j                  _        	 d –— |t         j                  j                  _        y # |t         j                  j                  _        w xY w­w©N©r9   ÚbackendsÚ	quantizedÚengine)ÚqengineÚpreviouss     r   Úoverride_quantized_enginern   ›   sY   è ø€ ä�~‰~×'Ñ'×.Ñ.€HØ&-„E‡N�N×ÑÔ#ð3Ûà*2Œ�‰× Ñ Õ'ø¨(Œ�‰× Ñ Õ'üs   ‚ABÁA+ Á BÁ+!BÂBc              #   óä   K  — 	 | rt         j                  j                  «        d –— | rt         j                  j                  «        y y # | rt         j                  j                  «        w w xY w­wrg   )r9   Ú_CÚ!_set_default_mobile_cpu_allocatorÚ#_unset_default_mobile_cpu_allocator)Úqengine_is_qnnpacks    r   Ú"override_cpu_allocator_for_qnnpackrt   ¤   sR   è ø€ ð;ÙÜ�H‰H×6Ñ6Ô8ÛáÜ�H‰H×8Ñ8Õ:ð øÑÜ�H‰H×8Ñ8Õ:ð üs   ‚A0„$A
 ¨"A0Á
#A-Á-A0c                 ó   ‡ — ˆ fd„}|S )Nc                  ól   •— t         D ]  }t        |«      5   ‰| i |¤Ž d d d «       Œ  y # 1 sw Y   Œ+xY wrg   )Úsupported_qenginesrn   )ÚargsÚkwargsrl   Ú	qfunctions      €r   Útest_fnz"override_qengines.<locals>.test_fn²   sA   ø€ Ü)ò 	+ˆGÜ*¨7Ó3ñ +á˜4Ð* 6Ò*÷+ð +ñ	+÷+ð +ús   –	*ª3	© )rz   r{   s   ` r   Úoverride_qenginesr}   ±   s   ø€ ô+ð
 €Nr   c                  óP   — t         j                  j                  j                  dk(  S )Nr   rh   r|   r   r   Úqengine_is_fbgemmr   ¹   ó   € Ü�>‰>×#Ñ#×*Ñ*¨hÑ6Ð6r   c                  óP   — t         j                  j                  j                  dk(  S )Nr
   rh   r|   r   r   rs   rs   »   s   € Ü�>‰>×#Ñ#×*Ñ*¨iÑ7Ð7r   c                  óP   — t         j                  j                  j                  dk(  S )NÚonednnrh   r|   r   r   Úqengine_is_onednnr„   ½   r€   r   c                  óP   — t         j                  j                  j                  dk(  S )Nr   rh   r|   r   r   Úqengine_is_x86r†   ¿   s   € Ü�>‰>×#Ñ#×*Ñ*¨eÑ3Ð3r   c                 ó–   — t        t        | j                  «       «      «      }d||<   ||d<   | j                  t	        |«      «      }||fS )Nr   )rW   rP   ÚdimÚpermuterX   )rD   ÚaxisÚnew_axis_listÚys       r   Ú_permute_to_axis_zeror�   Ã   sH   € Üœ˜qŸu™u›w›Ó(€MØ€M�$ÑØ€M�!ÑØ	�	‰	”%˜Ó&Ó'€AØˆmÐÐr   c           	      óÊ  — | j                   }t        | j                  t        j                  «      |«      \  } }t        j
                  | «      }t        | j                  «       d   «      D ]M  }	t        j                  t        j                  | |	   d||	   z  z  ||	   z   «      ||«      ||	   z
  ||	   z  ||	<   ŒO |j                  t        |«      «      }
|
j                  |«      S ©Nr   r7   )r(   r�   Útor9   rA   Ú
zeros_likerP   ÚsizeÚclampr   r‰   rX   )rD   Úper_channel_scaleÚper_channel_zero_pointrŠ   Ú	quant_minÚ	quant_maxr(   Úpermute_axis_listra   rR   Úouts              r   Ú+_fake_quantize_per_channel_affine_referencerš   Ì   sâ   € Ø�G‰G€EÜ0°·±´e·m±mÓ1DÀdÓKÑ€AÐÜ
×
Ñ
˜1Ó
€Cä�1—6‘6“8˜A‘;Óò xˆÜ—+‘+œeŸk™k¨!¨A©$°#Ð8IÈ!Ñ8LÑ2LÑ*MØ(¨Ñ+ñ+,ó -Ø.7¸óDØF\Ð]^ÑF_ñ`ØctÐuvÑcwñxˆˆAŠðxð �+‰+”eÐ-Ó.Ó
/€CØ�6‰6�%‹=Ðr   c                 óØ  — |j                   }t        |j                  t        j                  «      |«      \  }}t        j
                  |«      }	t        |j                  «       d   «      D ],  }
t        j                  ||
   d||
   z  z  ||
   z   «      |	|
<   Œ. |	j                  t        |«      «      }	|	|k\  |	|k  z  }t        j
                  | «      }| |   ||<   |j                  |«      S r�   )r(   r�   r�   r9   rA   r‘   rP   r’   r   r‰   rX   )ÚdYrD   r”   r•   rŠ   r–   r—   r(   r˜   ÚXqrR   Úmaskra   s                r   Ú0_fake_quantize_per_channel_affine_grad_referencerŸ   Ú   sÝ   € Ø�G‰G€EÜ0°·±´e·m±mÓ1DÀdÓKÑ€AÐÜ	×	Ñ	˜!Ó	€BÜ�1—6‘6“8˜A‘;Óò ]ˆÜ—‘˜A˜a™D CÐ*;¸AÑ*>Ñ$>Ñ?ÐBXÐYZÑB[Ñ[Ó\ˆˆ1Šð]à	�‰”EÐ+Ó,Ó	-€BØ�)‰O  i¡Ñ0€DÜ
×
Ñ
˜2Ó
€CØ�4‘€Cˆ�IØ�6‰6�%‹=Ðr   c                 ó  — t        | t        j                  «      st        j                  | «      } n| j	                  «       j                  «       } | j                  t        j                  |«      t        j                  ¬«      S )N©Údevicer(   )	r>   r9   r   ÚtensorÚdetachÚcloner�   r¢   rA   )rD   r¢   s     r   Ú	to_tensorr¦   æ   sQ   € Ü�aœŸ™Ô&Ü�L‰L˜‹O‰à�H‰H‹J×ÑÓˆØ�4‰4”u—|‘| FÓ+´5·=±=ˆ4ÓAÐAr   ÚnÚreturnc                 ó   — d| z  dz
  S ©Nr   r|   )r§   s    r   Ú_n_onesr«   ï   s   € Ø�‰F�a‰<Ðr   )é   é   r   r#   ÚebitsÚmbitsc                 ó^  — | j                   t        j                  k7  rt        d| j                   › �«      ‚d|z   |z   dkD  rt        dd|z   |z   › �«      ‚t	        |dz
  «      }t	        ||z   «      }d||z   z  }t	        t
        |z
  dz
  «      }dt	        |«      |z
  z  t	        |dz   «      d|z  z  z  }dd|z
  z  }t        |z
  t
        |z
  z   dz   }	|	t
        z  }
t        j                  |
t        j                  ¬«      j                  t        j                  «      }| j                  t        j                  «      } | dz  }| |z  } | j                  t        j                  «      } | |k\  }t        j                  t        j                  |«      | |k  «      }t        j                  t        j                  ||«      «      }| |z   }|j                  t        j                  «      }||
z  }|j                  t        j                  «      }| j                  t        j                  «      }|t
        |z
  z	  dz  }|t        z
  t
        z  |z   }||z  }||z  }|t
        |z
  z	  }|j                  t        j                  «      }t        j                   | |t        j                  ¬«      } t        j"                  ||| «      } t        j"                  ||| «      } |t
        t$        z   |z
  |z
  z	  }|j                  t        j                  «      }||z  }| |z  } | j                  t        j                  «      S )aJ  Convert FP32 numbers to sub-byte floating point numbers with the given
    number of exponent and mantissa bits.

    Input: torch.Tensor of dtype torch.float
    Output: torch.Tensor of dtype torch.uint8, where the bit encoding is stored
    in the least significant bits. e.g.
      fp4: bits 0-3 empty and bits 4-7 in fp4_e2m1 encoding
      fp6: bits 0-1 empty and bits 2-7 in fp6_e2m3 or fp6_e3m2 encoding

    Note: there are no special values (NaN, inf) support in this code. Values
    outside the representable range of Floatx after rounding are clamped to the
    maximum Floatx magnitude (sign is preserved).

    Code below is an adaptation of https://fburl.com/code/ciwofcg4

    Background 1: last answer in https://stackoverflow.com/q/8981913
    Background 2: Computer Organization and Design, RISC-V edition, Chapter 3.5
    z(Expected x.dtype to be torch.float, got r   r¬   ú%Expected 1 + ebits + mbits <= 8, got r   rL   l        )r(   r9   r,   r<   r«   Ú	MBITS_F32ÚF32_EXP_BIASr£   Úint32ÚviewrA   Úlogical_andÚlogical_notÚ
logical_orr�   Úuint8Ú	full_likeÚwhereÚ	EBITS_F32)r#   r®   r¯   Úexp_biasÚmax_intÚ	sign_maskÚmagic_adderÚ
max_normalÚ
min_normalÚ
denorm_expÚdenorm_mask_intÚdenorm_mask_floatÚsignÚsaturate_maskÚdenormal_maskÚnormal_maskÚ
denormal_xÚnormal_xÚmant_oddÚ
val_to_addÚsign_lps                        r   Ú_f32_to_floatx_unpackedrÏ   ÷   sõ  € ð& 	‡w�w”%—+‘+ÒÜÐGÈÏÉÀyÐQÓRÐRØˆ5�y�5Ñ˜1ÒÜÐDÀQÈÁYÐQVÑEVÐDWÐXÓYÐYô �u˜q‘yÓ!€HÜ�e˜e‘mÓ$€GØ�e˜e‘mÑ$€Iô œ) eÑ+¨aÑ/Ó0€Kð ”w˜u“~¨Ñ0Ñ1´W¸UÀQ¹YÓ5GÈ1ÈeÉ8Ñ5TÑU€Jð �q˜8‘|Ñ$€Jô 
˜Ñ	 ä�uÑñ	ð ñ		ð ð !¤IÑ-€Oô Ÿ™ _¼E¿K¹KÔH×MÑMÜ�‰óÐð 	
�‰Œu�{‰{Ó€AØˆz‰>€Dð 	
ˆD‰€Að 	
�‰Œu�{‰{Ó€Að ˜‘O€MÜ×%Ñ%¤e×&7Ñ&7¸Ó&FÈÈJÉÓW€MÜ×#Ñ#¤E×$4Ñ$4°]ÀMÓ$RÓS€Kð Ð&Ñ&€JØ—‘¤§¡Ó-€JØ�/Ñ!€JØ—‘œuŸ{™{Ó+€Jð
 �v‰v”e—k‘kÓ"€HàœY¨Ñ.Ñ/°1Ñ4€HàœlÑ*¬yÑ8¸KÑG€JØ�
Ñ€Hà�Ñ€HàœI¨Ñ-Ñ.€HØ�{‰{œ5Ÿ;™;Ó'€Hô
 	�‰˜˜7¬%¯+©+Ô6€AÜ�‰�M :¨qÓ1€AÜ�‰�K ¨1Ó-€Að ”y¤9Ñ,¨uÑ4°uÑ<Ñ=€GØ�j‰jœŸ™Ó%€Gð
 ˜	Ñ!€GØ	ˆG‰€Aà�4‰4”—‘ÓÐr   c                 óú  — | j                   t        j                  k7  rt        d| j                   › �«      ‚d|z   |z   dkD  rt        dd|z   |z   › �«      ‚d||z   z  }t	        |dz
  «      }t	        |«      }| |z  }| |z  }|dk(  }t        j
                  |dkD  ||z	  dk(  «      }	||z	  }
|
|z
  t        z   }|j                  t        j                  «      t        z  }||z  j                  t        j                  «      }|t        |z
  z  }||z  }d||<   d|z
  t        z   }|dk(  r||z
  t        z  ||	<   nrt        |«      D ]M  }t        d|z  d|dz   z  «      D ]3  }||z
  }|d|z  z
  |t        z   |z
  z  }||z
  t        z  }||z   |||k(  <   Œ5 ŒO t        j                  |	||«      }|j                  t        j                  «      t        |z
  t        z   |z
  z  }||z  }|j                  t        j                  «      S )a¥  Convert sub-byte floating point numbers with the given number of exponent
    and mantissa bits to FP32.

    Input: torch.Tensor of dtype uint8, where the bit encoding is stored
    in the least significant bits. e.g.
      fp4: bits 0-3 empty and bits 4-7 in fp4_e2m1 encoding
      fp6: bits 0-1 empty and bits 2-7 in fp6_e2m3 or fp6_e3m2 encoding
    Output: torch.Tensor of dtype fp32 with the dequantized value
    z(Expected x.dtype to be torch.uint8, got r   r¬   r±   r   )r(   r9   r¹   r<   r«   r¶   r³   r�   r´   r²   rP   r»   r¼   rµ   r,   )r#   r®   r¯   r¿   r½   Úmantissa_maskrÎ   Úx_posÚ	zero_maskrÈ   Úexp_biased_lpÚexp_biased_f32Úmantissa_lp_int32Úmantissa_f32ÚresultÚdenormal_exp_biasedrR   Úmantissa_cmpÚ
left_shiftÚsign_f32s                       r   Ú_floatx_unpacked_to_f32rÝ   q  sH  € ð 	‡w�w”%—+‘+ÒÜÐGÈÏÉÀyÐQÓRÐRØˆ5�y�5Ñ˜1ÒÜÐDÀQÈÁYÐQVÑEVÐDWÐXÓYÐYà�e˜e‘mÑ$€IÜ�u˜q‘yÓ!€HÜ˜E“N€Mð �)‰m€Gð �‰K€Eð
 ˜‘
€Iô
 ×%Ñ% u¨q¡y°U¸e±^ÈÑ4IÓK€Mð ˜U‘N€MØ" XÑ-´Ñ<€NØ#×&Ñ&¤u§{¡{Ó3´yÑ@€Nð  Ñ.×2Ñ2´5·;±;Ó?ÐØ$¬°UÑ):Ñ;€LØ˜lÑ*€Fð
 €Fˆ9Ñà˜h™,¬Ñ5Ðð �‚zØ!4°uÑ!<ÄÑ Jˆˆ}Òô �u“ò 	ˆAÜ % a¨1¡f¨a°A¸±E©lÓ ;ò �ð # Q™Y�
Ø ,°°Q±Ñ 7Ø¤Ñ*¨UÑ2ñ �ð #6¸
Ñ"BÄyÑ!P�ð # \Ñ1ð "Ð"3°|Ñ"CÒDñð	ô" —‘˜]Ð,=¸vÓFˆð �z‰zœ%Ÿ+™+Ó&¬9°uÑ+<¼yÑ+HÈ5Ñ+PÑQ€HØ�hÑ€Fà�;‰;”u—{‘{Ó#Ð#r   c                 ó   — | |z   dz
  |z  S rª   r|   )ÚaÚbs     r   Úceil_divrá   Î  s   € Ø�‰E�A‰I˜!ÑÐr   c                 óð  — t        j                  | j                  d«      | j                  d«      |z  f| j                  |j                  ¬«      }t        t        | j                  d«      |«      d«      }t        | j                  d«      «      D ]d  }t        | j                  d«      |z  «      D ]B  }|dz  }|dz  }d||z  |z   z  }	|dz  }
|dz  }|	|
dz  dz  z   |
dz  dz  z   |z   }||   |||f<   ŒD Œf |S )	Nr   r   r¡   é   é€   i   é    é   )r9   rM   r’   r¢   r(   rá   rP   )ÚinputÚinput_scalesÚ	blocksizeÚoutput_scalesÚnum_col_tilesrR   ÚjÚscale_tile_hÚscale_tile_wÚtile_offsetÚouterÚinnerÚoffsets                r   Úfrom_blockedró   Õ  s  € ô —K‘KØ	�‰�A‹˜Ÿ
™
 1›¨Ñ2Ð3Ø�|‰|Ø× Ñ ô€Mô œX e§j¡j°£m°YÓ?ÀÓC€Mô �5—:‘:˜a“=Ó!ò 7ˆÜ�u—z‘z !“}¨	Ñ1Ó2ò 	7ˆAà ™8ˆLØ ™6ˆLð  °Ñ!=ÀÑ!LÑMˆKð ˜‘GˆEØ˜‘EˆEð
 ! E¨B¡J°"Ñ#4Ñ4¸À¹ÀqÑ7HÑHÈ5ÑPˆFà".¨vÑ"6ˆM˜!˜Q˜$Òñ%	7ð7ð* Ðr   c                 óî   — t        j                  ||d¬«      }| j                  t         j                  «      |j                  t         j                  «      z  }|j                  t         j                  «      S )Nr   )rˆ   )r9   Úrepeat_interleaver�   r,   Úbfloat16)Úx_mxfp8Úscales_unswizzledré   ÚscalesÚx_f32s        r   Úfrom_blocked_formatrû   û  sP   € ä×$Ñ$Ð%6¸	ÀqÔI€Fð �J‰J”u—{‘{Ó# f§i¡i´·±Ó&<Ñ<€EØ�8‰8”E—N‘NÓ#Ð#r   c                 óÂ  — | j                   \  }}t        |d«      }t        |d«      }|dz  }|dz  }| }||f||fk7  r9t        j                  ||f| j                  | j
                  ¬«      }| |d|…d|…f<   |j                  |d|d«      j                  dddd«      }|j                  d	dd
d«      j                  dd«      j                  d	d
d«      }	|	j                  «       S )a[  
    Rearrange a large matrix by breaking it into blocks and applying the rearrangement pattern.

    See:
        https://docs.nvidia.com/cuda/cublas/index.html#d-block-scaling-factors-layout

    Args:
        input_matrix: Input tensor of shape (H, W)

    Returns:
        Rearranged tensor of shape (32*ceil_div(H,128), 16*ceil_div(W,4))
    rä   rã   r¡   Nr   r   r   é   éÿÿÿÿrå   ræ   )rN   rá   r9   rM   r¢   r(   rµ   r‰   ÚreshapeÚ	transposeÚflatten)
Úinput_matrixÚrowsÚcolsÚn_row_blocksÚn_col_blocksÚpadded_rowsÚpadded_colsÚpaddedÚblocksÚ
rearrangeds
             r   Ú
to_blockedr    s÷   € ð ×#Ñ#�J€Dˆ$Ü˜D #Ó&€LÜ˜D !Ó$€Lð  Ñ$€KØ Ñ"€Kà€Fàˆd€|˜ [Ð1Ò1Ü—‘˜k¨;Ð7À×@SÑ@SÐ[g×[mÑ[mÔnˆØ+ˆˆu�ˆu�e�t�eˆ|Ñð �[‰[˜ s¨L¸!Ó<×DÑDÀQÈÈ1ÈaÓP€FØ—‘  A r¨1Ó-×7Ñ7¸¸1Ó=×EÑEÀbÈ"ÈbÓQ€Jà×ÑÓÐr   c                 óT   — | d   dz  dk7  rt        | › d�«      ‚g | d d ¢| d   dz  ‘­S )Nrþ   r   r   z last dim not divisible by two)r<   )r’   s    r   Ú	down_sizer  %  sC   € ØˆB�x�!�|�qÒÜ ˜vÐ%CÐDÓEÐEØ&ˆT�#�2ˆYÐ&˜˜R™ A™Ñ&Ð&r   c                 óÌ   — | j                   }|d   dz  dk7  rt        d|d   › �«      ‚| j                  d«      } | dd d…   dz  | d d d…   z  j                  t	        |«      «      S )Nrþ   r   r   z-Expected shape[-1] to be divisible by 2, got r   rã   )rN   r<   rÿ   rµ   r  )Ú
uint8_datarN   s     r   Ú
pack_uint4r  +  sx   € à×Ñ€EØˆR�y�1�}˜ÒÜÐLÈUÐSUÉYÈKÐXÓYÐYØ×#Ñ# BÓ'€JØ�q�t˜!�tÑ Ñ! J©s°¨s¡OÑ3×9Ñ9¼)ÀEÓ:JÓKÐKr   )r   r   c                 ó
  — | j                   t        j                  k7  rt        d| j                   › �«      ‚t	        | j                  «       t        t        «      } t        | «      } | j                  t        j                  «      } | S )Nz+Expected x.dtype to be torch.bfloat16, got )r(   r9   rö   r<   rÏ   r,   Ú	FP4_EBITSÚ	FP4_MBITSr  rµ   Úfloat4_e2m1fn_x2)r#   s    r   Ú_bfloat16_to_float4_e2m1fn_x2r  8  s_   € Ø‡w�w”%—.‘.Ò ÜÐJÈ1Ï7É7È)ÐTÓUÐUÜ §¡£	¬9´iÓ@€AÜ�1‹€AØ	�‰Œu×%Ñ%Ó&€AØ€Hr   Údata_hpÚ
block_sizeÚformatc           
      ó  — | j                   t        j                  t        j                  fvrt	        | j                   › d�«      ‚| j
                  d   |z  dk7  rt	        d| j
                  › d|› �«      ‚| j                  «       st	        d«      ‚| j
                  } | j                  g |d d ¢|d   |z  ‘|‘­Ž } t        j                  t        j                  | «      d«      j                  d«      }| j                  t        j                  «      } |j                  t        j                  «      }|dk(  r0t        j                  t        j                  «      j                  }|}n	|dk(  rd	}|}d
t        j                   dt        j                   dt        dt"        t        j                   t        j                   f   fd„} || |«      \  }	}
|dk(  r1|
j                  t        j                  «      }
|
j                  |«      }
nV|dk(  rQt%        |
j                  t        j                  «      «      }
t'        |«      }|dxx   dz  cc<   |
j                  |«      }
|	j)                  t        j*                  «      }	|	j-                  d«      }	|	|
fS )Nz is not supported yetrþ   r   zthe last dimension of shape z! must be divisible by block_size z'unsupported: data_hp must be contiguousÚmxfp8Úmxfp4g      @r  Úmax_absÚmax_posr¨   c                 óü  — d}||z  }t        j                  t        j                  |«      dt        j                  t        j                  t        j
                  |«      «      | |¬«      |z   j                  t         j                  «      «      }t        j                  |dk(  dt        j                  ||j                  t         j                  «      z
  «      «      }t        j                  | |z  d|z  |¬«      }||fS )Nr6   r.   )r   r   r   r7   rþ   )
r9   r»   Úisnanr“   ÚceilÚlog2r�   r¹   Úexp2rA   )r  r  r  ÚE8M0_EXPONENT_BIASÚdescaleÚexponentÚ
descale_fpÚdata_lps           r   Ú_to_mx_rceilzto_mxfp.<locals>._to_mx_rceilb  s×   € ð
 !ÐØ˜GÑ#ˆÜ—;‘;Ü�K‰K˜Ó Øô —‘Ü—J‘JœuŸz™z¨'Ó2Ó3Ø+Ð+Ø*ôð
 %ñ%÷ ‰b”—‘‹oó
ˆô —[‘[Ø˜‰MØÜ�J‰JÐ)¨H¯K©K¼¿¹Ó,FÑFÓGó
ˆ
ô —+‘+˜g¨
Ñ2¸¸W¹È'ÔRˆØ˜Ð Ð r   r   )r(   r9   rö   r,   r<   rN   Úis_contiguousrÿ   ÚamaxÚabsÚ	unsqueezer�   rA   r@   Úfloat8_e4m3fnr   r   rX   r  rW   rµ   Úfloat8_e8m0fnuÚsqueeze)r  r  r  Ú
orig_shaper  Ú
F8E4M3_MAXr  Ú
F4E2M1_MAXr)  Úscale_e8m0_biasedr(  Úfinal_shapes               r   Úto_mxfpr6  B  sH  € ð
 ‡}�}œUŸ^™^¬U¯[©[Ð9Ñ9Ü §¡˜Ð.CÐDÓEÐEØ‡}�}�RÑ˜:Ñ%¨Ò*ÜØ*¨7¯=©=¨/Ð9ZÐ[eÐZfÐgó
ð 	
ð × Ñ Ô"ÜÐFÓGÐGà—‘€JØˆg�o‰oð Ø	�C�RˆðØ$ R™.¨JÑ6ðØ8Bò€Gô �j‰jœŸ™ 7Ó+¨RÓ0×:Ñ:¸2Ó>€Gà�j‰jœŸ™Ó'€GØ�j‰jœŸ™Ó'€Gà�ÒÜ—[‘[¤×!4Ñ!4Ó5×9Ñ9ˆ
Ø‰Ø	�7Ò	Øˆ
Øˆð!Ü—‘ð!ä—‘ð!ô ð!ô 
Œu�|‰|œUŸ\™\Ð)Ñ	*ó	!ñ> ".¨g°wÀÓ!HÑÐ�wð �ÒØ—*‘*œU×0Ñ0Ó1ˆà—/‘/ *Ó-‰Ø	�7Ò	Ü/°·
±
¼5¿>¹>Ó0JÓKˆÜ˜:Ó&ˆØ�B‹˜AÑ‹Ø—/‘/ +Ó.ˆà)×.Ñ.¬u×/CÑ/CÓDÐØ)×1Ñ1°"Ó5ÐØ˜gÐ%Ð%r   ræ   Úcudac                 ó¶  — ddl }||z  dk7  rt        d|› �«      ‚t        t        ||dz   |«      «      }| t	        |«      kD  rt        d«      ‚t        j                  |j                  |dd | dz
  «      «      }t        j                  |t        j                  |g«      f«      }t        j                  |«      \  }}|j                  |«      j                  |«      S )a£  
    Utility function for tests and benchmarks.

    Generates a tensor of length E, containing random values divisible by `multiple_of`,
    from 0 to M, in sorted order, and where the final value in the tensor is always M.
    Args:
        E (int): The length of the tensor.
        M (int): The maximum value in the tensor.
    Returns:
        torch.Tensor: A tensor of length E with the specified properties.
    r   NzM must be divisible by r   z5E cannot be larger than the number of possible valuesrþ   )ÚrandomÚ
ValueErrorrW   rP   rY   r9   r£   ÚsampleÚcatÚsortr�   )	ÚEÚMÚmultiple_ofr(   r¢   r9  Úpossible_valuesÚselected_valuesÚ_s	            r   Úgenerate_jagged_offsrD  “  sÓ   € ó ð 	ˆ;�˜!ÒÜÐ2°;°-Ð@ÓAÐAô œ5 ¨a°!©e°[ÓAÓB€Oð 	Œ3ˆÓÒÜÐPÓQÐQô —l‘l 6§=¡=°ÀÀ"Ð1EÀqÈ1ÁuÓ#MÓN€Oô —i‘i ´%·,±,À¸sÓ2CÐ DÓE€Oô Ÿ™ OÓ4Ñ€O�Qà×Ñ˜eÓ$×'Ñ'¨Ó/Ð/r   )r   )rå   )rå   r  )<Ú__doc__r?   r   r9   r   Ú
contextlibr   Ú$torch.testing._internal.common_utilsr   r   r   r   r	   rW   ri   rj   Úsupported_enginesrw   ÚanyÚremover   r¹   r*   r-   r2   r:   rJ   rS   rZ   rn   rt   r}   r   rs   r„   r†   r�   rš   rŸ   r¦   rC   r«   r¼   r²   r³   rÏ   rÝ   rá   ró   rû   r  r  r  r  r  r  Ústrr6  r´   rD  )Úqes   0r   ú<module>rM     s?  ðñó Û Ý Ý %ß gÕ gá˜%Ÿ.™.×2Ñ2×DÑDÓEÐ ð Ð"Ñ"¡s¨F°NÀHÈjÐ+YÔ'ZØ×Ñ˜iÔ(ñ Ø'9ÖY ¸RÐGXÒ=Xš"ÒYÐð '(óJð *.°DÀÇÁó 	òð 12¸À2Ç8Á8ó ð 7<ÀU×E\ÑE\ó -+ò^ò4!ð8 ñ3ó ð3ð ñ;ó ð;òò7ò8ò7ò4òò
ò
òBðˆsð �só ð Ñ €	ˆ9Ù�y 1‘}Ó%€ðu˜vð u¨cð u¸#ð uÀ&ó uðtZ$˜vð Z$¨cð Z$¸#ð Z$À&ó Z$òzð$°E·L±Ló $óL$ð  §¡ó  òD'ðL˜eŸl™ló Lð Ñ €	ˆ9òð ØñN&Ø�\‰\ðN&àðN&ð óN&ðb ,.°U·[±[Èô "0ùò Zs   Á2	F	Á<F	