§
    ‚ŠtjC+  ã            	       ó:  — d Z ddlZddlmZ ddlmc mZ ddej        dej        dedej        fd„Z	d	ej        d
edej        fd„Z
d	ej        d
edej        fd„Z G d„ dej        ¦  «        Z G d„ dej        ¦  «        Z	 	 ddej        dee         dz  ddfd„ZdS )z‚Quantized layers for Gemma: INT2/4/8 packed-weight Linear and Embedding,
plus SRQ (Static Range Quantization) activation rounding.é    Né   ÚxÚscaleÚbitsÚreturnc                 óp  — |                      | j        ¦  «        }d|dz
  z  dz
  }| dz
  }|dk    }t          j        ||t          j        |¦  «        ¦  «        }t          j        t          j        | |z  ¦  «        t          |¦  «        t          |¦  «        ¦  «        |z  }t          j        ||| ¦  «        S )a[  Apply Static Range Quantization rounding and clipping (in x's dtype).

    A `scale` of 0 means the layer is uncalibrated, in which case this is a no-op. The guard uses
    `torch.where` rather than `scale.item()` so it stays on-device and `torch.compile`-friendly (an
    `.item()` would force a host-device sync and break `fullgraph=True`).
    é   é   r   )ÚtoÚdtypeÚtorchÚwhereÚ	ones_likeÚclampÚroundÚfloat)r   r   r   Ú	max_valueÚ	min_valueÚ
calibratedÚ
safe_scaleÚx_qs           úc/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/transformers/integrations/gemma_quant.pyÚ	apply_srqr      s¥   € ð �HŠH�Q”WÑÔ€EØ�d˜Q‘h‘ !Ñ#€IØ�
˜Q‘€IØ˜!’€JÝ”˜Z¨µ´ÀÑ0FÔ0FÑGÔG€JÝ
Œ+•e”k ! j¡.Ñ1Ô1µ5¸Ñ3CÔ3CÅUÈ9ÑEUÔEUÑ
VÔ
VÐYcÑ
c€CÝŒ;�z 3¨Ñ*Ô*Ð*ó    ÚpackedÚoriginal_widthc                 óP  — |                       t          j        ¦  «        } | dz                        t          j        ¦  «        dz
  }| dz	                        t          j        ¦  «        dz
  } t          j        ||gd¬¦  «        j        g | j        dd…         ¢d‘R Ž }|dd|…f         S )a  Unpack int4 values from uint8 storage. Two values per byte.

    Each byte: low nibble = first value, high nibble = second value.
    Values are stored unsigned in [0, 15] and shifted to signed [-8, 7].
    Cast to uint8 first so the right shift is logical, not arithmetic.
    é   r   é   éÿÿÿÿ©ÚdimN.©r   r   Úuint8Úint8ÚstackÚreshapeÚshape)r   r   ÚlowÚhighÚinterleaveds        r   Ú_unpack_int4r,   '   s¢   € ð �YŠY•u”{Ñ#Ô#€FØ�D‰=×
