Ë
    ÄÓ^jy5  ã                   óâ   — d dl 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Z d dlmZ ddlmZmZmZ ddgZ G d	„ dej
                  j*                  «      Z G d
„ de«      Zy)é    )ÚIterableN)Úfuse_linear_bn_weights)Útype_before_parametrizationsé   )Ú_hide_packed_params_reprÚ_quantize_weightÚWeightedQuantizedModuleÚLinearPackedParamsÚLinearc                   ó  ‡ — e Zd ZdZej
                  fˆ fd„	Zej                  j                  dej                  dej                  dz  ddfd„«       Z
ej                  j                  d„ «       Zd	„ Zˆ fd
„Zˆ fd„Zd„ Zˆ xZS )r
   é   c                 ój  •— t         ‰| �  «        || _        | j                  t        j                  k(  r*t        j
                  ddgddt        j                  ¬«      }nD| j                  t        j                  k(  r't        j                  ddgt        j                  ¬«      }| j                  d «       y )Nr   ç      ð?r   ©ÚscaleÚ
zero_pointÚdtype©r   )
ÚsuperÚ__init__r   ÚtorchÚqint8Ú_empty_affine_quantizedÚfloat16ÚzerosÚfloatÚset_weight_bias)Úselfr   ÚwqÚ	__class__s      €úo/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/torch/ao/nn/quantized/modules/linear.pyr   zLinearPackedParams.__init__   s€   ø€ Ü‰ÑÔØˆŒ
Ø�:‰:œŸ™Ò$Ü×.Ñ.Ø�A�˜c¨a´u·{±{ô‰Bð �Z‰Zœ5Ÿ=™=Ò(Ü—‘˜a ˜V¬5¯;©;Ô7ˆBØ×Ñ˜R Õ&ó    ÚweightÚbiasNÚreturnc                 óL  — | j                   t        j                  k(  r0t        j                  j                  j                  ||«      | _        y | j                   t        j                  k(  r0t        j                  j                  j                  ||«      | _        y t        d«      ‚©Nz.Unsupported dtype on dynamic quantized linear!)
r   r   r   ÚopsÚ	quantizedÚlinear_prepackÚ_packed_paramsr   Úlinear_prepack_fp16ÚRuntimeError)r   r#   r$   s      r!   r   z"LinearPackedParams.set_weight_bias    sm   € à�:‰:œŸ™Ò$Ü"'§)¡)×"5Ñ"5×"DÑ"DÀVÈTÓ"RˆDÕØ�Z‰Zœ5Ÿ=™=Ò(Ü"'§)¡)×"5Ñ"5×"IÑ"IÈ&ÐRVÓ"WˆDÕäÐOÓPÐPr"   c                 óX  — | j                   t        j                  k(  r3t        j                  j                  j                  | j                  «      S | j                   t        j                  k(  r3t        j                  j                  j                  | j                  «      S t        d«      ‚r'   )
r   r   r   r(   r)   Úlinear_unpackr+   r   Úlinear_unpack_fp16r-   ©r   s    r!   Ú_weight_biaszLinearPackedParams._weight_bias)   sp   € à�:‰:œŸ™Ò$Ü—9‘9×&Ñ&×4Ñ4°T×5HÑ5HÓIÐIØ�Z‰Zœ5Ÿ=™=Ò(Ü—9‘9×&Ñ&×9Ñ9¸$×:MÑ:MÓNÐNäÐOÓPÐPr"   c                 ó   — |S ©N© ©r   Úxs     r!   ÚforwardzLinearPackedParams.forward2   s   € Øˆr"   c                 óx   •— t         ‰| �  |||«       | j                  ||dz   <   | j                  «       ||dz   <   y )Nr   r+   )r   Ú_save_to_state_dictr   r2   ©r   ÚdestinationÚprefixÚ	keep_varsr    s       €r!   r:   z&LinearPackedParams._save_to_state_dictE   s@   ø€ Ü‰Ñ# K°¸ÔCØ(,¯
©
ˆ�F˜WÑ$Ñ%Ø15×1BÑ1BÓ1Dˆ�FÐ-Ñ-Ò.r"   c           	      óÖ  •— |j                  dd «      }|�|dk  rt        j                  | _        n!||dz      | _        |j	                  |dz   «       |�|dk  rF| j                  ||dz      ||dz      «       |j	                  |dz   «       |j	                  |dz   «       |dk(  r1||dz      \  }	}
|j	                  |dz   «       | j                  |	|
«       t        ‰| �  |||d|||«       y )	NÚversioné   r   r   r#   r$   r+   F)Úgetr   r   r   Úpopr   r   Ú_load_from_state_dict©r   Ú
state_dictr=   Úlocal_metadataÚstrictÚmissing_keysÚunexpected_keysÚ
error_msgsr@   r#   r$   r    s              €r!   rD   z(LinearPackedParams._load_from_state_dictJ   s  ø€ ð !×$Ñ$ Y°Ó5ˆØˆ?˜g¨škÜŸ™ˆD�Jà# F¨WÑ$4Ñ5ˆDŒJØ�N‰N˜6 GÑ+Ô,àˆ?˜g¨škØ× Ñ Ø˜6 HÑ,Ñ-¨z¸&À6¹/Ñ/Jôð �N‰N˜6 HÑ,Ô-Ø�N‰N˜6 F™?Ô+à�aŠ<Ø% fÐ/?Ñ&?Ñ@‰LˆF�DØ�N‰N˜6Ð$4Ñ4Ô5Ø× Ñ  ¨Ô.ä‰Ñ%ØØØØØØØõ	
r"   c                 ó>   — | j                  «       j                  «       S r4   )r2   Ú__repr__r1   s    r!   rM   zLinearPackedParams.__repr__q   s   € Ø× Ñ Ó"×+Ñ+Ó-Ð-r"   )Ú__name__Ú
__module__Ú__qualname__Ú_versionr   r   r   ÚjitÚexportÚTensorr   r2   r8   r:   rD   rM   Ú__classcell__©r    s   @r!   r
   r
      s�   ø„ Ø€Hà"Ÿ[™[õ 	'ð ‡Y�Y×ÑðQ e§l¡lð Q¸%¿,¹,ÈÑ:Mð QÐRVò Qó ðQð ‡Y�Y×ÑñQó ðQòô&Eô
