Ë
    ÛÓ^jC+  ã            	       óŠ  — 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y)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                 ój  — |j                  | j                  «      }d|dz
  z  dz
  }| dz
  }|dk7  }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           úp/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/transformers/integrations/gemma_quant.pyÚ	apply_srqr      s™   € ð �H‰H�Q—W‘WÓ€EØ�d˜Q‘h‘ !Ñ#€IØ�
˜Q‘€IØ˜!‘€JÜ—‘˜Z¨´·±ÀÓ0FÓG€JÜ
�+‰+”e—k‘k ! j¡.Ó1´5¸Ó3CÄUÈ9ÓEUÓ
VÐYcÑ
c€CÜ�;‰;�z 3¨Ó*Ð*ó    ÚpackedÚoriginal_widthc                 óV  — | j                  t        j                  «      } | dz  j                  t        j                  «      dz
  }| dz	  j                  t        j                  «      dz
  } t        j                  ||gd¬«      j
                  g | j                  dd ¢d‘­Ž }|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.
    é   é   é   éÿÿÿÿ©ÚdimN.©r
   r   Úuint8Úint8ÚstackÚreshapeÚshape)r   r   ÚlowÚhighÚinterleaveds        r   Ú_unpack_int4r,   '   s˜   € ð �Y‰Y”u—{‘{Ó#€FØ�D‰=×
Ñ
œUŸZ™ZÓ
(¨1Ñ
,€CØ�a‰K×ÑœEŸJ™JÓ'¨!Ñ+€DØ:”%—+‘+˜s D˜k¨rÔ2×:Ñ:ÐR¸F¿L¹LÈÈ"Ð<MÐRÈrÒR€KØ�s˜O˜^˜OÐ+Ñ,Ð,r   c                 óú  — | j                  t        j                  «      } | dz  j                  t        j                  «      dz
  }| dz	  dz  j                  t        j                  «      dz
  }| dz	  dz  j                  t        j                  «      dz
  }| dz	  j                  t        j                  «      dz
  } t        j                  ||||gd¬«      j
                  g | j                  dd ¢d‘­Ž }|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™JÓ	'¨!Ñ	+€BØ�Q‰;˜$Ñ
×	"Ñ	"¤5§:¡:Ó	.°Ñ	2€BØ�Q‰;˜$Ñ
×	"Ñ	"¤5§:¡:Ó	.°Ñ	2€BØ
�A‰+×	Ñ	œ%Ÿ*™*Ó	%¨Ñ	)€BØ?”%—+‘+˜r 2 r¨2Ð.°BÔ7×?Ñ?ÐWÀÇÁÈcÈrÐARÐWÐTVÒ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.Úin_featuresÚout_featuresÚbiasÚnum_bitsc                 óü  •— t         ‰| �  |||¬«       || _        |dk(  r/|dz   dz  }t        j                  ||t        j
                  ¬«      }nZ|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                  ¬«      «      | _        y )
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   s  ø€ ô 	‰Ñ˜ l¸ÐÔ>Ø ˆŒð �qŠ=Ø$ q™¨QÑ.ˆIÜ"Ÿ[™[¨°yÌÏÉÔT‰NØ˜Š]Ø$ q™¨QÑ.ˆIÜ"Ÿ[™[¨°yÌÏÉÔT‰Nä"Ÿ[™[¨°{Ì%Ï*É*ÔUˆNÜ—l‘l >ÀÔGˆŒÜŸL™L¬¯©°LÀ!Ì5Ï=É=Ô)YÓZˆÔô ')§l¡l´5·<±<ÀÌ5Ï=É=Ô3YÓ&ZˆÔ#Ü')§|¡|´E·L±LÀÌEÏMÉMÔ4ZÓ'[ˆÕ$r   Nr   r   c                 óV  — | j                   dk(  r!t        | j                  | j                  «      }n<| j                   dk(  r!t	        | j                  | j                  «      }n| j                  }|€|| j
                  z  S |j                  |«      | j
                  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Ñ4DÓE‰KØ�]‰]˜aÒÜ& t§{¡{°D×4DÑ4DÓE‰KàŸ+™+ˆKØˆ=Ø ×!2Ñ!2Ñ2Ð2Ø�~‰~˜eÓ$ t×'8Ñ'8×';Ñ';¸EÓ'BÑBÐBr   r   c                 óÎ   — t        || j                  «      }t        j                  || j	                  |j
                  «      | j                  «      }t        || j                  «      S ©N)r   rI   ÚFÚlinearrQ   r   r9   rJ   )rK   r   Úouts      r   ÚforwardzQuantizedLinear.forwardn   sL   € Ü�a˜×4Ñ4Ó5ˆÜ�h‰h�q˜$×2Ñ2°1·7±7Ó;¸T¿Y¹YÓGˆÜ˜˜d×:Ñ:Ó;Ð;r   c                 ór   — 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   sG   € à˜4×+Ñ+Ð,¨O¸D×<MÑ<MÐ;Nð OØ—I‘I TÐ)Ð*¨+°d·m±m°_ðFð	