Ò
�UœZÑ
(Ô
(¨1Ñ
,€CØ�a‰K×Ò�EœJÑ'Ô'¨!Ñ+€DØ:•%”+˜s D˜k¨rÐ2Ñ2Ô2Ô:ÐR¸F¼LÈÈ"ÈÔ<MÐRÈrÐRÐRÐR€KØ�s˜O˜^˜OÐ+Ô,Ð,r   c                 óô  — |                       t          j        ¦  «        } | dz                        t          j        ¦  «        dz
  }| dz	  dz                        t          j        ¦  «        dz
  }| dz	  dz                        t          j        ¦  «        dz
  }| dz	                        t          j        ¦  «        dz
  } t          j        ||||gd¬¦  «        j        g | j        dd…         ¢d‘R Ž }|dd|…f         S )	z•Unpack int2 values from uint8 storage. Four values per byte.

    Bits [1:0]/[3:2]/[5:4]/[7:6] hold values 0..3 each, shifted to signed [-2, 1].
    é   r	   r   é   r    r!   N.r#   )r   r   Úv0Úv1Úv2Úv3r+   s          r   Ú_unpack_int2r4   5   sî   € ð
 �YŠY•u”{Ñ#Ô#€FØ
�4‰-×	Ò	�EœJÑ	'Ô	'¨!Ñ	+€BØ�Q‰;˜$Ñ
×	"Ò	"¥5¤:Ñ	.Ô	.°Ñ	2€BØ�Q‰;˜$Ñ
×	"Ò	"¥5¤:Ñ	.Ô	.°Ñ	2€BØ
�A‰+×	Ò	�%œ*Ñ	%Ô	%¨Ñ	)€BØ?•%”+˜r 2 r¨2Ð.°BÐ7Ñ7Ô7Ô?ÐWÀÄÈcÈrÈcÔARÐWÐTVÐWÐWÐW€KØ�s˜O˜^˜OÐ+Ô,Ð,r   c            	       ó–   ‡ — e Zd ZdZ	 	 ddedededefˆ fd„Zdd
ej        d	z  dej	        fd„Z
dej	        dej	        fd„Zdefd„Zˆ xZS )ÚQuantizedLinearzFLinear layer with INT2/4/8 packed weights and SRQ activation rounding.Fr   Úin_featuresÚout_featuresÚbiasÚnum_bitsc                 óâ  •— t          ¦   «                              |||¬¦  «         || _        |dk    r*|dz   dz  }t          j        ||t          j        ¬¦  «        }nQ|dk    r*|dz   dz  }t          j        ||t          j        ¬¦  «        }n!t          j        ||t          j        ¬¦  «        }t          j        |d¬¦  «        | _	        t          j        t          j
        |dt          j        ¬¦  «        ¦  «        | _        t          j        t          j        d	t          j        ¬¦  «        ¦  «        | _        t          j        t          j        d	t          j        ¬¦  «        ¦  «        | _        d S )
N)r9   r	   r.   r   ©r   r
   F©Úrequires_gradg        )ÚsuperÚ__init__r:   r   Úemptyr$   r%   ÚnnÚ	ParameterÚweightÚonesÚfloat32Úweight_scaleÚtensorÚinput_activation_scaleÚoutput_activation_scale)Úselfr7   r8   r9   r:   Ú	packed_inÚweight_storageÚ	__class__s          €r   r@   zQuantizedLinear.__init__F   s0  ø€ õ 	‰Œ×Ò˜ l¸ÐÑ>Ô>Ð>Ø ˆŒð �qŠ=ˆ=Ø$ q™¨QÑ.ˆIÝ"œ[¨°yÍÌÐTÑTÔTˆNˆNØ˜Š]ˆ]Ø$ q™¨QÑ.ˆIÝ"œ[¨°yÍÌÐTÑTÔTˆNˆNå"œ[¨°{Í%Ì*ÐUÑUÔUˆNÝ”l >ÀÐGÑGÔGˆŒÝœL­¬°LÀ!Í5Ì=Ð)YÑ)YÔ)YÑZÔZˆÔõ ')¤lµ5´<ÀÍ5Ì=Ð3YÑ3YÔ3YÑ&ZÔ&ZˆÔ#Ý')¤|µE´LÀÍEÌMÐ4ZÑ4ZÔ4ZÑ'[Ô'[ˆÔ$Ð$Ð$r   Nr   r   c                 ó   — | j         dk    rt          | j        | j        ¦  «        }n-| j         dk    rt	          | j        | j        ¦  «        }n| j        }|€
|| j        z  S |                     |¦  «        | j                             |¦  «        z  S )u˜   Dequantize weights (handles int2/int4/int8 storage). If `dtype` is given,
        the math runs in that dtype; otherwise intÃ—fp32 promotion gives fp32.r	   r   )r:   r4   rD   r7   r,   rG   r   )rK   r   Úint_weightss      r   Ú_dequantize_weightsz#QuantizedLinear._dequantize_weightsa   sŒ   € ð Œ=˜AÒÐÝ& t¤{°DÔ4DÑEÔEˆKˆKØŒ]˜aÒÐÝ& t¤{°DÔ4DÑEÔEˆKˆKàœ+ˆKØˆ=Ø Ô!2Ñ2Ð2Ø�~Š~˜eÑ$Ô$ tÔ'8×';Ò';¸EÑ'BÔ'BÑBÐBr   r   c                 ó¼   — t          || j        ¦  «        }t          j        ||                      |j        ¦  «        | j        ¦  «        }t          || j        ¦  «        S ©N)r   rI   ÚFÚlinearrQ   r   r9   rJ   )rK   r   Úouts      r   ÚforwardzQuantizedLinear.forwardn   sL   € Ý�a˜Ô4Ñ5Ô5ˆÝŒh�q˜$×2Ò2°1´7Ñ;Ô;¸T¼YÑGÔGˆÝ˜˜dÔ:Ñ;Ô;Ð;r   c                 óJ   — d| j         › d| j        › d| j        d u› d| j        › �S )Nzin_features=z, out_features=z, bias=ú, num_bits=)r7   r8   r9   r:   ©rK   s    r   Ú
