§
    9²¸j,u  ã                   óÖ  — d dl Z d dlZd dlZd dlmZ d dlmZ ddlmZ  ej	        e
¦  «        Z G d„ dej        ¦  «        Z G d„ d	ej        ¦  «        Z G d
„ dej        ¦  «        Z G d„ dej        ¦  «        Z G d„ dej        ¦  «        Z G d„ dej        ¦  «        Zd d„Zd d„Zd d„Z G d„ de¦  «        Z G d„ de¦  «        Z G d„ de¦  «        Zd!d„Z G d„ de¦  «        ZdS )"é    N)Únn)ÚFunctioné   )Úloggingc                   ó>   ‡ — e Zd ZdZ	 	 	 	 	 	 	 	 	 d	ˆ fd„	Zd
d„Zˆ xZS )ÚQuantEmbeddingaÞ  
    Quantized version of `torch.nn.Embedding`. Adds quantization-specific arguments on top of `torch.nn.Embedding`.

    Args:
        weight_bit (`int`, *optional*, defaults to `8`):
            Bitwidth for the quantized weight.
        momentum (`float`, *optional*, defaults to `0.95`):
            Momentum for updating the activation quantization range.
        quant_mode (`bool`, *optional*, defaults to `False`):
            Whether or not the layer is quantized.
    Nç       @Fé   çffffffî?c                 ó  •— t          ¦   «                              ¦   «          || _        || _        || _        || _        || _        || _        || _        t          j
        t          j        ||g¦  «        ¦  «        | _        t          j        t          j        d¦  «        ¦  «        | _        t          j        t          j        | j        ¦  «        ¦  «        | _        |	| _        |
| _        || _        d| _        t,          j        | _        d S ©Né   F)ÚsuperÚ__init__Únum_ÚdimÚpadding_idxÚmax_normÚ	norm_typeÚscale_grad_by_freqÚsparser   Ú	ParameterÚtorchÚzerosÚweightÚBufferÚweight_scaling_factorÚ
zeros_likeÚweight_integerÚ
weight_bitÚmomentumÚ
quant_modeÚpercentile_modeÚSymmetricQuantFunctionÚapplyÚweight_function)ÚselfÚnum_embeddingsÚembedding_dimr   r   r   r   r   Ú_weightr    r!   r"   Ú	__class__s               €úw/root/private/project/pallet_detection_v2/.venv/lib/python3.11/site-packages/transformers/models/ibert/quant_modules.pyr   zQuantEmbedding.__init__+   sÕ   ø€ õ 	‰Œ×ÒÑÔÐØ"ˆŒ	Ø ˆŒØ&ˆÔØ ˆŒØ"ˆŒØ"4ˆÔØˆŒå”l¥5¤;°ÀÐ/NÑ#OÔ#OÑPÔPˆŒÝ%'¤Y­u¬{¸1©~¬~Ñ%>Ô%>ˆÔ"Ý œi­Ô(8¸¼Ñ(EÔ(EÑFÔFˆÔà$ˆŒØ ˆŒØ$ˆŒØ$ˆÔÝ5Ô;ˆÔÐÐó    c           	      ó¸  — | j         sEt          j                             || j        | j        | j        | j        | j        | j	        ¦  «        d fS | j        }|j
                             ¦   «         }|                     ¦   «                              d¦  «        }|                     ¦   «                              d¦  «        }t          | j        ||d¦  «        | _        |                      | j        | j        | j        | j        ¦  «        | _        t          j                             || j        | j        | j        | j        | j        | j	        ¦  «        }|| j        z  | j        fS r   )r"   r   Ú
functionalÚ	embeddingr   r   r   r   r   r   ÚdataÚdetachÚminÚexpandÚmaxÚ$symmetric_linear_quantization_paramsr    r   r&   r#   r   )	r'   ÚxÚ	positionsÚincremental_stateÚwÚw_transformÚw_minÚw_maxÚemb_ints	            r,   ÚforwardzQuantEmbedding.forwardL   s@  € ØŒð 	å”×'Ò'ØØ”KØÔ$Ø”MØ”NØÔ+Ø”Kñô ð ðð ð ŒKˆØ”f—m’m‘o”oˆØ—’Ñ!Ô!×(Ò(¨Ñ+Ô+ˆØ—’Ñ!Ô!×(Ò(¨Ñ+Ô+ˆå%IÈ$Ì/Ð[`ÐbgÐinÑ%oÔ%oˆÔ"Ø"×2Ò2ØŒK˜œ¨$Ô*>ÀÔ@Zñ
ô 
ˆÔõ ”-×)Ò)ØØÔØÔØŒMØŒNØÔ#ØŒKñ
ô 
ˆð ˜Ô3Ñ3°TÔ5OÐOÐOr-   )	NNr	   FFNr
   r   F©NN)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r   r?   Ú__classcell__©r+   s   @r,   r   r      s�   ø€ € € € € ð
ð 
ð  ØØØ ØØØØØð<ð <ð <ð <ð <ð <ðB"Pð "Pð "Pð "Pð "Pð "Pð "Pð "Pr-   r   c                   ó<   ‡ — e Zd ZdZdˆ fd„	Zd„ Z	 	 	 	 	 d	d„Zˆ xZS )
ÚQuantActap  
    Quantizes the given activation.

    Args:
        activation_bit (`int`):
            Bitwidth for the quantized activation.
        act_range_momentum (`float`, *optional*, defaults to `0.95`):
            Momentum for updating the activation quantization range.
        per_channel (`bool`, *optional*, defaults to `False`):
            Whether to or not use channel-wise quantization.
        channel_len (`int`, *optional*):
            Specify the channel length when set the *per_channel* True.
        quant_mode (`bool`, *optional*, defaults to `False`):
            Whether or not the layer is quantized.
    r   FNc                 ó  •— t          ¦   «                              ¦   «          || _        || _        || _        || _        d| _        t          j        | _	        | j        s£t          j        t          j        d¦  «        ¦  «        | _        t          j        t          j        d¦  «        ¦  «        | _        t          j        t          j        d¦  «        ¦  «        | _        | xj        dz  c_        | xj        dz  c_        d S t#          d¦  «        ‚)NFr   gñhãˆµøä>ú;per-channel mode is not currently supported for activation.)r   r   Úactivation_bitÚact_range_momentumr"   Úper_channelÚ
percentiler$   r%   Úact_functionr   r   r   r   Úx_minÚx_maxÚact_scaling_factorÚNotImplementedError)r'   rK   rL   rM   Úchannel_lenr"   r+   s         €r,   r   zQuantAct.__init__‚   sÕ   ø€ Ý‰Œ×ÒÑÔÐà,ˆÔØ"4ˆÔØ$ˆŒØ&ˆÔØˆŒÝ2Ô8ˆÔàÔð 	eÝœ¥5¤;¨q¡>¤>Ñ2Ô2ˆDŒJÝœ¥5¤;¨q¡>¤>Ñ2Ô2ˆDŒJÝ&(¤iµ´¸A±´Ñ&?Ô&?ˆDÔ#ØˆJŒJ˜$ÑˆJŒJØˆJŒJ˜$ÑˆJŒJˆJˆJå%Ð&cÑdÔdÐdr-   c           
      ó¬   — | j         j        › d| j        › d| j        › d| j                             ¦   «         d›d| j                             ¦   «         d›d�
