Ë
    g^(h&5  ã                   óî   — d dl mZ 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)é    )ÚIterable)ÚOptionalN)Ú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
ej                     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      €úb/var/www/skyplay_api_hub/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ÚbiasÚreturnNc                 ó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!   so   € ð �:‰:œŸ™Ò$Ü"'§)¡)×"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.forward5   s   € Øˆr#   c                 óx   •— t         ‰| �  |||«       | j                  ||dz   <   | j                  «       ||dz   <   y )Nr   r,   )r   Ú_save_to_state_dictr   r3   ©r   ÚdestinationÚprefixÚ	keep_varsr!   s       €r"   r;   z&LinearPackedParams._save_to_state_dictH   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_msgsrA   r$   r%   r!   s              €r"   rE   z(LinearPackedParams._load_from_state_dictM   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 r5   )r3   Ú__repr__r2   s    r"   rN   zLinearPackedParams.__repr__t   s   € Ø× Ñ Ó"×+Ñ+Ó-Ð-r#   )Ú__name__Ú
__module__Ú__qualname__Ú_versionr   r   r   ÚjitÚexportÚTensorr   r   r3   r9   r;   rE   rN   Ú__classcell__©r!   s   @r"   r   r      s’   ø„ Ø€Hà"Ÿ[™[õ 	'ð ‡Y�Y×ÑðQØ—l‘lðQØ*2°5·<±<Ñ*@ðQà	ò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ej"                     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   rZ   r[   Ú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ÚQuantizedLinearr6   r2   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=)rZ   r[   r   r   r$   Úqschemer2   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 r5   )r   r   r2   s    r"   rN   zLinear.__repr__º   s   € Ü'¨Ô.@ÓAÐAr#   r8   r&   c                 óª   — t         j                  j                  j                  || j                  j                  | j
                  | j                  «      S r5   )r   r)   r*   Úlinearr,   r   r   r7   s     r"   r9   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   rA   r   r$   r%   z_packed_params.weightz_packed_params.biasF)	r   r   rD   Úintr   rC   Úupdater   rE   rF   s              €r"   rE   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 r5   )r,   r3   r2   s    r"   r3   zLinear._weight_bias  s   € Ø×"Ñ"×/Ñ/Ó1Ð1r#   c                 ó(   — | j                  «       d   S )Nr   ©r3   r2   s    r"   r$   zLinear.weight  ó   € Ø× Ñ Ó" 1Ñ%Ð%r#   c                 ó(   — | j                  «       d   S )Nr   rn   r2   s    r"   r%   zLinear.bias  ro   r#   ÚwÚbNc                 ó<   — | j                   j                  ||«       y r5   )r,   r   )r   rq   rr   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 sJ |j'                  «       «       ‚t        |d«      sJ d«       ‚|j                  }t        |«      t(        j*                  k(  r|d   }t        |d«      s|j,                  j                  «       n|j                  }|s ||j
                  «       |j.                  }|j1                  «       \  }	}
|t2        j4                  k(  sJ 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   z+Weight observer must have dtype torch.qint8r   )#Úhasattrr   ÚnniqatÚ
LinearBn1dr   r$   r%   ÚbnÚrunning_meanÚrunning_varÚepsru   Úactivation_post_processÚ
isinstanceÚ_FLOAT_MODULEr   ÚjoinrO   ÚtypeÚformatÚnniÚ
LinearReLUrv   r   Úcalculate_qparamsr   r   r	   r   rZ   r[   r   r   rj   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  s`  € ô �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ä,¨SÓ1°S×5FÑ5FÑFð"à×ÑÓ!ó"ØFäØ�Yôð >à=ó>ð ð '*×&AÑ&AÐ#Ü+¨CÓ0´C·N±NÒBØ˜!‘f�ô ˜sÐ$7Ô8ð —‘×"Ñ"Ô$à×*Ñ*ð  ñ *ñ   §
¡
Ô+Ø#×)Ñ)ˆØ3×EÑEÓGÑˆ	�6ØœŸ™Ò#ÐRÐ%RÓRÐ#Ü" 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
        )	rZ   r[   Úget_quantized_weightr   r%   r   r   rj   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)rO   rP   rQ   Ú__doc__rR   Únnr   Úmodulesrf   ÚNonDynamicallyQuantizableLinearr€   r   r   r   r`   rc   rN   rU   r9   r;   rE   r3   r$   r%   r   r   Úclassmethodr‘   r—   rV   rW   s   @r"   r   r   x   sÒ   ø„ ñð6 €HØ—Y‘Y §
¡
× 1Ñ 1× QÑ QÐR€Mà8<ÀEÇKÁKõ ò4!ò
òBð
˜Ÿ™ð 
¨%¯,©,ó 
ôDKô%
òR2ò&ò&ð2 §¡ð 2°(¸5¿<¹<Ñ2Hð 2ÈTó 2ð ò;ó ð;ðz ñó ôr#   )Úcollections.abcr   Útypingr   r   Útorch.ao.nn.intrinsicÚaor™   Ú	intrinsicr„   Útorch.ao.nn.intrinsic.qatÚqatrx   Útorch.nnÚtorch.nn.utils.fusionr   Útorch.nn.utils.parametrizer   Úutilsr   r	   r
   Ú__all__ÚModuler   r   r6   r#   r"   ú<module>rª      s]   ðõ %Ý ã ß #Ó #ß *Ö *Ý Ý 8Ý Cç VÑ Vð   Ð
*€ôb.˜Ÿ™Ÿ™ô b.ôJrÐ$õ rr#   