%
öN.r"   c                   ól  ‡ — e Zd ZdZdZej                  ej                  j                  j                  fZ
dej                  fˆ fd„	Zd„ Zd„ Zd„ Zdej"                  d	ej"                  fd
„Zˆ fd„Zˆ fd„Zd„ Zd„ Zd„ Zdej"                  dej"                  dz  d	dfd„Zedd„«       Zed„ «       Zˆ xZS )r   aÜ  
    A quantized linear module with quantized tensor as inputs and outputs.
    We adopt the same interface as `torch.nn.Linear`, please see
    https://pytorch.org/docs/stable/nn.html#torch.nn.Linear for documentation.

    Similar to :class:`~torch.nn.Linear`, attributes will be randomly
    initialized at module creation time and will be overwritten later

    Attributes:
        weight (Tensor): the non-learnable quantized weights of the module of
                         shape :math:`(\text{out\_features}, \text{in\_features})`.
        bias (Tensor): the non-learnable bias of the module of shape :math:`(\text{out\_features})`.
                If :attr:`bias` is ``True``, the values are initialized to zero.
        scale: `scale` parameter of output Quantized Tensor, type: double
        zero_point: `zero_point` parameter for output Quantized Tensor, type: long

    Examples::

        >>> # xdoctest: +REQUIRES(env:TORCH_DOCTEST_QENGINE)
        >>> m = nn.quantized.Linear(20, 30)
        >>> input = torch.randn(128, 20)
        >>> # xdoctest: +SKIP
        >>> input = torch.quantize_per_tensor(input, 1.0, 0, torch.quint8)
        >>> output = m(input)
        >>> print(output.size())
        torch.Size([128, 30])
    r   Tc                 ó
  •— t         ‰| �  «        || _        || _        d }|r%t	        j
                  |t        j                  ¬«      }|t        j                  k(  r*t	        j                  ||gddt        j                  ¬«      }nF|t        j                  k(  r(t	        j
                  ||gt        j                  ¬«      }nt        d«      ‚t        |«      | _        | j                  j                  ||«       d| _        d| _        y )Nr   r   r   r   z1Unsupported dtype specified for quantized Linear!r   )r   r   Úin_featuresÚout_featuresr   r   r   r   r   r   r-   r
   r+   r   r   r   )r   rY   rZ   Úbias_r   r$   Úqweightr    s          €r!   r   zLinear.__init__•   sÎ   ø€ Ü‰ÑÔð
 'ˆÔØ(ˆÔØˆÙÜ—;‘;˜|´5·;±;Ô?ˆDà”E—K‘KÒÜ×3Ñ3Ø˜{Ð+°1ÀÌ%Ï+É+ô‰Gð ”e—m‘mÒ#Ü—k‘k <°Ð"=ÄUÇ[Á[ÔQ‰GäÐRÓSÐSä0°Ó7ˆÔØ×Ñ×+Ñ+¨G°TÔ:ØˆŒ