S )Nz(activation_bit=z, quant_mode: z, Act_min: z.2fz, Act_max: ú))r+   rA   rK   r"   rP   ÚitemrQ   )r'   s    r,   Ú__repr__zQuantAct.__repr__•   st   € àŒ~Ô&ð 1ð 1¸Ô8Kð 1ð 1Øœ?ð1ð 1Ø7;´z·²Ñ7HÔ7HÐPð1ð 1àœ
ŸšÑ)Ô)Ð0ð1ð 1ð 1ð	
r-   c                 óÎ  — |€|n||z   }| j         �r™| j        r
J d¦   «         ‚| j        r
J d¦   «         ‚|j                             ¦   «         }|j                             ¦   «         }	|	                     ¦   «                              ¦   «         dk    r*|                     ¦   «                              ¦   «         dk    s
J d¦   «         ‚| j                             ¦   «         dk    r<| j	                             ¦   «         dk     r| j        |z   | _        | j	        |	z   | _	        nŽ| j
        dk    r?t          j        | j        |¦  «        | _        t          j        | j	        |	¦  «        | _	        nD| j        | j
        z  |d| j
        z
  z  z   | _        | j	        | j
        z  |	d| j
        z
  z  z   | _	        | j        s|d fS |€| j        n|}|€| j	        n|}	t          | j        ||	| j        ¬	¦  «        | _        |€(|                      || j        | j        | j        ¦  «        }
n)t"                               ||| j        | j        ||¦  «        }
| j                             d¦  «        }|
|z  | j        fS )
Nz:percentile mode is not currently supported for activation.rJ   r   z5NaN detected when computing min/max of the activationg¢&ú|”ç¾g¢&ú|”ç>éÿÿÿÿr   )rM   )ÚtrainingrN   rM   r1   r3   r5   ÚisnanÚsumrP   rQ   rL   r   r"   r6   rK   rR   rO   ÚFixedPointMulr%   Úview)r'   r7   Úpre_act_scaling_factorÚidentityÚidentity_scaling_factorÚspecified_minÚspecified_maxÚx_actrP   rQ   Úquant_act_intÚcorrect_output_scales               r,   r?   zQuantAct.forwardœ   sr  € ð Ð%��¨8°a©<ˆàŒ=ñ 	jØ”ÐdÐdÐ(dÑdÔdÐ&ØÔ'ÐfÐfÐ)fÑfÔfÐ'Ø”J—N’NÑ$Ô$ˆEØ”J—N’NÑ$Ô$ˆEà—;’;‘=”=×$Ò$Ñ&Ô&¨!Ò+Ð+°·²±´×0AÒ0AÑ0CÔ0CÀqÒ0HÐ0HÐ0HØGñ 1IÔ0HÐHð
 Œz�~Š~ÑÔ 'Ò)Ð)¨d¬j¯nªnÑ.>Ô.>ÀÒ.GÐ.GØ!œZ¨%Ñ/�”
Ø!œZ¨%Ñ/�”
�
ð Ô(¨BÒ.Ð.Ý"œY t¤z°5Ñ9Ô9�”
Ý"œY t¤z°5Ñ9Ô9�”
�
à!œZ¨$Ô*AÑAÀEÈQÐQUÔQhÑMhÑDiÑi�”
Ø!œZ¨$Ô*AÑAÀEÈQÐQUÔQhÑMhÑDiÑi�”
àŒð 	Ø˜$�;Ðà+Ð3�”
�
¸ˆØ+Ð3�”
�
¸ˆå"FØÔ ¨¸4Ô;Kð#
ñ #
ô #
ˆÔð "Ð)à ×-Ò-¨a°Ô1DÀdÄoÐW[ÔWnÑoÔoˆMˆMå)×/Ò/ØØ&ØÔ#ØÔ'ØØ'ñô ˆMð  $Ô6×;Ò;¸BÑ?Ô?ÐàÐ3Ñ3°TÔ5LÐLÐLr-   )r   FNF)NNNNN©rA   rB   rC   rD   r   rX   r?   rE   rF   s   @r,   rH   rH   q   s‰   ø€ € € € € ðð ð eð eð eð eð eð eð&
ð 
ð 
ð  $ØØ $ØØð<Mð <Mð <Mð <Mð <Mð <Mð <Mð <Mr-   rH   c                   ó8   ‡ — e Zd ZdZ	 d
ˆ fd„	Zˆ fd„Zdd	„Zˆ xZS )ÚQuantLineara8  
    Quantized version of `torch.nn.Linear`. Adds quantization-specific arguments on top of `torch.nn.Linear`.

    Args:
        weight_bit (`int`, *optional*, defaults to `8`):
            Bitwidth for the quantized weight.
        bias_bit (`int`, *optional*, defaults to `32`):
            Bitwidth for the quantized bias.
        per_channel (`bool`, *optional*, defaults to `False`):
            Whether or not to use channel-wise quantization.
        quant_mode (`bool`, *optional*, defaults to `False`):
            Whether or not the layer is quantized.
    Tr
   é    Fc                 ó®  •— t          ¦   «                              ¦   «          || _        || _        t	          j        t          j        ||g¦  «        ¦  «        | _        t	          j	        t          j
        | j        ¦  «        ¦  «        | _        t	          j	        t          j        | j        ¦  «        ¦  «        | _        |r[t	          j        t          j        |¦  «        ¦  «        | _        t	          j	        t          j
        | j        ¦  «        ¦  «        | _        || _        || _        || _        || _        || _        d| _        t(          j        | _        d S )NF)r   r   Úin_featuresÚout_featuresr   r   r   r   r   r   r   r   Úfc_scaling_factorÚbiasÚbias_integerr    r"   rM   Úbias_bitr#   r$   r%   r&   )	r'   rm   rn   rp   r    rr   rM   r"   r+   s	           €r,   r   zQuantLinear.__init__ê   s	  ø€ õ 	‰Œ×ÒÑÔÐØ&ˆÔØ(ˆÔå”l¥5¤;°¸kÐ/JÑ#KÔ#KÑLÔLˆŒÝ œi­Ô(8¸¼Ñ(EÔ(EÑFÔFˆÔÝ!#¤­5¬;°tÔ7HÑ+IÔ+IÑ!JÔ!JˆÔØð 	GÝœ¥U¤[°Ñ%>Ô%>Ñ?Ô?ˆDŒIÝ "¤	­%Ô*:¸4¼9Ñ*EÔ*EÑ FÔ FˆDÔà$ˆŒØ$ˆŒØ&ˆÔØ ˆŒØ$ˆŒØ$ˆÔÝ5Ô;ˆÔÐÐr-   c                 ót   •— t          ¦   «                              ¦   «         }d|› d| j        › d| j        › d�}|S )Nú(z weight_bit=z, quant_mode=rV   )r   rX   r    r"   )r'   Úsr+   s     €r,   rX   zQuantLinear.__repr__   sA   ø€ Ý‰GŒG×ÒÑÔˆØO�ÐOÐO˜tœÐOÐO¸T¼_ÐOÐOÐOˆØˆr-   Nc                 óš  — | j         s.t          j                             || j        | j        ¬¦  «        d fS |�|j        dk    s
J d¦   «         ‚| j        }|j                             ¦   «         }| j	        r5t          j        |dd ¬¦  «        \  }}t          j        |dd ¬¦  «        \  }}nN|                     ¦   «                              d¦  «        }|                     ¦   «                              d¦  «        }t          | j        ||| j	        ¦  «        | _        |                      | j        | j        | j        | j        ¦  «        | _        | j        |z  }| j        �'|                      | j        | j        d|¦  «        | _        |                     dd¦  «        }||z  }	t          j                             |	| j        | j        ¬¦  «        |z  |fS )N)r   rp   )r   z«Input activation to the QuantLinear layer should be globally (non-channel-wise) quantized. Please add a QuantAct layer with `per_channel = True` before this QuantAct layerr   )r   ÚoutFrZ   )r"   r   r/   Úlinearr   rp   Úshaper1   r2   rM   r   r3   r5   r4   r6   r    ro   r&   r#   r   rr   rq   r_   )
r'   r7   Úprev_act_scaling_factorr:   r;   r<   Ú_r=   Úbias_scaling_factorÚx_ints
             r,   r?   zQuantLinear.forward  sÌ  € ØŒð 	UÝ”=×'Ò'¨°$´+ÀDÄIÐ'ÑNÔNÐPTÐTÐTð 'Ð2Ð7NÔ7TÐX\Ò7\Ð7\Ð7\ð_ñ 8]Ô7\Ð\ð
 ŒKˆØ”f—m’m‘o”oˆØÔð 	0Ý”y °!¸Ð>Ñ>Ô>‰HˆE�1Ý”y °!¸Ð>Ñ>Ô>‰HˆE�1�1à—O’OÑ%Ô%×,Ò,¨QÑ/Ô/ˆEØ—O’OÑ%Ô%×,Ò,¨QÑ/Ô/ˆEå!EÀdÄoÐW\Ð^cÐeiÔeuÑ!vÔ!vˆÔØ"×2Ò2ØŒK˜œ¨$Ô*>ÀÔ@Vñ
