+
    QV-jC+  ã                   ó¼   € R t ^ RIt^ RIHt ^ RIHu Ht RR R lltR R ltR R lt	 ! R R	]P                  4      t ! R
 R]P                  4      tRR R lltR# )z‚Quantized layers for Gemma: INT2/4/8 packed-weight Linear and Embedding,
plus SRQ (Static Range Quantization) activation rounding.Nc                ó„   € V ^8„  d   QhR\         P                  R\         P                  R\        R\         P                  /# )é   ÚxÚscaleÚbitsÚreturn©ÚtorchÚTensorÚint)Úformats   "Úv/Volumes/fast/ai/experiments/ui-tars-smoke/.venv/lib/python3.14/site-packages/transformers/integrations/gemma_quant.pyÚ__annotate__r      s4   € ÷ +ñ +”—‘ð +¤e§l¡lð +¼#ð +ÄeÇlÁlñ +ó    c                óž  € VP                  V P                  4      p^V^,
          ,          ^,
          pV) ^,
          pV^ 8g  p\        P                  ! WQ\        P                  ! V4      4      p\        P
                  ! \        P                  ! W,          4      \        V4      \        V4      4      V,          p\        P                  ! WWV 4      # )aK  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`).
)ÚtoÚdtyper	   ÚwhereÚ	ones_likeÚclampÚroundÚfloat)r   r   r   Ú	max_valueÚ	min_valueÚ
calibratedÚ
safe_scaleÚx_qs   &&&     r   Ú	apply_srqr      s“   € ð �H‰H�Q—W‘WÓ€EØ�d˜Q•h• !Õ#€IØ�
˜Q•€IØ˜!‘€JÜ—’˜Z´·²ÀÓ0FÓG€JÜ
�+Š+”e—k’k !¥.Ó1´5¸Ó3CÄUÈ9ÓEUÓ
VÐYcÕ
c€CÜ�;Š;�z¨Ó*Ð*r   c                ód   € V ^8„  d   QhR\         P                  R\        R\         P                  /# ©r   ÚpackedÚoriginal_widthr   r   )r   s   "r   r   r   '   ó)   € ÷ -ñ -œŸ™ð -´sð -¼u¿|¹|ñ -r   c                ó€  € V P                  \        P                  4      p V ^,          P                  \        P                  4      ^,
          pV ^,	          P                  \        P                  4      ^,
          p\        P                  ! W#.RR7      P
                  ! . V P                  RR ORN5!  pVRRV13,          # )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_int4r0   '   s”   € ð �Y‰Y”u—{‘{Ó#€FØ�D�=×