Øˆ�r"   c                  ó   — y)NÚQuantizedLinearr5   r1   s    r!   Ú	_get_namezLinear._get_name¯   s   € Ø r"   c                 ó¬   — d| j                   › d| j                  › d| j                  › d| j                  › d| j	                  «       j                  «       › �
S )Nzin_features=z, out_features=z, scale=z, zero_point=z
, qscheme=)rY   rZ   r   r   r#   Úqschemer1   s    r!   Ú
extra_reprzLinear.extra_repr²   s\   € à˜4×+Ñ+Ð,¨O¸D×<MÑ<MÐ;NÈhÐW[×WaÑWaÐVbð cØŸ/™/Ð*¨*°T·[±[³]×5JÑ5JÓ5LÐ4MðOð	
r"   c                 ó"   — t        | t        «      S r4   )r   r
   r1   s    r!   rM   zLinear.__repr__¸   s   € Ü'¨Ô.@ÓAÐAr"   r7   r%   c                 óª   — t         j                  j                  j                  || j                  j                  | j
                  | j                  «      S r4   )r   r(   r)   Úlinearr+   r   r   r6   s     r!   r8   zLinear.forward»   s<   € Ü�y‰y×"Ñ"×)Ñ)Øˆt×"Ñ"×1Ñ1°4·:±:¸t¿¹ó
ð 	
r"   c                 ó¼   •— t         ‰| �  |||«       t        j                  | j                  «      ||dz   <   t        j                  | j
                  «      ||dz   <   y )Nr   r   )r   r:   r   Útensorr   r   r;   s       €r!   r:   zLinear._save_to_state_dictÝ   sL   ø€ Ü‰Ñ# K°¸ÔCÜ(-¯©°T·Z±ZÓ(@ˆ�F˜WÑ$Ñ%Ü-2¯\©\¸$¿/¹/Ó-Jˆ�F˜\Ñ)Ò*r"   c           	      ó�  •— t        ||dz      «      | _        |j                  |dz   «       t        ||dz      «      | _        |j                  |dz   «       |j                  dd «      }|�|dk(  rC|j                  |dz   «      }	|j                  |dz   «      }
|j                  |dz   |	|dz   |
i«       t        ‰| �!  |||d	|||«       y )
Nr   r   r@   r   r#   r$   z_packed_params.weightz_packed_params.biasF)	r   r   rC   Úintr   rB   Úupdater   rD   rE   s              €r!   rD   zLinear._load_from_state_dictå   sâ   ø€ ô ˜: f¨wÑ&6Ñ7Ó8ˆŒ
Ø�‰�v Ñ'Ô(ä˜j¨°,Ñ)>Ñ?Ó@ˆŒØ�‰�v Ñ,Ô-à ×$Ñ$ Y°Ó5ˆàˆ?˜g¨šlà—^‘^ F¨XÑ$5Ó6ˆFØ—>‘> &¨6¡/Ó2ˆDØ×ÑàÐ4Ñ4°fØÐ2Ñ2°Dðôô 	‰Ñ%ØØØØØØØõ	
r"   c                 ó6   — | j                   j                  «       S r4   )r+   r2   r1   s    r!   r2   zLinear._weight_bias  s   € Ø×"Ñ"×/Ñ/Ó1Ð1r"   c                 ó(   — | j                  «       d   S )Nr   ©r2   r1   s    r!   r#   zLinear.weight  ó   € Ø× Ñ Ó" 1Ñ%Ð%r"   c                 ó(   — | j                  «       d   S )Nr   rm   r1   s    r!   r$   zLinear.bias  rn   r"   ÚwÚbNc                 ó<   — | j                   j                  ||«       y r4   )r+   r   )r   rp   rq   s      r!   r   zLinear.set_weight_bias  s   € Ø×Ñ×+Ñ+¨A¨qÕ1r"   c           	      ó�  — t        |d«      rÌt        |«      t        j                  k(  r–t	        |j
                  |j                  |j                  j                  |j                  j                  |j                  j                  |j                  j
                  |j                  j                  «      \  |_        |_        |j                  }|j                  }�nt        | j                  t        «      s| j                  g| _        dj!                  | j                  D �cg c]  }|j"                  ‘Œ c}«      }d| j"                  › d|› dt%        |«      › �}t        |«      | j                  vrt'        |«      ‚t        |d«      st'        d«      ‚|j                  }t        |«      t(        j*                  k(  r|d   }t        |d«      s|j,                  j                  «       n|j                  }|s ||j
                  «       |j.                  }|j1                  «       \  }	}
|t2        j4                  k7  rt'        d	|› �«      ‚t7        |j
                  j9                  «       |«      } | |j:                  |j<                  |¬