ô 
ˆÔð #Ô4Ð7NÑNÐàŒ9Ð Ø $× 4Ò 4°T´YÀÄÈuÐViÑ jÔ jˆDÔà"9×">Ò">¸qÀ"Ñ"EÔ"EÐØÐ+Ñ+ˆõ ŒM× Ò  ¨tÔ/BÈÔIZÐ Ñ[Ô[Ð^qÑqØð
ð 	
r-   )Tr
   rk   FF©Nrh   rF   s   @r,   rj   rj   Û   s{   ø€ € € € € ðð ð nsð<ð <ð <ð <ð <ð <ð,ð ð ð ð ð
#
ð #
ð #
ð #
ð #
ð #
ð #
ð #
r-   rj   c                   ó2   ‡ — e Zd ZdZdˆ fd„	Zd„ Zd	d„Zˆ xZS )
ÚIntGELUa}  
    Quantized version of `torch.nn.GELU`. Adds quantization-specific arguments on top of `torch.nn.GELU`.

    Args:
        quant_mode (`bool`, *optional*, defaults to `False`):
            Whether or not the layer is quantized.
        force_dequant (`str`, *optional*, defaults to `"none"`):
            Force dequantize the layer if either "gelu" or "nonlinear" is given.
    TÚnonec                 óL  •— t          ¦   «                              ¦   «          || _        |dv r!t                               d¦  «         d| _        | j        st          j        ¦   «         | _        d| _        d| _	        g d¢| _
        | j
        dxx         | j
        d         z  cc<   d S )	N)Ú	nonlinearÚgeluzForce dequantize geluFgà-� ö?é   )g]mÅþ²{Ò¿gçû©ñÒMü¿r   é   r   )r   r   r"   ÚloggerÚinfor   ÚGELUÚactivation_fnÚkÚconstÚcoeff)r'   r"   Úforce_dequantr+   s      €r,   r   zIntGELU.__init__6  s›   ø€ Ý‰Œ×ÒÑÔÐØ$ˆŒàÐ1Ð1Ð1Ý�KŠKÐ/Ñ0Ô0Ð0Ø#ˆDŒOàŒð 	+Ý!#¤¡¤ˆDÔàˆŒØˆŒ