r   )Fr   rS   )Ú__name__Ú
__module__Ú__qualname__Ú__doc__ÚintÚboolr@   r   r   ÚTensorrQ   rW   Ústrr[   Ú__classcell__©rN   s   @r   r6   r6   C   sˆ   ø„ ÙPð Øñ\àð\ð ð\ð ð	\ð
 õ\ñ6C¨¯©°tÑ);ð CÀuÇ|Á|ó 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.
    Únum_embeddingsÚembedding_dimÚoutput_dtypeÚembed_scaler:   c                 ó8  •— t         ‰| �  «        || _        || _        || _        || _        || _        |dk(  r/|dz   dz  }t        j                  ||t        j                  ¬«      }nZ|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                  ¬«      «      | _        y )Nr   r.   r   r<   r	   Fr=   )r?   r@   rh   ri   Úscalar_embed_scaler:   rj   r   rA   r$   r%   rB   rC   Úembedding_quantizedrE   rF   Úembedding_scale)	rK   rh   ri   rj   rk   r:   Ú
packed_dimÚembed_storagerN   s	           €r   r@   zQuantizedEmbedding.__init__„   sß   ø€ ô 	‰ÑÔØ,ˆÔØ*ˆÔØ"-ˆÔØ ˆŒØ(ˆÔð �qŠ=Ø'¨!Ñ+°Ñ1ˆJÜ!ŸK™K¨¸
Ì%Ï+É+ÔV‰MØ˜Š]Ø'¨!Ñ+°Ñ1ˆJÜ!ŸK™K¨¸
Ì%Ï+É+ÔV‰Mä!ŸK™K¨¸ÌUÏZÉZÔXˆMÜ#%§<¡<°ÈUÔ#SˆÔ Ü!Ÿ|™|¬E¯J©J°~ÀqÔPU×P]ÑP]Ô,^Ó_ˆÕr   r   c                 óN   — | j                  | 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   rn   ro   rZ   s    r   rD   zQuantizedEmbedding.weightŸ   s#   € ð ×'Ñ'¨×(@Ñ(@À$×BVÑBVÓWÐWr   Ú
quant_rowsÚ
scale_rowsc                 ój  — | j                   dk(  rt        || j                  «      }n(| j                   dk(  rt        || j                  «      }n|}| j                  |j                  d   z  }|j                  |d¬«      }|j                  | j                  «      |j                  | j                  «      z  S )zFUnpack int2/int4/int8 + apply per-row block-wise dequantization scale.r   r   r    r!   )r:   r,   ri   r4   r(   Úrepeat_interleaver
   rj   )rK   rs   rt   Úint_rowsÚ