«      }|j?                  ||j                  «       t9        |	«      |_         tC        |
«      |_"        |S c c}w )a}  Create a quantized module from an observed float module

        Args:
            mod (Module): a float module, either produced by torch.ao.quantization
                          utilities or provided by the user
            use_precomputed_fake_quant (bool): if True, the module will reuse min/max
                          values from the precomputed fake quant module.
        Úweight_fake_quantz, znnq.z.from_float only works for z, but got: Úqconfigz,Input float module must have qconfig definedr   z1Weight observer must have dtype torch.qint8, got r   )#Úhasattrr   ÚnniqatÚ
LinearBn1dr   r#   r$   ÚbnÚrunning_meanÚrunning_varÚepsrt   Úactivation_post_processÚ
isinstanceÚ_FLOAT_MODULEr   ÚjoinrN   ÚtypeÚAssertionErrorÚnniÚ
LinearReLUru   r   Úcalculate_qparamsr   r   r   r   rY   rZ   r   r   ri   r   )ÚclsÚmodÚuse_precomputed_fake_quantÚweight_post_processr}   Ú	float_modÚsupported_modulesÚ	error_msgr   Ú	act_scaleÚact_zpr\   Úqlinears                r!   Ú
from_floatzLinear.from_float  sT  € ô �3Ð+Ô,Ü+¨CÓ0´F×4EÑ4EÒEÜ'=Ø—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Ò#ô
 ˜c×/Ñ/´Ô:à%(×%6Ñ%6Ð$7�Ô!Ø $§	¡	Ø58×5FÑ5FÖG¨	�×#Ó#ÒGó!Ðð ˜sŸ|™|˜nÐ,GÐHYÐGZÐZeÔfjÐknÓfoÐepÐqˆIÜ+¨CÓ0¸×8IÑ8IÑIÜ$ YÓ/Ð/Ü˜3 	Ô*Ü$Ð%SÓTÐTØ&)×&AÑ&AÐ#Ü+¨CÓ0´C·N±NÒBØ˜!‘f�ô ˜sÐ$7Ô8ð —‘×"Ñ"Ô$à×*Ñ*ð  ñ *ñ   §
¡
Ô+Ø#×)Ñ)ˆØ3×EÑEÓGÑˆ	�6Ø”E—K‘KÒÜ ØCÀEÀ7ÐKóð ô # 3§:¡:×#3Ñ#3Ó#5Ð7JÓKˆÙ�c—o‘o s×'7Ñ'7¸uÔEˆØ×Ñ ¨¯©Ô2Ü˜iÓ(ˆŒÜ  ›[ˆÔØˆùò? Hs   ÄKc                 óØ   —  | |j                   |j                  «      }|j                  «       }|j                  ||j                  «       t        |«      |_        t        |«      |_        |S )aŒ  Create a (fbgemm/qnnpack) quantized module from a reference quantized module

        Args:
            ref_qlinear (Module): a reference quantized linear 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
        )	rY   rZ   Úget_quantized_weightr   r$   r   r   ri   r   )r†   Úref_qlinearÚoutput_scaleÚoutput_zero_pointr�   r\   s         r!   Úfrom_referencezLinear.from_referenceZ  s_   € ñ �k×-Ñ-¨{×/GÑ/GÓHˆØ×2Ñ2Ó4ˆØ×Ñ ¨×)9Ñ)9Ô:ä˜lÓ+ˆŒÜ Ð!2Ó3ˆÔØˆr"   )F)rN   rO   rP   Ú__doc__rQ   Únnr   Úmodulesre   ÚNonDynamicallyQuantizableLinearr   r   r   r   r_   rb   rM   rT   r8   r:   rD   r2   r#   r$   r   Úclassmethodr�   r–   rU   rV   s   @r!   r   r   u   sÒ   ø„ ñð8 €HØ—Y‘Y §
¡
× 1Ñ 1× QÑ QÐR€Mà8<ÀEÇKÁKõ ò4!ò
òBð
˜Ÿ™ð 
¨%¯,©,ó 
ôDKô%
òR2ò&ò&ð2 §¡ð 2°%·,±,ÀÑ2Eð 2È$ó 2ð ò=ó ð=ð~ ñó ôr"   )Úcollections.abcr   r   Útorch.ao.nn.intrinsicÚaor˜   Ú	intrinsicrƒ   Útorch.ao.nn.intrinsic.qatÚqatrw   Útorch.nnÚtorch.nn.utils.fusionr   Útorch.nn.utils.parametrizer   Úutilsr   r   r	   Ú__all__ÚModuler
   r   r5   r"   r!   ú<module>r¨      sZ   ðõ %ã ß #Ó #ß *Ö *Ý Ý 8Ý Cç VÑ Vð   Ð
*€ô`.˜Ÿ™Ÿ™ô `.ôFuÐ$õ ur"   