extra_reprzQuantizedLinear.extra_reprs   sV   € ðF˜4Ô+ð Fð F¸DÔ<Mð Fð FØ”I TÐ)ðFð FØ6:´mðFð Fð	
r   )Fr   rS   )Ú__name__Ú
__module__Ú__qualname__Ú__doc__ÚintÚboolr@   r   r   ÚTensorrQ   rW   Ústrr[   Ú__classcell__©rN   s   @r   r6   r6   C   sù   ø€ € € € € ØPÐPð Øð\ð \àð\ð ð\ð ð	\ð
 ð\ð \ð \ð \ð \ð \ð6Cð C¨¬°tÑ);ð CÀuÄ|ð Cð Cð Cð Cð<˜œð <¨%¬,ð <ð <ð <ð <ð

˜Cð 
ð 
ð 
ð 
ð 
ð 
ð 
ð 
r   r6   c                   óÐ   ‡ — e Zd ZdZ	 	 ddededej        dedef
ˆ fd	„Ze	d
ej
        fd„¦   «         Zdej
        dej
        d
ej
        fd„Zdej        d
ej
        fd„Zd
efd„Zˆ xZS )ÚQuantizedEmbeddingaæ  Embedding with INT2/4/8 packed table, per-row dequant scale, and architectural embed_scale.

    Does NOT subclass `nn.Embedding` because the packed-int storage isn't a usable
    embedding table on its own: indexing `.embedding_quantized[idx]` returns packed
    bytes, not a row of size `embedding_dim`. Callers expect `embed_tokens.weight[idx, :]`
    to return the *dequantized* row, so we expose `weight` as a property (below)
    that returns the dequantized table on demand.
    ç      ð?r   Únum_embeddingsÚembedding_dimÚoutput_dtypeÚembed_scaler:   c                 ó6  •— t          ¦   «                              ¦   «          || _        || _        || _        || _        || _        |dk    r*|dz   dz  }t          j        ||t          j	        ¬¦  «        }nQ|dk    r*|dz   dz  }t          j        ||t          j	        ¬¦  «        }n!t          j        ||t          j
        ¬¦  «        }t          j        |d¬¦  «        | _        t          j        t          j        |dt          j        ¬¦  «        ¦  «        | _        d S )Nr	   r.   r   r<   r
   Fr=   )r?   r@   ri   rj   Úscalar_embed_scaler:   rk   r   rA   r$   r%   rB   rC   Úembedding_quantizedrE   rF   Úembedding_scale)	rK   ri   rj   rk   rl   r:   Ú