block_sizer   s         r   rQ   z&QuantizedEmbedding._dequantize_weights¨   sœ   € à�=‰=˜AÒÜ# J°×0BÑ0BÓC‰HØ�]‰]˜aÒÜ# J°×0BÑ0BÓC‰Hà!ˆHà×'Ñ'¨:×+;Ñ+;¸BÑ+?Ñ?ˆ
Ø×,Ñ,¨Z¸RÐ,Ó@ˆØ�{‰{˜4×,Ñ,Ó-°·±¸×9JÑ9JÓ0KÑKÐKr   Ú	input_idsc                 óª   — | j                  | j                  |   | j                  |   «      }|| j                  z  j	                  | j
                  «      S rS   )rQ   rn   ro   rm   r
   rj   )rK   ry   Úresults      r   rW   zQuantizedEmbedding.forwardµ   sM   € Ø×)Ñ)¨$×*BÑ*BÀ9Ñ*MÈt×OcÑOcÐdmÑOnÓoˆØ˜×0Ñ0Ñ0×4Ñ4°T×5FÑ5FÓGÐGr   c                 ón   — d| j                   › d| j                  › d| j                  › d| j                  › �S )Nznum_embeddings=z, embedding_dim=rY   z, embed_scale=)rh   ri   r:   rm   rZ   s    r   r[   zQuantizedEmbedding.extra_repr¹   sE   € à˜d×1Ñ1Ð2Ð2BÀ4×CUÑCUÐBVð WØŸ™� n°T×5LÑ5LÐ4MðOð	
r   )ç      ð?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‘kð	`ð
 ð`ð õ`ð6 ðX˜Ÿ™ò Xó ðXðL¨e¯l©lð LÈÏÉð LÐY^×YeÑYeó LðH ×!1Ñ!1ð H°e·l±ló Hð
˜C÷ 
r   rg   ÚmodelÚmodules_to_not_convertc                 óØ  ‡— ddl }ddlm} |j                  }|j                  }|j
                  xs i }t        |j                  «       «      D ��	ci c]  \  }}	d|› �|	“Œ c}	}Š|r0|j                  dj                  d„ t        |«      D «       «      «      nd}
t        | j                  «       «      D �]/  \  }} |||«      sŒd|i}|
�I|
j                  |«      x}�6t        ˆfd	„|j                  «       j                  «       D «       «      }	d|i|	¥}t!        |t"        j$                  «      rG|sŒ}t'        d|j(                  |j*                  t-        |d
d«      |j.                  j0                  dœ|¤Ž}nLt!        |t"        j2                  «      r0t5        d|j6                  |j8                  |j:                  dudœ|¤Ž}n�Œ|j=                  d«       | j?                  ||«       �Œ2 | S c c}	}w )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_moduleÚgú|c              3   ó4   K  — | ]  \  }}d |› d|› d�–— Œ y­w)z(?P<gú>ú)N© )Ú.0ÚiÚpatterns      r   ú	<genexpr>z,replace_with_quant_layers.<locals>.<genexpr>Ø   s#   è ø€ Òe±z°q¸'˜e A 3 a¨ y°Ô2Ñeùs   ‚r:   c              3   ó4   •K  — | ]  \  }}|€Œ	‰|   –— Œ y ­wrS   r‰   )rŠ   r„   ÚvÚoverrides_by_groups      €r   r�   z,replace_with_quant_layers.<locals>.<genexpr>â   s!   øè ø€ Òi±d°a¸Ð[\Ñ[hÐ.¨qÕ1Ñiùs   ƒ
Ž
rm   r}   )rh   ri   rk   rj   )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   rh   ri   ÚgetattrrD   r   ÚLinearr6   r7   r8   r9   Úrequires_grad_Úset_submodule)r€   Úquantization_configr�   r‘   rƒ   r“   r:   r”   r‹   ÚoverrideÚmatcherÚnameÚmoduleÚoptsÚmatchÚ
new_moduler�   s                   @r   Úreplace_with_quant_layersr­   À   sê  ø€ ó åCà-×AÑAÐØ"×+Ñ+€HØ.×CÑCÒIÀrÐô
 @IÐI]×IdÑIdÓIfÓ?g×h±°°8˜A˜a˜S˜' 8Ñ+ÓhÐñ  ð 	�
‰
�3—8‘8ÑeÄYÐOcÓEdÔeÓeÔfàð ô ˜U×0Ñ0Ó2Ó3ó .‰ˆˆfÙ$ TÐ+AÔBØØ˜HÐ%ˆØÐ¨W¯^©^¸DÓ-AÐ$A EÐ#NÜÓi¸e¿o¹oÓ>O×>UÑ>UÓ>WÔiÓiˆHØ Ð5¨HÐ5ˆDÜ�fœbŸl™lÔ+Ù&ØÜ+ð Ø%×4Ñ4Ø$×2Ñ2Ü# FÐ,@À#ÓFØ#Ÿ]™]×0Ñ0ñ	ð
 ñ‰Jô ˜¤§	¡	Ô*Ü(ð Ø"×.Ñ.Ø#×0Ñ0Ø—[‘[¨Ð,ñð ñ	‰Jñ Ø×!Ñ! %Ô(Ø×Ñ˜D *Ö-ð7.ð8 €LùóG is   ÁG&)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¡lð +¸#ð +ÀeÇlÁló +ð -˜Ÿ™ð -°sð -¸u¿|¹|ó -ð-˜Ÿ™ð -°sð -¸u¿|¹|ó -ô4
�b—i‘iô 4
ônC
˜Ÿ™ô C
ðP Ø/3ñ9Ø�9‰9ð9ð ! ™I¨Ñ,ð9ð 
ô	9r   