Ø)Ð)Ð)ˆŒ
ØŒ
�1ˆˆŒ˜œ AœÑ&ˆˆ‰ˆˆr-   c                 ó¶  — t          j        | j        d         |z  ¦  «        }t          j        | j        d         |dz  z  ¦  «        }t          j        |¦  «        }t          j        t          j        |¦  «        | ¦  «        }|||z   dz  |z   z  }|dz  | j        d         z  }t                               |d| j        z  z  ¦  «        }|d| j        z  z  }||fS ©Nr   r†   r   )	r   Úfloorr�   Úsignr3   ÚabsÚ	floor_ster%   rŒ   )r'   r}   Úscaling_factorÚb_intÚc_intr’   Úabs_intÚy_ints           r,   Úint_erfzIntGELU.int_erfF  sÍ   € Ý”˜DœJ qœM¨NÑ:Ñ;Ô;ˆÝ”˜DœJ qœM¨N¸AÑ,=Ñ=Ñ>Ô>ˆÝŒz˜%Ñ Ô ˆå”)�EœI eÑ,Ô,¨u¨fÑ5Ô5ˆØ˜ 5™¨QÑ.°Ñ6Ñ7ˆØ'¨Ñ*¨T¬Z¸¬]Ñ:ˆõ —’ ¨¨4¬:©Ñ 5Ñ6Ô6ˆØ'¨!¨T¬Z©-Ñ7ˆà�nÐ$Ð$r-   Nc                 óÂ   — | j         s|                      |¦  «        d fS ||z  }|                      ||| j        z  ¦  «        \  }}d|z  }|||z   z  }||z  dz  }||z  |fS )Nç      ð?r†   )r"   rŠ   rš   r‹   )r'   r7   r•   r}   Úsigmoid_intÚsigmoid_scaling_factorÚ	shift_ints          r,   r?   zIntGELU.forwardU  s‹   € ØŒð 	/Ø×%Ò% aÑ(Ô(¨$Ð.Ð.à�NÑ"ˆØ.2¯lªl¸5À.ÐSWÔSYÑBYÑ.ZÔ.ZÑ+ˆÐ+àÐ1Ñ1ˆ	à˜ yÑ0Ñ1ˆØ'Ð*@Ñ@À1ÑDˆà�~Ñ% ~Ð5Ð5r-   )Tr�   r~   )rA   rB   rC   rD   r   rš   r?   rE   rF   s   @r,   r€   r€   +  sj   ø€ € € € € ðð ð'ð 'ð 'ð 'ð 'ð 'ð %ð %ð %ð6ð 6ð 6ð 6ð 6ð 6ð 6ð 6r-   r€   c                   ó6   ‡ — e Zd ZdZdˆ fd„	Zd„ Zd„ Zd„ Zˆ xZS )	Ú
IntSoftmaxaØ  
    Quantized version of `torch.nn.Softmax`. Adds quantization-specific arguments on top of `torch.nn.Softmax`.

    Args:
        output_bit (`int`):
            Bitwidth for the layer output activation.
        quant_mode (`bool`, *optional*, defaults to `False`):
            Whether or not the layer is quantized.
        force_dequant (`str`, *optional*, defaults to `"none"`):
            Force dequantize the layer if either "softmax" or "nonlinear" is given.
    Fr�   c                 ó   •— t          ¦   «                              ¦   «          || _        d| _        || _        |dv r!t
                               d¦  «         d| _        t          d| j        ¬¦  «        | _        d| _	        d| _
        g d	¢| _        | j        d
xx         | j        d         z  cc<   | j        dxx         | j        d         z  cc<   d S )Nrk   )rƒ   ÚsoftmaxzForce dequantize softmaxFé   ©r"   gvqà-æ¿é   )gN„ª$ôëÖ?g¾Ã'|:ï?rœ   r   r   r†   )r   r   Ú
output_bitÚmax_bitr"   r‡   rˆ   rH   ÚactÚx0rŒ   Úcoef)r'   r§   r"   rŽ   r+   s       €r,   r   zIntSoftmax.__init__q  sÅ   ø€ Ý‰Œ×ÒÑÔÐØ$ˆŒØˆŒØ$ˆŒàÐ4Ð4Ð4Ý�KŠKÐ2Ñ3Ô3Ð3Ø#ˆDŒOå˜B¨4¬?Ð;Ñ;Ô;ˆŒØˆŒØˆŒ
Ø1Ð1Ð1ˆŒ	ØŒ	�!ˆˆŒ˜œ	 !œÑ$ˆˆ‰ØŒ	�!ˆˆŒ˜œ	 !œÑ$ˆˆ‰ˆˆr-   c                 ó*  — t          j        ¦   «         5  t          j        | j        d         |z  ¦  «        }t          j        | j        d         |dz  z  ¦  «        }d d d ¦  «         n# 1 swxY w Y   ||z   |z  |z   }| j        d         |dz  z  }||fS r�   )r   Úno_gradr‘   r«   )r'   r}   r•   r–   r—   Úzs         r,   Úint_polynomialzIntSoftmax.int_polynomial‚  sâ   € ÝŒ]‰_Œ_ð 	Bð 	BÝ”K ¤	¨!¤¨~Ñ =Ñ>Ô>ˆEÝ”K ¤	¨!¤¨~¸qÑ/@Ñ @ÑAÔAˆEð	Bð 	Bð 	Bñ 	Bô 	Bð 	Bð 	Bð 	Bð 	Bð 	Bð 	Bøøøð 	Bð 	Bð 	Bð 	Bð �U‰]˜eÑ# eÑ+ˆØœ 1œ¨¸Ñ(9Ñ9ˆØ�.Ð Ð s   ”AA(Á(A,Á/A,c                 óà  — t          j        ¦   «         5  t          j        | j        |z  ¦  «        }d d d ¦  «         n# 1 swxY w Y   t          j        || j        |z  ¦  «        }t                               ||z  ¦  «        }|||z  z
  }|                      ||¦  «        \  }}t          j	        t                               |d| j        |z
  z  z  ¦  «        d¬¦  «        }|d| j        z  z  }||fS )Nr†   r   ©r3   )
r   r­   r‘   rª   r5   rŒ   r”   r%   r¯   Úclamp)r'   r}   r•   Úx0_intÚqÚrÚexp_intÚexp_scaling_factors           r,   Úint_expzIntSoftmax.int_expŠ  s  € ÝŒ]‰_Œ_ð 	;ð 	;Ý”[ ¤¨>Ñ!9Ñ:Ô:ˆFð	;ð 	;ð 	;ñ 	;ô 	;ð 	;ð 	;ð 	;ð 	;ð 	;ð 	;øøøð 	;ð 	;ð 	;ð 	;å”	˜% ¤¨fÑ!4Ñ5Ô5ˆå�OŠO˜E F™NÑ+Ô+ˆØ�F˜Q‘JÑˆØ&*×&9Ò&9¸!¸^Ñ&LÔ&LÑ#ˆÐ#Ý”+�iŸošo¨g¸¸d¼jÈ1¹nÑ8MÑ.MÑNÔNÐTUÐVÑVÔVˆØ+¨a°´©mÑ;ˆØ˜Ð&Ð&s   ”=½AÁAc                 ó  — | j         s#t          j                             |d¬¦  «        d fS ||z  }|                     dd¬¦  «        \  }}||z
  }|                      ||¦  «        \  }}|                      ||¦  «        \  }}||z  }|                     dd¬¦  «        }	t           	                    d| j
        z  |	z  ¦  «        }
t           	                    ||
z  d| j
        | j        z
  z  z  ¦  «        }dd| j        z  z  }||z  |fS )NrZ   ©r   T)r   Úkeepdimr†   r   )r"   r   r/   r£   r5   r¸   r©   r]   r”   r%   r¨   r§   )r'   r7   r•   r}   Ú	x_int_maxr{   r¶   r·   ÚexpÚexp_int_sumÚfactors              r,   r?   zIntSoftmax.forward–  s  € ØŒð 	:Ý”=×(Ò(¨°Ð(Ñ3Ô3°TÐ9Ð9à�NÑ"ˆà—y’y R°�yÑ6Ô6‰ˆ	�1Ø˜	Ñ!ˆØ&*§l¢l°5¸.Ñ&IÔ&IÑ#ˆÐ#ð #'§(¢(¨7Ð4FÑ"GÔ"GÑˆÐØÐ*Ñ*ˆà—k’k b°$�kÑ7Ô7ˆÝ—’  D¤L¡°;Ñ!>Ñ?Ô?ˆÝ—/’/ '¨FÑ"2°Q¸4¼<È$Ì/Ñ;YÑ5ZÑ"ZÑ[Ô[ˆØ˜Q ¤Ñ/Ñ/ˆØ˜Ñ'¨Ð7Ð7r-   )Fr�   )	rA   rB   rC   rD   r   r¯   r¸   r?   rE   rF   s   @r,   r¡   r¡   d  st   ø€ € € € € ð