packed_dimÚembed_storagerN   s	           €r   r@   zQuantizedEmbedding.__init__„   s  ø€ õ 	‰Œ×ÒÑÔÐØ,ˆÔØ*ˆÔØ"-ˆÔØ ˆŒØ(ˆÔð �qŠ=ˆ=Ø'¨!Ñ+°Ñ1ˆJÝ!œK¨¸
Í%Ì+ÐVÑVÔVˆMˆMØ˜Š]ˆ]Ø'¨!Ñ+°Ñ1ˆJÝ!œK¨¸
Í%Ì+ÐVÑVÔVˆMˆMå!œK¨¸ÍUÌZÐXÑXÔXˆMÝ#%¤<°ÈUÐ#SÑ#SÔ#SˆÔ Ý!œ|­E¬J°~ÀqÕPUÔP]Ð,^Ñ,^Ô,^Ñ_Ô_ˆÔÐÐr   r   c                 óB   — |                       | j        | j        ¦  «        S )zéDequantized embedding table (no architectural `embed_scale` applied).

        Mirrors `nn.Embedding.weight` so callers can do `weight[idx, :]` and get
        the same unscaled row they'd get from a non-quantized embedding.
        )rQ   ro   rp   rZ   s    r   rD   zQuantizedEmbedding.weightŸ   s    € ð ×'Ò'¨Ô(@À$ÔBVÑWÔWÐWr   Ú
quant_rowsÚ
scale_rowsc                 óL  — | j         dk    rt          || j        ¦  «        }n#| j         dk    rt          || j        ¦  «        }n|}| j        |j        d         z  }|                     |d¬¦  «        }|                     | j        ¦  «        |                     | j        ¦  «        z  S )zFUnpack int2/int4/int8 + apply per-row block-wise dequantization scale.r   r	   r    r!   )r:   r,   rj   r4   r(   Úrepeat_interleaver   rk   )rK   rt   ru   Úint_rowsÚ
block_sizer   s         r   rQ   z&QuantizedEmbedding._dequantize_weights¨   sŸ   € àŒ=˜AÒÐÝ# J°Ô0BÑCÔCˆHˆHØŒ]˜aÒÐÝ# J°Ô0BÑCÔCˆHˆHà!ˆHàÔ'¨:Ô+;¸BÔ+?Ñ?ˆ
Ø×,Ò,¨Z¸RÐ,Ñ@Ô@ˆØ�{Š{˜4Ô,Ñ-Ô-°·²¸Ô9JÑ0KÔ0KÑKÐKr   Ú	input_idsc                 óž   — |                       | j        |         | j        |         ¦  «        }|| j        z                       | j        ¦  «        S rS   )rQ   ro   rp   rn   r   rk   )rK   rz   Úresults      r   rW   zQuantizedEmbedding.forwardµ   sG   € Ø×)Ò)¨$Ô*BÀ9Ô*MÈtÔOcÐdmÔOnÑoÔoˆØ˜Ô0Ñ0×4Ò4°TÔ5FÑGÔGÐGr   c                 óF   — d| j         › d| j        › d| j        › d| j        › �S )Nznum_embeddings=z, embedding_dim=rY   z, embed_scale=)ri   rj   r:   rn   rZ   s    r   r[   zQuantizedEmbedding.extra_repr¹   sR   € ðO˜dÔ1ð Oð OÀ4ÔCUð Oð OØœðOð OØ59Ô5LðOð Oð	
r   )rh   r   )r\   r]   r^   r_   r`   r   r   r   r@   Úpropertyrb   rD   rQ   Ú
LongTensorrW   rc   r[   rd   re   s   @r   rg   rg   z   s@  ø€ € € € € ðð ð !Øð`ð `àð`ð ð`ð ”kð	`ð
 ð`ð ð`ð `ð `ð `ð `ð `ð6 ðX˜œð Xð Xð Xñ „XðXðL¨e¬lð LÈÌð LÐY^ÔYeð Lð Lð Lð LðH Ô!1ð H°e´lð Hð Hð Hð Hð
˜Cð 
ð 
ð 
ð 
ð 
ð 
ð 
ð 
r   rg   ÚmodelÚmodules_to_not_convertc                 óÌ  ‡— ddl }ddlm} |j        }|j        }|j        pi }d„ t          |                     ¦   «         ¦  «        D ¦   «         Š|r?|                     d 	                    d„ t          |¦  «        D ¦   «         ¦  «        ¦  «        nd}t          |                      ¦   «         ¦  «        D �]0\  }	}
 ||	|¦  «        sŒd|i}|�\|                     |	¦  «        x}�Et          ˆfd	„|                     ¦   «                              ¦   «         D ¦   «         ¦  «        }d|i|¥}t!          |
t"          j        ¦  «        r8|sŒ’t'          d|
j        |
j        t-          |
d
d¦  «        |
j        j        dœ|¤Ž}n>t!          |
t"          j        ¦  «        r"t5          d|
j        |
j        |
j        dudœ|¤Ž}n�Œ|                     d¦  «         |                      |	|¦  «         �Œ2| S )aS  Replace `nn.Linear` / `nn.Embedding` modules with `QuantizedLinear` / `QuantizedEmbedding`.

    Per-module bit widths come from `quantization_config.module_quant_configs`.
    `nn.Embedding` modules are only replaced when `quantize_embeddings` is True.
    Modules whose name matches an entry in `modules_to_not_convert` are skipped.
    r   Nr	   )Úshould_convert_modulec                 ó    — i | ]\  }}d |› �|“ŒS )Úg© )Ú.0ÚiÚoverrides      r   ú
<dictcomp>z-replace_with_quant_layers.<locals>.<dictcomp>Ö   s$   € ÐhÐhÐh±°°8˜'˜a˜'˜' 8ÐhÐhÐhr   ú|c              3   ó.   K  — | ]\  }}d |› d|› d�V — ŒdS )z(?P<gú>ú)Nr†   )r‡   rˆ   Úpatterns      r   ú	<genexpr>z,replace_with_quant_layers.<locals>.<genexpr>Ø   s:   è è € ÐeÐe±z°q¸'Ð2 AÐ2Ð2¨Ð2Ð2Ð2ÐeÐeÐeÐeÐeÐer   r:   c              3   ó2   •K  — | ]\  }}|®‰|         V — Œd S rS   r†   )r‡   r…   ÚvÚoverrides_by_groups      €r   r�   z,replace_with_quant_layers.<locals>.<genexpr>â   s3   øè è € ÐiÐi±d°a¸Ð[\Ð[hÐ.¨qÔ1Ð[hÐ[hÐ[hÐ[hÐiÐir   rn   rh   )ri   rj   rl   rk   )r7   r8   r9   Fr†   ) ÚreÚquantizers.quantizers_utilsrƒ   Úquantize_embeddingsr:   Úmodule_quant_configsÚ	enumerateÚvaluesÚcompileÚjoinÚlistÚnamed_modulesÚsearchÚnextÚ	groupdictÚitemsÚ
isinstancerB   Ú	Embeddingrg   ri   rj   ÚgetattrrD   r   ÚLinearr6   r7   r8   r9   Úrequires_grad_Úset_submodule)r€   Úquantization_configr�   r”   rƒ   r–   r:   r—   ÚmatcherÚnameÚmoduleÚoptsÚmatchr‰   Ú
new_moduler“   s                  @r   Úreplace_with_quant_layersr¯   À   sQ  ø€ ð €I€I€IàCÐCÐCÐCÐCÐCà-ÔAÐØ"Ô+€HØ.ÔCÐIÀrÐð
 iÐh½yÐI]×IdÒIdÑIfÔIfÑ?gÔ?gÐhÑhÔhÐð  ð	ˆ�
Š
�3—8’8ÐeÐeÅYÐOcÑEdÔEdÐeÑeÔeÑeÔeÑfÔfÐfàð õ ˜U×0Ò0Ñ2Ô2Ñ3Ô3ð .ñ .‰ˆˆfØ$Ð$ TÐ+AÑBÔBð 	ØØ˜HÐ%ˆØÐ¨W¯^ª^¸DÑ-AÔ-AÐ$A EÐ#NÝÐiÐiÐiÐi¸e¿oºoÑ>OÔ>O×>UÒ>UÑ>WÔ>WÐiÑiÔiÑiÔiˆHØ Ð5¨HÐ5ˆDÝ�f�bœlÑ+Ô+ð 	Ø&ð ØÝ+ð Ø%Ô4Ø$Ô2Ý# FÐ,@À#ÑFÔFØ#œ]Ô0ð	ð ð
 ðð ˆJˆJõ ˜¥¤	Ñ*Ô*ð 	Ý(ð Ø"Ô.Ø#Ô0Ø”[¨Ð,ðð ð ð	ð ˆJˆJñ Ø×!Ò! %Ñ(Ô(Ð(Ø×Ò˜D *Ñ-Ô-Ð-Ñ-Ø€Lr   )r   )NN)r_   r   Útorch.nnrB   Útorch.nn.functionalÚ
functionalrT   rb   r`   r   r,   r4   r¥   r6   ÚModulerg   rœ   rc   r¯   r†   r   r   ú<module>r´      s�  ðð=ð =ð €€€Ø Ð Ð Ð Ð Ð Ø Ð Ð Ð Ð Ð Ð Ð Ð ð+ð +�”ð + e¤lð +¸#ð +ÀeÄlð +ð +ð +ð +ð -˜œð -°sð -¸u¼|ð -ð -ð -ð -ð-˜œð -°sð -¸u¼|ð -ð -ð -ð -ð4
ð 4
ð 4
ð 4
ð 4
�b”iñ 4
ô 4
ð 4
ðnC
ð C
ð C
ð C
ð C
˜œñ C
ô C
ð C
ðP Ø/3ð9ð 9ØŒ9ð9ð ! œI¨Ñ,ð9ð 
ð	9ð 9ð 9ð 9ð 9ð 9r   