Ñ
œUŸZ™ZÓ
(¨1Õ
,€CØ�a�K×ÑœEŸJ™JÓ'¨!Õ+€DÜ—+’+˜s˜k¨rÔ2×:Ò:ÐR¸F¿L¹LÈÈ"Ð<MÐRÈrÓR€KØ�s˜O˜^˜OÐ+Õ,Ð,r   c                ód   € V ^8„  d   QhR\         P                  R\        R\         P                  /# r   r   )r   s   "r   r   r   5   r"   r   c                óR  € V P                  \        P                  4      p V ^,          P                  \        P                  4      ^,
          pV ^,	          ^,          P                  \        P                  4      ^,
          pV ^,	          ^,          P                  \        P                  4      ^,
          pV ^,	          P                  \        P                  4      ^,
          p\        P                  ! W#WE.RR7      P
                  ! . V P                  RR ORN5!  pVRRV13,          # )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$   N.r&   r'   )r    r!   Úv0Úv1Úv2Úv3r/   s   &&     r   Ú_unpack_int2r7   5   sÜ   € ð
 �Y‰Y”u—{‘{Ó#€FØ
�4�-×	Ñ	œEŸJ™JÓ	'¨!Õ	+€BØ�Q�;˜$Õ
×	"Ñ	"¤5§:¡:Ó	.°Õ	2€BØ�Q�;˜$Õ
×	"Ñ	"¤5§:¡:Ó	.°Õ	2€BØ
�A�+×	Ñ	œ%Ÿ*™*Ó	%¨Õ	)€BÜ—+’+˜r rÐ.°BÔ7×?Ò?ÐWÀÇÁÈcÈrÐARÐWÐTVÓW€KØ�s˜O˜^˜OÐ+Õ,Ð,r   c                   ó€   a a€ ] tR t^Ct oRtRV3R lV 3R llltRV3R lR lltV3R lR ltV3R lR	 ltR
t	Vt
V ;t# )ÚQuantizedLinearzFLinear layer with INT2/4/8 packed weights and SRQ activation rounding.c                ó2   <€ V ^8„  d   QhRS[ RS[ RS[RS[ /# )r   Úin_featuresÚout_featuresÚbiasÚnum_bits)r   Úbool)r   Ú__classdict__s   "€r   r   ÚQuantizedLinear.__annotate__F   s9   ø€ ÷ \ñ \áð\ñ ð\ñ ð	\ñ
 ñ\r   c                ó0  <€ \         SV `  WVR 7       W@n        V^8X  d8   V^,           ^,          p\        P                  ! W%\        P
                  R7      pMdV^8X  d8   V^,           ^,          p\        P                  ! W%\        P
                  R7      pM&\        P                  ! W!\        P                  R7      p\        P                  ! VRR7      V n	        \        P                  ! \        P                  ! V^\        P                  R7      4      V n        \        P                  ! \        P                  ! R\        P                  R7      4      V n        \        P                  ! \        P                  ! R\        P                  R7      4      V n        R# ))r=   ©r   F©Úrequires_gradg        N)ÚsuperÚ__init__r>   r	   Úemptyr(   r)   ÚnnÚ	ParameterÚweightÚonesÚfloat32Úweight_scaleÚtensorÚinput_activation_scaleÚoutput_activation_scale)Úselfr;   r<   r=   r>   Ú	packed_inÚweight_storageÚ	__class__s   &&&&&  €r   rG   ÚQuantizedLinear.__init__F   sú   ø€ ô 	‰Ñ˜¸ÐÔ>Ø Œð �qŒ=Ø$ q�¨QÕ.ˆIÜ"Ÿ[š[¨ÌÏÉÔT‰NØ˜Œ]Ø$ q�¨QÕ.ˆIÜ"Ÿ[š[¨ÌÏÉÔ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   c                ó\   <€ V ^8„  d   QhRS[ P                  R,          RS[ P                  /# )r   r   Nr   )r	   r   r
   )r   r@   s   "€r   r   rA   a   s,   ø€ ÷ Cñ C©¯©°tÕ);ð CÁuÇ|Á|ñ Cr   c                óp  € V P                   ^8X  d"   \        V P                  V P                  4      pM>V P                   ^8X  d"   \	        V P                  V P                  4      pMV P                  pVf   W P
                  ,          # VP                  V4      V P
                  P                  V4      ,          # )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>   r7   rK   r;   r0   rN   r   )rR   r   Úint_weightss   && r   Ú_dequantize_weightsÚ#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   c                óN   <€ V ^8„  d   QhRS[ P                  RS[ P                  /# )r   r   r   ©r	   r
   )r   r@   s   "€r   r   rA   n   s#   ø€ ÷ <ñ <™Ÿ™ð <©%¯,©,ñ <r   c                óÊ   € \        WP                  4      p\        P                  ! WP	                  VP
                  4      V P                  4      p\        W P                  4      # ©N)r   rP   ÚFÚlinearrZ   r   r=   rQ   )rR   r   Úouts   && r   ÚforwardÚQuantizedLinear.forwardn   sF   € Ü�a×4Ñ4Ó5ˆÜ�hŠh�q×2Ñ2°1·7±7Ó;¸T¿Y¹YÓGˆÜ˜×:Ñ:Ó;Ð;r   c                ó    <€ V ^8„  d   QhRS[ /# ©r   r   ©Ústr)r   r@   s   "€r   r   rA   s   ó   ø€ ÷ 
ñ 
™Cñ 
r   c                ór   € R V P                    RV P                   RV P                  RJ RV P                   2# )zin_features=z, out_features=z, bias=Nú, num_bits=)r;   r<   r=   r>   ©rR   s   &r   Ú
extra_reprÚQuantizedLinear.extra_reprs   sG   € à˜4×+Ñ+Ð,¨O¸D×<MÑ<MÐ;Nð OØ—I‘I TÐ)Ð*¨+°d·m±m°_ðFð	
r   )rP   r>   rQ   rK   rN   )Fé   r_   )Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__rG   rZ   rc   rm   Ú__static_attributes__Ú__classdictcell__Ú__classcell__©rU   r@   s   @@r   r9   r9   C   s9   ù‡ € ÙP÷\õ \÷6Cò C÷<ð <÷

÷ 
ð 
r   r9   c                   ó˜   a a€ ] tR t^zt oRtRV3R lV 3R lllt]V3R lR l4       tV3R lR ltV3R lR	 lt	V3R
 lR lt
RtVtV ;t# )Ú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.
c          
      óL   <€ V ^8„  d   QhRS[ RS[ RS[P                  RS[RS[ /# )r   Únum_embeddingsÚembedding_dimÚoutput_dtypeÚembed_scaler>   )r   r	   r   r   )r   r@   s   "€r   r   ÚQuantizedEmbedding.__annotate__„   sH   ø€ ÷ `ñ `áð`ñ ð`ñ —k‘kð	`ñ
 ð`ñ ñ`r   c                ó^  <€ \         SV `  4        Wn        W n        W@n        WPn        W0n        V^8X  d8   V^,           ^,          p\        P                  ! W\        P                  R7      pMdV^8X  d8   V^,           ^,          p\        P                  ! W\        P                  R7      pM&\        P                  ! W\        P                  R7      p\        P                  ! VRR7      V n        \        P                  ! \        P                  ! V^\        P                  R7      4      V n        R# )r   rC   FrD   N)rF   rG   r|   r}   Úscalar_embed_scaler>   r~   r	   rH   r(   r)   rI   rJ   Úembedding_quantizedrL   rM   Úembedding_scale)	rR   r|   r}   r~   r   r>   Ú
packed_dimÚembed_storagerU   s	   &&&&&&  €r   rG   Ú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   c                ó4   <€ V ^8„  d   QhRS[ P                  /# rf   r]   )r   r@   s   "€r   r   r€       s   ø€ ÷ Xñ X™Ÿ™ñ Xr   c                óN   € V P                  V P                  V P                  4      # )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.
)rZ   rƒ   r„   rl   s   &r   rK   ÚQuantizedEmbedding.weightŸ   s#   € ð ×'Ñ'¨×(@Ñ(@À$×BVÑBVÓWÐWr   c                óh   <€ V ^8„  d   QhRS[ P                  RS[ P                  RS[ P                  /# )r   Ú
quant_rowsÚ
scale_rowsr   r]   )r   r@   s   "€r   r   r€   ¨   s6   ø€ ÷ Lñ L©e¯l©lð LÉÏÉð LÑY^×YeÑYeñ Lr   c                ó†  € V P                   ^8X  d   \        WP                  4      pM)V P                   ^8X  d   \        WP                  4      pMTpV P                  VP                  R,          ,          pVP                  VRR7      pVP                  V P                  4      VP                  V P                  4      ,          # )zFUnpack int2/int4/int8 + apply per-row block-wise dequantization scale.r$   r&   )r>   r0   r}   r7   r,   Úrepeat_interleaver   r~   )rR   rŒ   r�   Úint_rowsÚ
block_sizer   s   &&&   r   rZ   Ú&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   c                óN   <€ V ^8„  d   QhRS[ P                  RS[ P                  /# )r   Ú	input_idsr   )r	   Ú
LongTensorr
   )r   r@   s   "€r   r   r€   µ   s)   ø€ ÷ Hñ H¡×!1Ñ!1ð H±e·l±lñ Hr   c                óÀ   € V P                  V P                  V,          V P                  V,          4      pW P                  ,          P	                  V P
                  4      # r_   )rZ   rƒ   r„   r‚   r   r~   )rR   r”   Úresults   && r   rc   ÚQuantizedEmbedding.forwardµ   sK   € Ø×)Ñ)¨$×*BÑ*BÀ9Õ*MÈt×OcÑOcÐdmÕOnÓoˆØ×0Ñ0Õ0×4Ñ4°T×5FÑ5FÓGÐGr   c                ó    <€ V ^8„  d   QhRS[ /# rf   rg   )r   r@   s   "€r   r   r€   ¹   ri   r   c                ón   € R V P                    RV P                   RV P                   RV P                   2# )znum_embeddings=z, embedding_dim=rk   z, embed_scale=)r|   r}   r>   r‚   rl   s   &r   rm   Ú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‚   )ç      ð?ro   )rp   rq   rr   rs   rt   rG   ÚpropertyrK   rZ   rc   rm   ru   rv   rw   rx   s   @@r   rz   rz   z   sS   ù‡ € ñ÷`õ `ð6 ÷Xó ðX÷Lð L÷Hð H÷
÷ 
ð 
r   rz   c                ól   € V ^8„  d   QhR\         P                  R\        \        ,          R,          RR/# )r   ÚmodelÚmodules_to_not_convertNr   )rI   ÚModuleÚlistrh   )r   s   "r   r   r   À   s5   € ÷ 9ñ 9Ü�9‰9ð9ô !¤�I¨Õ,ð9ð 
ñ	9r   c                ó:  a€ ^ RI p^RIHp VP                  pVP                  pVP
                  ;'       g    / p\        VP                  4       4       UU	u/ uF  w  r‰RV 2V	bK  	  up	poV'       d1   VP                  RP                  R \        V4       4       4      4      MRp
\        V P                  4       4       EFR  w  r¼V! W²4      '       g   K  RV/pV
eM   V
P                  V4      ;pe8   \        V3R lVP                  4       P                  4        4       4      p	RV/V	Cp\!        V\"        P$                  4      '       dR   V'       g   K”  \'        RRVP(                  R	VP*                  R
\-        VRR4      RVP.                  P0                  /VB pMU\!        V\"        P2                  4      '       d3   \5        RRVP6                  RVP8                  RVP:                  RJ/VB pMEK0  VP=                  R4       V P?                  W¿4       EKU  	  V # u up	pi )aC  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.
N)Úshould_convert_moduleÚgÚ|c              3   ó8   "  € T F  w  rR V RV R2x € K  	  R# 5i)z(?P<gÚ>Ú)N© )Ú.0ÚiÚpatterns   &  r   Ú	<genexpr>Ú,replace_with_quant_layers.<locals>.<genexpr>Ø   s#   é € ÐeÑEd±z°q˜e A 3 a¨ y°Õ2ÓEdùs   ‚r>   c              3   óF   <"  € T F  w  rVf   K  SV,          x € K  	  R # 5ir_   rª   )r«   r¥   ÚvÚoverrides_by_groups   &  €r   r®   r¯   â   s$   øé € ÐiÑ>W±d°aÐ[\Ô1Ð.¨q×1Ò1Ó>Wùs   ƒ!�!r|   r}   r   r‚   rœ   r~   r;   r<   r=   Frª   ) ÚreÚquantizers.quantizers_utilsr¤   Úquantize_embeddingsr>   Úmodule_quant_configsÚ	enumerateÚvaluesÚcompileÚjoinr¢   Únamed_modulesÚsearchÚnextÚ	groupdictÚitemsÚ
isinstancerI   Ú	Embeddingrz   r|   r}   ÚgetattrrK   r   ÚLinearr9   r;   r<   r=   Ú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ÐIÀrÐô
 @IÐI]×IdÑIdÓIfÔ?gÔhÑ?g±°˜A˜a˜S˜' 8Ò+Ñ?gÒhÐ÷  ð 	�
‰
�3—8‘8ÑeÄYÐOcÔEdÓeÓeÔfàð ô ˜U×0Ñ0Ó2×3‰ˆÙ$ T×BÒ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 4ð8 €LùóG is   ÁH)ro   )NN)rt   r	   Útorch.nnrI   Útorch.nn.functionalÚ
functionalr`   r   r0   r7   rÃ   r9   r¡   rz   rÎ   rª   r   r   Ú<module>rÒ      sU   ðñ=ó Ý ß Ð ÷+õ -õ-ô4
�b—i‘iô 4
ônC
˜Ÿ™ô C
÷L9ñ 9r   