ð 
ð%ð %ð %ð %ð %ð %ð"!ð !ð !ð
'ð 
'ð 
'ð8ð 8ð 8ð 8ð 8ð 8ð 8r-   r¡   c                   ó8   ‡ — e Zd ZdZd
ˆ fd„	Zd„ Zd„ Zdd	„Zˆ xZS )ÚIntLayerNormaû  
    Quantized version of `torch.nn.LayerNorm`. Adds quantization-specific arguments on top of `torch.nn.LayerNorm`.

    Args:
        output_bit (`int`, *optional*, defaults to `8`):
            Bitwidth for the layer output activation.
        quant_mode (`bool`, *optional*, defaults to `False`):
            Whether or not the layer is quantized.
        force_dequant (`str`, *optional*, defaults to `"none"`):
            Force dequantize the layer if either "layernorm" or "nonlinear" is given.
    r
   Fr�   c                 ó(  •— t          ¦   «                              ¦   «          || _        || _        t	          j        t          j        |¦  «        ¦  «        | _        t	          j        t          j        |¦  «        ¦  «        | _	        || _
        |dv r!t                               d¦  «         d| _
        t	          j        t          j        d¦  «        ¦  «        | _        || _        d| _        d | _        t%          | j        | j
        ¬¦  «        | _        d S )N)rƒ   Ú	layernormzForce dequantize layernormFr   rk   r¥   )r   r   Únormalized_shapeÚepsr   r   r   r   r   rp   r"   r‡   rˆ   r   Úshiftr§   r¨   Údim_sqrtrH   Ú
activation)r'   rÄ   rÅ   r§   r"   rŽ   r+   s         €r,   r   zIntLayerNorm.__init__¸  s×   ø€ Ý‰Œ×ÒÑÔÐØ 0ˆÔØˆŒå”l¥5¤;Ð/?Ñ#@Ô#@ÑAÔAˆŒÝ”L¥¤Ð-=Ñ!>Ô!>Ñ?Ô?ˆŒ	à$ˆŒØÐ6Ð6Ð6Ý�KŠKÐ4Ñ5Ô5Ð5Ø#ˆDŒOå”Y�uœ{¨1™~œ~Ñ.Ô.ˆŒ
Ø$ˆŒØˆŒØˆŒÝ" 4¤?¸t¼ÐOÑOÔOˆŒˆˆr-   c           	      ó
  — t          j        ¦   «         5  |dz  }t          j        |dd¬¦  «        }t          j        t          j        |d| j        z  z  ¦  «        ¦  «                             ¦   «                              ¦   «         }| j        }t          j        | j        |¦  «        | _        t           
                    dt          |¦  «        › dt          | j        ¦  «        › �¦  «         d d d ¦  «         d S # 1 swxY w Y   d S )Nr†   T©Úaxisr»   zDynamic shift adjustment: z -> )r   r­   r]   Úlog2Úsqrtr¨   Úceilr5   rÆ   r‡   rˆ   Úint)r'   r™   Úy_sq_intÚvar_intrÆ   Ú	shift_olds         r,   Ú	set_shiftzIntLayerNorm.set_shiftË  s.  € ÝŒ]‰_Œ_ð 	\ð 	\Ø˜a‘xˆHÝ”i ¨q¸$Ð?Ñ?Ô?ˆGÝ”Z¥¤
¨7°Q¸¼±_Ñ+DÑ EÔ EÑFÔF×KÒKÑMÔM×RÒRÑTÔTˆEØœ
ˆIÝœ 4¤:¨uÑ5Ô5ˆDŒJÝ�KŠKÐZµS¸±^´^ÐZÐZÍÈTÌZÉÌÐZÐZÑ[Ô[Ð[ð	\ð 	\ð 	\ñ 	\ô 	\ð 	\ð 	\ð 	\ð 	\ð 	\ð 	\ð 	\øøøð 	\ð 	\ð 	\ð 	\ð 	\ð 	\s   ”CC8Ã8C<Ã?C<c                 ó²   — |                       |¦  «         t                               |d| j        z  z  ¦  «        }|dz  }t	          j        |dd¬¦  «        }|S )z±
        This fallback function is called when overflow is detected during training time, and adjusts the `self.shift`
        to avoid overflow in the subsequent runs.
        r†   TrÊ   )rÓ   r”   r%   rÆ   r   r]   )r'   r™   Úy_int_shiftedrÐ   rÑ   s        r,   Úoverflow_fallbackzIntLayerNorm.overflow_fallbackÔ  sW   € ð
 	�Š�uÑÔÐÝ!Ÿš¨°°4´:±Ñ(=Ñ>Ô>ˆØ  !Ñ#ˆÝ”)˜H¨1°dÐ;Ñ;Ô;ˆØˆr-   Nc                 óR  — | j         sk|                     dd¬¦  «        }||z
  }t          j        |dz  dd¬¦  «        }|t          j        | j        |z   ¦  «        z  }|| j        z  | j        z   }|d fS | j        €\t          j        |j	        d         t          j
        ¬¦  «        }t          j        |¦  «                             |j        ¦  «        | _        ||z  }t                               |                     dd¬¦  «        ¦  «        }||z
  }	t                               |	d| j        z  z  ¦  «        }
|
dz  }t          j        |dd¬¦  «        }| j        rb|                     ¦   «         d| j        z  k    rB|                      |	¦  «        }|                     ¦   «         d| j        z  dz   k     s
J d¦   «         ‚t                               t          j        |¦  «        ¦  «        d| j        z  z  }t                               d|z  ¦  «        }t                               |	|z  dz  ¦  «        }	| j        dz  }| j        j                             ¦   «         | j        j                             ¦   «         z  }t                               ||z  ¦  «        }|	|z   }	|| j        z  }|	|z  }||fS )	Nr†   TrÊ   )Údtypegš™™™™™¹?zfError detected in overflow handling: `var_int` exceeds `self.max_bit` (the maximum possible bit width)l        i   @)r"   Úmeanr   rÍ   rÅ   r   rp   rÇ   Útensorry   ÚfloatÚtoÚdeviceÚ	round_ster%   r”   rÆ   r]   r[   r5   r¨   rÖ   r1   r2   )r'   r7   r•   rÙ   ÚyÚvarÚnr}   Úmean_intr™   rÕ   rÐ   rÑ   Ústd_intr¿   rp   Úbias_ints                    r,   r?   zIntLayerNorm.forwardß  sl  € ØŒð 	Ø—6’6˜q¨$�6Ñ/Ô/ˆDØ�D‘ˆAÝ”*˜Q ™T¨°4Ð8Ñ8Ô8ˆCØ•E”J˜tœx¨#™~Ñ.Ô.Ñ.ˆAØ�D”K‘ $¤)Ñ+ˆAØ�d�7ˆNð Œ=Ð Ý”˜QœW QœZ­u¬{Ð;Ñ;Ô;ˆAÝ!œJ q™MœM×,Ò,¨Q¬XÑ6Ô6ˆDŒMð �NÑ"ˆÝ—?’? 5§:¢:°1¸d :Ñ#CÔ#CÑDÔDˆØ˜Ñ ˆÝ!Ÿš¨°°4´:±Ñ(=Ñ>Ô>ˆØ  !Ñ#ˆÝ”)˜H¨1°dÐ;Ñ;Ô;ˆð Œ=ð 	à�{Š{‰}Œ}  4¤<¡Ò/Ð/Ø×0Ò0°Ñ7Ô7�Ø—{’{‘}”} q¨$¬,¡¸Ñ'<Ò<Ð<Ð<ðXñ =Ô<Ð<õ —/’/¥%¤*¨WÑ"5Ô"5Ñ6Ô6¸¸D¼J¹ÑFˆÝ—’ ¨¡Ñ1Ô1ˆÝ—’ ¨¡°Ñ 2Ñ3Ô3ˆØœ¨Ñ.ˆð ŒyŒ~×$Ò$Ñ&Ô&¨$¬+Ô*:×*AÒ*AÑ*CÔ*CÑDˆÝ—?’? 4¨.Ñ#8Ñ9Ô9ˆà˜Ñ ˆØ'¨$¬+Ñ5ˆØ�NÑ"ˆà�.Ð Ð r-   )r
   Fr�   r~   )	rA   rB   rC   rD   r   rÓ   rÖ   r?   rE   rF   s   @r,   rÁ   rÁ   «  s‚   ø€ € € € € ð
ð 
ðPð Pð Pð Pð Pð Pð&\ð \ð \ð	ð 	ð 	ð.!ð .!ð .!ð .!ð .!ð .!ð .!ð .!r-   rÁ   Fc                 óZ  — | j         d         }t          |d|dz  z
  z  ¦  «        }t          ||z  dz  ¦  «        }t          j        | |¬¦  «        j        }|dk    r|dz  }nt          j        |  |¬¦  «        j         }|s(|                     ¦   «         }|                     ¦   «         }||fS )aÆ  
    Calculate the percentile max and min values in a given tensor

    Args:
        input (`torch.Tensor`):
            The target tensor to calculate percentile max and min.
        lower_percentile (`float`):
            If 0.1, means we return the value of the smallest 0.1% value in the tensor as percentile min.
        upper_percentile (`float`):
            If 99.9, means we return the value of the largest 0.1% value in the tensor as percentile max.
        output_tensor (`bool`, *optional*, defaults to `False`):
            If True, this function returns tensors, otherwise it returns values.

    Returns:
        `Tuple(torch.Tensor, torch.Tensor)`: Percentile min and max value of *input*
    r   r   g{®Gáz„?)r‹   )ry   Úroundr   ÚkthvalueÚvaluesrW   )	ÚinputÚlower_percentileÚupper_percentileÚoutput_tensorÚinput_lengthÚlower_indexÚupper_indexÚupper_boundÚlower_bounds	            r,   Úget_percentile_min_maxrò     sÄ   € ð" ”;˜q”>€Lå˜¨Ð,<¸tÑ,CÑ(CÑDÑEÔE€KÝ˜Ð'7Ñ7¸$Ñ>Ñ?Ô?€Kå”. ¨+Ð6Ñ6Ô6Ô=€Kà˜1ÒÐØ! A‘oˆˆõ ”~ u f°Ð<Ñ<Ô<ÔCÐCˆàð )Ø!×&Ò&Ñ(Ô(ˆØ!×&Ò&Ñ(Ô(ˆØ˜Ð#Ð#r-   c                 ó.  — t          | j        ¦  «        dk    r1|                     dddd¦  «        }|                     dddd¦  «        }not          | j        ¦  «        dk    r-|                     dd¦  «        }|                     dd¦  «        }n*|                     d¦  «        }|                     d¦  «        }|r?|                      d|z  ¦  «                             |¦  «                             ¦   «          | S t          j        d|z  | z  |z   ¦  «        S )a@  
    Quantize single-precision input tensor to integers with the given scaling factor and zeropoint.

    Args:
        input (`torch.Tensor`):
            Single-precision input tensor to be quantized.
        scale (`torch.Tensor`):
            Scaling factor for quantization.
        zero_point (`torch.Tensor`):
            Shift for quantization.
        inplace (`bool`, *optional*, defaults to `False`):
            Whether to compute inplace or not.

    Returns:
        `torch.Tensor`: Linearly quantized value of *input* according to *scale* and *zero_point*.
    é   rZ   r   r†   rœ   )Úlenry   r_   Úmul_Úadd_Úround_r   ræ   )ré   ÚscaleÚ
zero_pointÚinplaces       r,   Úlinear_quantizerü   4  s  € õ$ ˆ5Œ;ÑÔ˜1ÒÐØ—
’
˜2˜q ! QÑ'Ô'ˆØ—_’_ R¨¨A¨qÑ1Ô1ˆ
ˆ
å	ˆUŒ[Ñ	Ô	˜QÒ	Ð	Ø—
’
˜2˜qÑ!Ô!ˆØ—_’_ R¨Ñ+Ô+ˆ
ˆ
à—
’
˜2‘”ˆØ—_’_ RÑ(Ô(ˆ
àð Ø�
Š
�3˜‘;ÑÔ×$Ò$ ZÑ0Ô0×7Ò7Ñ9Ô9Ð9ØˆÝŒ;�s˜U‘{ UÑ*¨ZÑ7Ñ8Ô8Ð8r-   c                 óê  — t          j        ¦   «         5  d| dz
  z  dz
  }|rmt          j        t          j        |                     ¦   «         |                     ¦   «         gd¬¦  «        d¬¦  «        \  }}t          j        |d¬¦  «        |z  }nMt          |                     ¦   «         |                     ¦   «         ¦  «        }t          j        |d¬¦  «        |z  }ddd¦  «         n# 1 swxY w Y   |S )a/  
    Compute the scaling factor with the given quantization range for symmetric quantization.

    Args:
        saturation_min (`torch.Tensor`):
            Lower bound for quantization range.
        saturation_max (`torch.Tensor`):
            Upper bound for quantization range.
        per_channel (`bool`, *optional*, defaults to `False`):
            Whether to or not use channel-wise quantization.

    Returns:
        `torch.Tensor`: Scaling factor that linearly quantizes the given range between *saturation_min* and
        *saturation_max*.
    r†   r   rº   g:Œ0âŽyE>r±   N)r   r­   r5   Ústackr“   r²   )Únum_bitsÚsaturation_minÚsaturation_maxrM   rá   rù   r{   s          r,   r6   r6   W  s*  € õ$ 
Œ‰Œð 	5ð 	5Ø�(˜Q‘,Ñ !Ñ#ˆàð 	5Ý”y¥¤¨n×.@Ò.@Ñ.BÔ.BÀN×DVÒDVÑDXÔDXÐ-YÐ_`Ð!aÑ!aÔ!aÐghÐiÑiÔi‰HˆE�1Ý”K ¨4Ð0Ñ0Ô0°1Ñ4ˆEˆEõ ˜×*Ò*Ñ,Ô,¨n×.@Ò.@Ñ.BÔ.BÑCÔCˆEÝ”K ¨4Ð0Ñ0Ô0°1Ñ4ˆEð	5ð 	5ð 	5ñ 	5ô 	5ð 	5ð 	5ð 	5ð 	5ð 	5ð 	5øøøð 	5ð 	5ð 	5ð 	5ð €Ls   ”CC(Ã(C,Ã/C,c                   ó>   — e Zd ZdZed„ ¦   «         Zed„ ¦   «         ZdS )r$   zw
    Class to quantize the given floating-point values using symmetric quantization with given range and bitwidth.
    c                 óº   — t          j        d|j        ¬¦  «        }d|dz
  z  dz
  }t          |||d¬¦  «        }t          j        || |dz
  ¦  «        }|| _        |S )a6  
        Args:
            x (`torch.Tensor`):
                Floating point tensor to be quantized.
            k (`int`):
                Quantization bitwidth.
            percentile_mode (`bool`):
                Whether or not to use percentile calibration.
            scale (`torch.Tensor`):
                Pre-calculated scaling factor for *x*. Note that the current implementation of SymmetricQuantFunction
                requires pre-calculated scaling factor.

        Returns:
            `torch.Tensor`: Symmetric-quantized value of *input*.
        g        )rÝ   r†   r   F)rû   )r   rÚ   rÝ   rü   r²   rù   )Úctxr7   r‹   r#   rù   rú   rá   Únew_quant_xs           r,   r?   zSymmetricQuantFunction.forward|  sh   € õ" ”\ #¨e¬lÐ;Ñ;Ô;ˆ
à�!�a‘%‰L˜1ÑˆÝ% a¨°
ÀEÐJÑJÔJˆÝ”k +°¨r°1°q±5Ñ9Ô9ˆàˆŒ	ØÐr-   c                 ó2  — | j         }t          |j        ¦  «        dk    r|                     dddd¦  «        }nDt          |j        ¦  «        dk    r|                     dd¦  «        }n|                     d¦  «        }|                     ¦   «         |z  d d d d fS )Nrô   rZ   r   r†   )rù   rõ   ry   r_   Úclone)r  Úgrad_outputrù   s      r,   ÚbackwardzSymmetricQuantFunction.backward–  s”   € à”	ˆÝˆ{Ô Ñ!Ô! QÒ&Ð&Ø—J’J˜r 1 a¨Ñ+Ô+ˆEˆEå�Ô"Ñ#Ô# qÒ(Ð(Ø—J’J˜r 1Ñ%Ô%ˆEˆEà—J’J˜r‘N”NˆEà× Ò Ñ"Ô" UÑ*¨D°$¸¸dÐBÐBr-   N©rA   rB   rC   rD   Ústaticmethodr?   r	  © r-   r,   r$   r$   w  sY   € € € € € ðð ð ðð ñ „\ðð2 ð
Cð 
Cñ „\ð
Cð 
Cð 
Cr-   r$   c                   ó>   — e Zd ZdZed„ ¦   «         Zed„ ¦   «         ZdS )r”   z;
    Straight-through Estimator(STE) for torch.floor()
    c                 ó*   — t          j        |¦  «        S r~   )r   r‘   ©r  r7   s     r,   r?   zfloor_ste.forward©  ó   € åŒ{˜1‰~Œ~Ðr-   c                 ó*   — |                      ¦   «         S r~   ©r  ©r  r  s     r,   r	  zfloor_ste.backward­  ó   € à× Ò Ñ"Ô"Ð"r-   Nr
  r  r-   r,   r”   r”   ¤  óT   € € € € € ðð ð ðð ñ „\ðð ð#ð #ñ „\ð#ð #ð #r-   r”   c                   ó>   — e Zd ZdZed„ ¦   «         Zed„ ¦   «         ZdS )rÞ   z;
    Straight-through Estimator(STE) for torch.round()
    c                 ó*   — t          j        |¦  «        S r~   )r   ræ   r  s     r,   r?   zround_ste.forward·  r  r-   c                 ó*   — |                      ¦   «         S r~   r  r  s     r,   r	  zround_ste.backward»  r  r-   Nr
  r  r-   r,   rÞ   rÞ   ²  r  r-   rÞ   é   c                 óú  — |                       ¦   «         }|                      d¦  «        } t          j        |                      ¦   «                              ¦   «         ¦  «        \  }}g }|D ]o}t          t          j        |d|z  z  ¦  «         	                    t          j        d¦  «        t          j
        ¬¦  «        ¦  «        }|                     |¦  «         Œpt          j        |¦  «        }t          |¦  «        |z
  }t          j        |¦  «                             | j        ¦  «                             |¦  «        t          j        |¦  «                             | j        ¦  «                             |¦  «        fS )zü
    Decompose the scaling factor into mantissa and twos exponent.

    Args:
        scaling_factor (`torch.Tensor`):
            Target scaling factor to decompose.

    Returns:
        ``Tuple(torch.Tensor, torch.Tensor)`: mantisa and exponent
    rZ   r†   r   )Úrounding)Úsizer_   ÚnpÚfrexpÚcpuÚnumpyrÏ   ÚdecimalÚDecimalÚquantizeÚROUND_HALF_UPÚappendÚarrayrÛ   r   Ú
from_numpyrÜ   rÝ   )Úinputsr¨   Úshape_of_inputÚoutput_mÚoutput_eÚtmp_mÚmÚint_m_shifteds           r,   Úbatch_frexpr/  À  s<  € ð —[’[‘]”]€Nð �[Š[˜‰_Œ_€Fåœ &§*¢*¡,¤,×"4Ò"4Ñ"6Ô"6Ñ7Ô7Ñ€HˆhØ€EØð $ð $ˆÝÝŒO˜A  G¡Ñ,Ñ-Ô-×6Ò6µw´ÀqÑ7IÔ7IÕT[ÔTiÐ6ÑjÔjñ
ô 
ˆð 	�Š�]Ñ#Ô#Ð#Ð#ÝŒx˜‰Œ€Hå�W‰~Œ~ Ñ(€Hõ 	Ô˜Ñ"Ô"×%Ò% f¤mÑ4Ô4×9Ò9¸.ÑIÔIÝÔ˜Ñ"Ô"×%Ò% f¤mÑ4Ô4×9Ò9¸.ÑIÔIðð r-   c                   óD   — e Zd ZdZe	 	 dd„¦   «         Zed„ ¦   «         ZdS )r^   aQ  
    Function to perform fixed-point arithmetic that can match integer arithmetic on hardware.

    Args:
        pre_act (`torch.Tensor`):
            Input tensor.
        pre_act_scaling_factor (`torch.Tensor`):
            Scaling factor of the input tensor *pre_act*.
        bit_num (`int`):
            Quantization bitwidth.
        z_scaling_factor (`torch.Tensor`):
            Scaling factor of the output tensor.
        identity (`torch.Tensor`, *optional*):
            Identity tensor, if exists.
        identity_scaling_factor (`torch.Tensor`, *optional*):
            Scaling factor of the identity tensor *identity*, if exists.

    Returns:
        `torch.Tensor`: Output tensor(*pre_act* if *identity* is not given, otherwise the addition of *pre_act* and
        *identity*), whose scale is rescaled to *z_scaling_factor*.
    Nc                 ó,  — t          |j        ¦  «        dk    rd„ }nd„ }|| _        d|dz
  z  dz
  }t          j        ¦   «         5   ||¦  «        }|� ||¦  «        }|| _        t          j        ||z  ¦  «        }	|                     t          j        ¦  «        }
|                     t          j	        ¦  «                             t          j        ¦  «        }|
|z  } ||¦  «        }t          |¦  «        \  }}|	                     t          j        ¦  «        |                     t          j        ¦  «        z  }t          j        |d|z  z  ¦  «        }|�òt          j        ||z  ¦  «        }|                     t          j        ¦  «        }
|                     t          j	        ¦  «                             t          j        ¦  «        }|
|z  } ||¦  «        }t          |¦  «        \  }}|                     t          j        ¦  «        |                     t          j        ¦  «        z  }t          j        |d|z  z  ¦  «        }||z   }t          j        |                     t          j	        ¦  «        | dz
  |¦  «        cd d d ¦  «         S # 1 swxY w Y   d S )Nr   c                 ó   — | S r~   r  ©r7   s    r,   ú<lambda>z'FixedPointMul.forward.<locals>.<lambda>  s   €  € r-   c                 ó0   — |                       ddd¦  «        S )Nr   rZ   )r_   r3  s    r,   r4  z'FixedPointMul.forward.<locals>.<lambda>  s   €  §¢ q¨!¨RÑ 0Ô 0€ r-   r†   r   r	   )rõ   ry   ra   r   r­   Úz_scaling_factorræ   ÚtypeÚdoublerÛ   r/  r²   )r  Úpre_actr`   Úbit_numr6  ra   rb   Úreshaperá   Úz_intÚ_AÚ_BÚ	new_scaler-  ÚeÚoutputÚwx_intÚm1Úe1Úoutput1s                       r,   r?   zFixedPointMul.forwardù  sœ  € õ Ð%Ô+Ñ,Ô,°Ò1Ð1Ø!�kˆGˆGà0Ð0ˆGØˆŒà�'˜A‘+Ñ Ñ"ˆåŒ]‰_Œ_ð !	Dð !	DØ%, WÐ-CÑ%DÔ%DÐ"ØÐ#Ø*1¨'Ð2IÑ*JÔ*JÐ'à#3ˆCÔ å”K Ð*@Ñ @ÑAÔAˆEØ'×,Ò,­U¬\Ñ:Ô:ˆBØ"×'Ò'­¬Ñ4Ô4×:Ò:½5¼<ÑHÔHˆBØ˜R™ˆIØ˜ 	Ñ*Ô*ˆIå˜yÑ)Ô)‰DˆAˆqà—Z’Z¥¤Ñ-Ô-°·²µu´|Ñ0DÔ0DÑDˆFÝ”[ ¨3°©6Ñ!2Ñ3Ô3ˆFàÐ#åœ XÐ0GÑ%GÑHÔH�à,×1Ò1µ%´,Ñ?Ô?�Ø&×+Ò+­E¬KÑ8Ô8×>Ò>½u¼|ÑLÔL�Ø ™G�	Ø#˜G IÑ.Ô.�	å$ YÑ/Ô/‘��BØ Ÿ+š+¥e¤lÑ3Ô3°b·g²g½e¼lÑ6KÔ6KÑK�Ýœ+ g°°b±Ñ&9Ñ:Ô:�à  6Ñ)�å”;˜vŸ{š{­5¬;Ñ7Ô7¸!¸¸a¹ÀÑCÔCðC!	Dð !	Dð !	Dð !	Dñ !	Dô !	Dð !	Dð !	Dð !	Dð !	Dð !	Dð !	Døøøð !	Dð !	Dð !	Dð !	Dð !	Dð !	Ds   ÁH7J	Ê	JÊJc                 ó’   — d }| j         �|                     ¦   «         | j        z  }|                     ¦   «         | j        z  d d d d |d fS r~   )ra   r  r6  )r  r  Úidentity_grads      r,   r	  zFixedPointMul.backward.  sS   € àˆØŒ<Ð#Ø'×-Ò-Ñ/Ô/°#Ô2FÑFˆMØ× Ò Ñ"Ô" SÔ%9Ñ9¸4ÀÀtÈTÐS`ÐbfÐfÐfr-   r@   r
  r  r-   r,   r^   r^   â  sk   € € € € € ðð ð, ð Ø $ð2Dð 2Dð 2Dñ „\ð2Dðh ðgð gñ „\ðgð gð gr-   r^   )F)r  )r!  r   r  r   r   Útorch.autogradr   Úutilsr   Ú
get_loggerrA   r‡   ÚModuler   rH   rj   r€   r¡   rÁ   rò   rü   r6   r$   r”   rÞ   r/  r^   r  r-   r,   ú<module>rL     sØ  ðð" €€€à Ð Ð Ð Ø €€€Ø Ð Ð Ð Ð Ð Ø #Ð #Ð #Ð #Ð #Ð #à Ð Ð Ð Ð Ð ð 
ˆÔ	˜HÑ	%Ô	%€ðPPð PPð PPð PPð PP�R”Yñ PPô PPð PPðfgMð gMð gMð gMð gMˆrŒyñ gMô gMð gMðTM
ð M
ð M
ð M
ð M
�"”)ñ M
ô M
ð M
ð`66ð 66ð 66ð 66ð 66ˆbŒiñ 66ô 66ð 66ðrD8ð D8ð D8ð D8ð D8�”ñ D8ô D8ð D8ðNb!ð b!ð b!ð b!ð b!�2”9ñ b!ô b!ð b!ðJ!$ð !$ð !$ð !$ðH 9ð  9ð  9ð  9ðFð ð ð ð@*Cð *Cð *Cð *Cð *C˜Xñ *Cô *Cð *CðZ#ð #ð #ð #ð #�ñ #ô #ð #ð#ð #ð #ð #ð #�ñ #ô #ð #ðð ð ð ðDQgð Qgð Qgð Qgð Qg�Hñ Qgô Qgð Qgð Qgð Qgr-   