Ë
    ÛÓ^j"ë ã                   óf
  — d dl Z d dlmZ d dlmZ d dlmZ d dlmZ d dl	m
Z
 d dlZd dlmZ d dlmZ d	d
lmZ d	dlmZ d	dlmZ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!m"Z"m#Z#m$Z$m%Z%m&Z& d	dl'm(Z( d	dl)m*Z* d	dl+m,Z,m-Z- d	dl.m/Z/m0Z0 d	dl1m2Z2m3Z3 d	dl4m5Z5 d	dl6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z< d	dl=m>Z>m?Z? d	dl@mAZAmBZB ddlCmDZD ddlEmFZFmGZGmHZHmIZI  e;«       rd dlJmKZK  e9d¬ «      e G d!„ d"e,«      «       «       ZL e9d#¬ «      e G d$„ d%e7«      «       «       ZMe G d&„ d'e,«      «       ZNe9e G d(„ d)e-«      «       «       ZO G d*„ d+ej                   «      ZQ G d,„ d-ej                   «      ZR G d.„ d/ej                   «      ZS G d0„ d1ej                   «      ZT G d2„ d3ej                   «      ZU G d4„ d5ej                   «      ZV G d6„ d7ej                   «      ZW G d8„ d9ej°                  «      ZY G d:„ d;ej                   «      ZZ G d<„ d=ej                   «      Z[ G d>„ d?ej                   «      Z\ G d@„ dAej                   «      Z] G dB„ dCej                   «      Z^ G dD„ dEej                   «      Z_dF„ Z`dŽdGejÂ                  dHejÂ                  dIejÂ                  dJebfdK„ZcdLejÂ                  dMebdNejÂ                  fdO„Zd	 	 	 d�dPej                   dQejÂ                  dRejÂ                  dSejÂ                  dTejÂ                  dz  dUeeebz  dVeedz  dWeedz  dNefejÂ                  ejÂ                  f   fdX„Zg	 d�dGejÂ                  dHejÂ                  dIejÂ                  dYejÂ                  dJebdNejÂ                  fdZ„Zh G d[„ d\ej                   «      Zi G d]„ d^e*«      Zj G d_„ d`ej                   «      Zk G da„ dbej                   «      Zl G dc„ ddej                   «      Zm G de„ dfej                   «      Zne G dg„ dhej                   «      «       Zo G di„ djej                   «      Zp G dk„ dle*«      Zq G dm„ dnejä                  «      Zse9 G do„ dpe3«      «       Zt e9dq¬ «       G dr„ dset«      «       Zu e9dt¬ «       G du„ dvete«      «       Zvdwefebebf   dNefdx„Zw G dy„ dzet«      Zx G d{„ d|et«      Zy G d}„ d~ej                   «      Zzded€ejÂ                  dTejÂ                  dz  d�edz  dYejÂ                  dz  d‚ejÂ                  dNe{fdƒ„Z|d„ejÂ                  d…ejú                  dNejÂ                  fd†„Z~ e9d‡¬ «       G dˆ„ d‰et«      «       Z e9dŠ¬ «       G d‹„ dŒete«      «       Z€g d�¢Z�y)‘é    N)ÚUserDict)ÚCallable)Ú	dataclass)Úcached_property)ÚOptional)Únn)Ú
functionalé   )Úinitialization)ÚACT2FN)ÚCacheÚDynamicCache)ÚPreTrainedConfig)ÚGenerationMixin)Úuse_experts_implementation)Ú_preprocess_mask_argumentsÚblockwise_overlayÚcreate_bidirectional_maskÚcreate_causal_maskÚcreate_masks_for_generateÚ!create_sliding_window_causal_maskÚmaybe_pad_block_sequence_idsÚsliding_window_overlay)ÚFlashAttentionKwargs)ÚGradientCheckpointingLayer)ÚBaseModelOutputWithPastÚBaseModelOutputWithPooling)ÚROPE_INIT_FUNCTIONSÚdynamic_rope_update)ÚALL_ATTENTION_FUNCTIONSÚPreTrainedModel)ÚUnpack)ÚModelOutputÚTransformersKwargsÚauto_docstringÚcan_return_tupleÚis_accelerate_availableÚtorch_compilable_check)Úmaybe_autocastÚmerge_with_config_defaults)ÚOutputRecorderÚcapture_outputsé   )Ú	AutoModelé   )ÚGemma4AudioConfigÚGemma4ConfigÚGemma4TextConfigÚGemma4VisionConfig)Úadd_hook_to_modulezK
    Base class for Gemma4 outputs, with hidden states and attentions.
    ©Úcustom_introc                   ó²   — e Zd ZU dZdZej                  dz  ed<   dZej                  dz  ed<   dZ	e
eeej                  ej                  f   f   dz  ed<   y)ÚGemma4ModelOutputWithPasta¯  
    past_key_values (`Cache`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`):
        It is a [`~cache_utils.Cache`] instance. For more details, see our [kv cache guide](https://huggingface.co/docs/transformers/en/kv_cache).

        Contains pre-computed hidden-states (key and values in the self-attention blocks) that can be used (see
        `past_key_values` input) to speed up sequential decoding.
    image_hidden_states (`torch.FloatTensor`, *optional*):
        A `torch.FloatTensor` of size `(batch_size, num_images, sequence_length, hidden_size)`.
        image_hidden_states of the model produced by the vision encoder and after projecting the last hidden state.
    audio_hidden_states (`torch.FloatTensor`, *optional*):
        A `torch.FloatTensor` of size `(batch_size, num_images, sequence_length, hidden_size)`.
        audio_hidden_states of the model produced by the audio encoder and after projecting the last hidden state.
    shared_kv_states (`dict`, *optional*):
        Dictionary mapping layer type strings to tuples of (key_states, value_states) tensors.
        Used to pass shared KV states between layers during KV sharing.
    NÚimage_hidden_statesÚaudio_hidden_statesÚshared_kv_states)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r9   ÚtorchÚFloatTensorÚ__annotations__r:   r;   ÚdictÚstrÚtupleÚTensor© ó    úu/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/transformers/models/gemma4/modeling_gemma4.pyr8   r8   H   sa   … ñð" 59Ð˜×*Ñ*¨TÑ1Ó8à48Ð˜×*Ñ*¨TÑ1Ó8àLPÐ�d˜3  e§l¡l°E·L±LÐ&@Ñ AÐAÑBÀTÑIÔPrH   r8   zR
    Base class for Gemma4 causal language model (or autoregressive) outputs.
    c                   ór  — e Zd ZU dZdZej                  dz  ed<   dZej                  dz  ed<   dZ	e
dz  ed<   dZeej                     dz  ed<   dZeej                     dz  ed<   dZej                  dz  ed<   dZej                  dz  ed	<   dZeeeej&                  ej&                  f   f   dz  ed
<   y)ÚGemma4CausalLMOutputWithPasta  
    loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `labels` is provided):
        Language modeling loss (for next-token prediction).
    logits (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.text_config.vocab_size)`):
        Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).
    past_key_values (`Cache`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`):
        It is a [`~cache_utils.Cache`] instance. For more details, see our [kv cache guide](https://huggingface.co/docs/transformers/en/kv_cache).

        Contains pre-computed hidden-states (key and values in the self-attention blocks) that can be used (see
        `past_key_values` input) to speed up sequential decoding.
    image_hidden_states (`torch.FloatTensor`, *optional*):
        A `torch.FloatTensor` of size `(batch_size, num_images, sequence_length, hidden_size)`.
        image_hidden_states of the model produced by the vision encoder after projecting last hidden state.
    audio_hidden_states (`torch.FloatTensor`, *optional*):
        A `torch.FloatTensor` of size `(batch_size, num_images, sequence_length, hidden_size)`.
        audio_hidden_states of the model produced by the audio encoder and after projecting the last hidden state.
    shared_kv_states (`dict`, *optional*):
        Dictionary mapping layer type strings to tuples of (key_states, value_states) tensors.
        Used to pass shared KV states between layers during KV sharing.
    NÚlossÚlogitsÚpast_key_valuesÚhidden_statesÚ
attentionsr9   r:   r;   )r<   r=   r>   r?   rL   r@   rA   rB   rM   rN   r   rO   rE   rP   r9   r:   r;   rC   rD   rF   rG   rH   rI   rK   rK   g   sÍ   … ñð* &*€Dˆ%×
Ñ
˜dÑ
"Ó)Ø'+€FˆE×Ñ Ñ$Ó+Ø$(€O�U˜T‘\Ó(Ø59€M�5˜×*Ñ*Ñ+¨dÑ2Ó9Ø26€J��e×'Ñ'Ñ(¨4Ñ/Ó6Ø48Ð˜×*Ñ*¨TÑ1Ó8à48Ð˜×*Ñ*¨TÑ1Ó8àLPÐ�d˜3  e§l¡l°E·L±LÐ&@Ñ AÐAÑBÀTÑIÔPrH   rK   c                   ób   — e Zd ZU dZdZeeeej                  ej                  f   f   dz  e
d<   y)ÚGemma4TextModelOutputWithPasta9  
    BaseModelOutputWithPast extended with shared_kv_states for KV sharing.

    Args:
        shared_kv_states (`dict`, *optional*):
            Dictionary mapping layer type strings to tuples of (key_states, value_states) tensors.
            Used to pass shared KV states between layers during KV sharing.
    Nr;   )r<   r=   r>   r?   r;   rC   rD   rE   r@   rF   rB   rG   rH   rI   rR   rR   �   s7   … ñð MQÐ�d˜3  e§l¡l°E·L±LÐ&@Ñ AÐAÑBÀTÑIÔPrH   rR   c                   ó:   — e Zd ZU dZdZej                  dz  ed<   y)ÚGemma4AudioModelOutputz§
    attention_mask (`torch.BoolTensor`, *optional*):
        A torch.BoolTensor of shape `(batch_size, num_frames)`. True for valid positions, False for padding.
    NÚattention_mask)r<   r=   r>   r?   rU   r@   Ú
BoolTensorrB   rG   rH   rI   rT   rT   �   s   … ñð
 /3€N�E×$Ñ$ tÑ+Ô2rH   rT   c                   ón   ‡ — e Zd Zdeez  dededdfˆ fd„Zdej                  dej                  fd„Z	ˆ xZ
S )	ÚGemma4ClippableLinearÚconfigÚin_featuresÚout_featuresÚreturnNc                 ó  •— t         ‰| �  «        |j                  | _        t        j                  ||d¬«      | _        | j                  r»| j                  dt        j                  t        d«       «      «       | j                  dt        j                  t        d«      «      «       | j                  dt        j                  t        d«       «      «       | j                  dt        j                  t        d«      «      «       y y )NF©ÚbiasÚ	input_minÚinfÚ	input_maxÚ
output_minÚ
output_max)
ÚsuperÚ__init__Úuse_clipped_linearsr   ÚLinearÚlinearÚregister_bufferr@   ÚtensorÚfloat)ÚselfrY   rZ   r[   Ú	__class__s       €rI   rf   zGemma4ClippableLinear.__init__©   s¸   ø€ ô 	‰ÑÔØ#)×#=Ñ#=ˆÔ Ü—i‘i ¨\ÀÔFˆŒà×#Ò#Ø× Ñ  ¬e¯l©l¼EÀ%»L¸=Ó.IÔJØ× Ñ  ¬e¯l©l¼5À»<Ó.HÔIØ× Ñ  ¬u¯|©|¼UÀ5»\¸MÓ/JÔKØ× Ñ  ¬u¯|©|¼EÀ%»LÓ/IÕJð	 $rH   rO   c                 ó  — | j                   r+t        j                  || j                  | j                  «      }| j                  |«      }| j                   r+t        j                  || j                  | j                  «      }|S ©N)rg   r@   Úclampr`   rb   ri   rc   rd   )rm   rO   s     rI   ÚforwardzGemma4ClippableLinear.forward¹   s\   € Ø×#Ò#Ü!ŸK™K¨°t·~±~ÀtÇ~Á~ÓVˆMàŸ™ MÓ2ˆà×#Ò#Ü!ŸK™K¨°t·±ÈÏÉÓXˆMàÐrH   )r<   r=   r>   r3   r0   Úintrf   r@   rF   rr   Ú__classcell__©rn   s   @rI   rX   rX   ¨   sT   ø„ ðKà"Ð%6Ñ6ðKð ðKð ð	Kð
 
õKð 	 U§\¡\ð 	°e·l±l÷ 	rH   rX   c                   ó†   ‡ — e Zd Zd	dededefˆ fd„Zdej                  fd„Z	dej                  dej                  fd„Z
ˆ xZS )
ÚGemma4RMSNormÚdimÚepsÚ
with_scalec                 ó¶   •— t         ‰| �  «        || _        || _        | j                  r0t	        j
                  t        j                  |«      d¬«      | _        y y )NT)Úrequires_grad)	re   rf   ry   rz   r   Ú	Parameterr@   ÚonesÚweight)rm   rx   ry   rz   rn   s       €rI   rf   zGemma4RMSNorm.__init__Æ   sB   ø€ Ü‰ÑÔØˆŒØ$ˆŒà�?Š?ÜŸ,™,¤u§z¡z°#£ÀdÔKˆD�Kð rH   rO   c                 ó’   — |j                  d«      j                  dd¬«      | j                  z   }|t        j                   |d«      z  S )Nr-   éÿÿÿÿT)Úkeepdimç      à¿)ÚpowÚmeanry   r@   )rm   rO   Úmean_squareds      rI   Ú_normzGemma4RMSNorm._normÎ   sA   € Ø$×(Ñ(¨Ó+×0Ñ0°¸TÐ0ÓBÀTÇXÁXÑMˆàœuŸy™y¨°tÓ<Ñ<Ð<rH   r\   c                 ó´   — | j                  |j                  «       «      }| j                  r|| j                  j                  «       z  }|j	                  |«      S rp   )r‡   rl   rz   r   Útype_as)rm   rO   Únormed_outputs      rI   rr   zGemma4RMSNorm.forwardÓ   sH   € ØŸ
™
 =×#6Ñ#6Ó#8Ó9ˆØ�?Š?Ø)¨D¯K©K×,=Ñ,=Ó,?Ñ?ˆMØ×$Ñ$ ]Ó3Ð3rH   )g�íµ ÷Æ°>T)r<   r=   r>   rs   rl   Úboolrf   r@   rF   r‡   rr   rt   ru   s   @rI   rw   rw   Å   sL   ø„ ñL˜Cð L eð LÀõ Lð= 5§<¡<ó =ð
4 U§\¡\ð 4°e·l±l÷ 4rH   rw   c                   ó¨   ‡ — e Zd ZU dZej
                  ed<   defˆ fd„Z ej                  «       dej
                  dej
                  fd„«       Z
ˆ xZS )Ú Gemma4AudioRelPositionalEncodingzíSinusoidal relative positional encoding for the audio encoder.

    Produces position embeddings of shape [1, context_size // 2 + 1, hidden_size] with
    concatenated [sin..., cos...] layout matching the original Gemma4 convention.
    Úinv_timescalesrY   c                 óØ  •— t         ‰| �  «        |j                  | _        |j                  |j                  z   dz
  |j
                  z   | _        d}d}| j                  dz  }t        j                  ||z  «      t        |dz
  d«      z  }|t        j                  t        j                  |«      | z  «      z  }| j                  d|j                  d«      j                  d«      d¬«       y )	Nr/   ç      ð?ç     ˆÃ@r-   rŽ   r   F©Ú
persistent)re   rf   Úhidden_sizeÚattention_chunk_sizeÚattention_context_leftÚattention_context_rightÚcontext_sizeÚmathÚlogÚmaxr@   ÚexpÚarangerj   Ú	unsqueeze)rm   rY   Úmin_timescaleÚmax_timescaleÚnum_timescalesÚlog_timescale_incrementrŽ   rn   s          €rI   rf   z)Gemma4AudioRelPositionalEncoding.__init__ã   sß   ø€ Ü‰ÑÔØ!×-Ñ-ˆÔà×'Ñ'¨&×*GÑ*GÑGÈ!ÑKÈf×NlÑNlÑlð 	Ôð ˆØˆØ×)Ñ)¨QÑ.ˆÜ"&§(¡(¨=¸=Ñ+HÓ"IÌCÐP^ÐabÑPbÐdeÓLfÑ"fÐØ&¬¯©´5·<±<ÀÓ3OÐSjÐRjÑ3jÓ)kÑkˆØ×ÑÐ-¨~×/GÑ/GÈÓ/J×/TÑ/TÐUVÓ/WÐdiÐÕjrH   rO   r\   c                 ót  — t        j                  | j                  dz  dd|j                  ¬«      }|d   }|| j                  j                  |j                  ¬«      z  }t        j                  t        j                  |«      t        j                  |«      gd¬«      }|j                  |j                  ¬«      S )Nr-   r�   ©Údevice©.N©rx   ©Údtype)
r@   r�   r˜   r¥   rŽ   ÚtoÚcatÚsinÚcosr©   )rm   rO   Úposition_idsÚscaled_timeÚ	pos_embeds        rI   rr   z(Gemma4AudioRelPositionalEncoding.forwardð   s”   € ä—|‘| D×$5Ñ$5¸Ñ$:¸BÀÈ=×K_ÑK_Ô`ˆØ# IÑ.ˆØ" T×%8Ñ%8×%;Ñ%;À=×CWÑCWÐ%;Ó%XÑXˆÜ—I‘IœuŸy™y¨Ó5´u·y±yÀÓ7MÐNÐTVÔWˆ	Ø�|‰| -×"5Ñ"5ˆ|Ó6Ð6rH   )r<   r=   r>   r?   r@   rF   rB   r0   rf   Úno_gradrr   rt   ru   s   @rI   r�   r�   Ú   sU   ø… ñð —L‘LÓ ðkÐ0õ kð €U‡]�]ƒ_ð7 U§\¡\ð 7°e·l±lò 7ó ô7rH   r�   c                   óP  ‡ — e Zd ZdZdedefˆ fd„Zdej                  dej                  fd„Z	dej                  dej                  fd„Z
d	ej                  dej                  fd
„Z	 ddej                  dej                  dej                  dz  deej                  df   fd„Zˆ xZS )ÚGemma4AudioAttentionz3Chunked local attention with relative position biasrY   Ú	layer_idxc                 ó   •— t         ‰| �  «        || _        || _        |j                  | _        |j                  |j                  z  | _        |j                  | _	        | j                  dz  t        j                  d«      z  | _        t        j                  dt        j                  z   «      t        j                  d«      z  | _        |j                  | _        |j"                  dz
  | _        |j&                  | _        | j                   | j$                  z   | j(                  z   | _        t-        ||j                  | j                  | j                  z  «      | _        t-        ||j                  | j                  | j                  z  «      | _        t-        ||j                  | j                  | j                  z  «      | _        t-        ||j                  |j                  «      | _        t7        j8                  |j                  | j                  | j                  z  d¬«      | _        t7        j<                  t?        j@                  | j                  «      «      | _!        | jE                  dt?        jF                  | j
                  «      d¬«       y )Nrƒ   r-   r/   Fr^   Úsoftcapr’   )$re   rf   rY   r´   Úattention_logit_capÚattention_logits_soft_capr”   Únum_attention_headsÚhead_dimÚ	num_headsr™   rš   Úq_scaleÚeÚk_scaler•   Ú
chunk_sizer–   Úmax_past_horizonr—   Úmax_future_horizonr˜   rX   Úq_projÚk_projÚv_projÚpostr   rh   Úrelative_k_projr}   r@   ÚzerosÚper_dim_scalerj   rk   ©rm   rY   r´   rn   s      €rI   rf   zGemma4AudioAttention.__init__ü   sÛ  ø€ Ü‰ÑÔØˆŒØ"ˆŒØ)/×)CÑ)CˆÔ&Ø×*Ñ*¨f×.HÑ.HÑHˆŒØ×3Ñ3ˆŒàŸ™ tÑ+¬t¯x©x¸«{Ñ:ˆŒÜ—x‘x ¤D§F¡F¡
Ó+¬d¯h©h°q«kÑ9ˆŒà ×5Ñ5ˆŒØ &× =Ñ =ÀÑ AˆÔØ"(×"@Ñ"@ˆÔØ ŸO™O¨d×.CÑ.CÑCÀd×F]ÑF]Ñ]ˆÔä+¨F°F×4FÑ4FÈÏÉÐY]×YfÑYfÑHfÓgˆŒÜ+¨F°F×4FÑ4FÈÏÉÐY]×YfÑYfÑHfÓgˆŒÜ+¨F°F×4FÑ4FÈÏÉÐY]×YfÑYfÑHfÓgˆŒÜ)¨&°&×2DÑ2DÀf×FXÑFXÓYˆŒ	ä!Ÿy™y¨×);Ñ);¸T¿^¹^ÈdÏmÉmÑ=[ÐbgÔhˆÔÜŸ\™\¬%¯+©+°d·m±mÓ*DÓEˆÔà×Ñ˜Y¬¯©°T×5SÑ5SÓ(TÐafÐÕgrH   rO   r\   c           	      ó  — |j                   \  }}}}|| j                  z   dz
  | j                  z  }|| j                  z  |z
  }t        j                  |ddddd|f«      }|j	                  ||| j                  ||«      j                  «       S )z€Splits a `(batch_size, seq_len, num_heads, head_dim)` tensor into non-overlapping blocks of `chunk_size` along the sequence dim.r/   r   )Úshaper¿   ÚFÚpadÚreshapeÚ
contiguous)rm   rO   Ú
batch_sizeÚseq_lenr»   rº   Ú
num_blocksrÍ   s           rI   Ú_convert_to_blockz&Gemma4AudioAttention._convert_to_block  s‰   € à3@×3FÑ3FÑ0ˆ
�G˜Y¨Ø §¡Ñ/°!Ñ3¸¿¹ÑGˆ
Ø˜4Ÿ?™?Ñ*¨WÑ4ˆÜŸ™˜m¨a°°A°q¸!¸SÐ-AÓBˆØ×$Ñ$ Z°¸T¿_¹_ÈiÐYaÓb×mÑmÓoÐorH   c           
      ó@  — |j                   \  }}}}t        j                  |dddd| j                  | j                  | j
                  z   dz
  f«      }|j                  d| j                  | j
                  «      }t        j                  |dd«      }|j                  «       S )z`Extracts overlapping context windows of `context_size` for every block, strided by `chunk_size`.r   r/   r�   r-   )rË   rÌ   rÍ   rÀ   rÁ   r¿   Úunfoldr˜   r@   ÚmovedimrÏ   )rm   rO   rÐ   rÑ   r»   rº   s         rI   Ú_extract_block_contextz+Gemma4AudioAttention._extract_block_context  s•   € à3@×3FÑ3FÑ0ˆ
�G˜Y¨ÜŸ™Ø˜A˜q ! Q¨×(=Ñ(=¸t×?VÑ?VÐY]×YhÑYhÑ?hÐklÑ?lÐmó
ˆð &×,Ñ,¨Q°×0AÑ0AÀ4Ç?Á?ÓSˆÜŸ™ m°R¸Ó;ˆØ×'Ñ'Ó)Ð)rH   Úxc                 óð   — |j                   \  }}}}}| j                  }t        j                  |d|dz   |z
  f«      }|j	                  |||||dz   z  «      }|dd||z  …f   }|j	                  |||||«      S )zjRelative position shift for blocked attention. See appendix B of https://huggingface.co/papers/1901.02860.r   r/   .N)rË   r˜   rÌ   rÍ   Úview)rm   rØ   rÐ   r»   rÒ   Ú
block_sizeÚposition_lengthr˜   s           rI   Ú
_rel_shiftzGemma4AudioAttention._rel_shift(  s�   € àIJÏÉÑFˆ
�I˜z¨:°Ø×(Ñ(ˆÜ�E‰E�!�a˜¨Ñ)¨OÑ;Ð<Ó=ˆØ�F‰F�:˜y¨*°jÀLÐSTÑDTÑ6UÓVˆØˆcÐ.�Z ,Ñ.Ð.Ð.Ñ/ˆØ�v‰v�j )¨Z¸À\ÓRÐRrH   NÚposition_embeddingsrU   c                 óÚ  — |j                   \  }}}||| j                  | j                  f}| j                  |«      j	                  «       j                  |«      }| j                  |«      j	                  «       j                  |«      }	| j                  |«      j	                  «       j                  |«      }
|| j                  z  t        j                  | j                  «      z  }|	| j                  z  }	| j                  |«      }| j                  |	«      }	| j                  |
«      }
|j                   d   }| j                  |«      }|j                  d| j                  | j                  «      }|j!                  |j"                  ¬«      }|j%                  ddddd«      }||	j%                  ddddd«      z  }|j'                  || j                  d| j                  «      }||j%                  ddd«      z  }|j'                  || j                  || j(                  d«      }| j+                  |«      }||z   }|| j,                  z  }t/        j0                  |«      }|| j,                  z  }|�4|j3                  |j5                  «       | j6                  j8                  «      }t        j:                  |dt.        j<                  ¬«      j!                  |
j"                  «      }||
j%                  ddddd«      z  }|j%                  ddddd«      j'                  ||| j(                  z  d«      }|d d …d |…f   j?                  «       }| jA                  |j!                  |j"                  «      «      }||fS )	Nr/   r�   r¨   r   r
   r-   é   ©rx   r©   )!rË   r»   rº   rÂ   rl   rÚ   rÃ   rÄ   r¼   rÌ   ÚsoftplusrÈ   r¾   rÓ   r×   rÆ   rª   r©   ÚpermuterÎ   r¿   rÝ   r¶   r@   ÚtanhÚmasked_fillÚlogical_notrY   Úattention_invalid_logits_valueÚsoftmaxÚfloat32rÏ   rÅ   )rm   rO   rÞ   rU   rÐ   Ú
seq_lengthÚ_Úhidden_shapeÚquery_statesÚ
key_statesÚvalue_statesrÒ   Úrelative_key_statesÚqueriesÚ	matrix_acÚqueries_flatÚ	matrix_bdÚattn_weightsÚattn_outputs                      rI   rr   zGemma4AudioAttention.forward1  s  € ð %2×$7Ñ$7Ñ!ˆ
�J Ø" J°·±ÀÇÁÐNˆà—{‘{ =Ó1×7Ñ7Ó9×>Ñ>¸|ÓLˆØ—[‘[ Ó/×5Ñ5Ó7×<Ñ<¸\ÓJˆ
Ø—{‘{ =Ó1×7Ñ7Ó9×>Ñ>¸|ÓLˆà# d§l¡lÑ2´Q·Z±ZÀ×@RÑ@RÓ5SÑSˆØ $§,¡,Ñ.ˆ
à×-Ñ-¨lÓ;ˆØ×0Ñ0°Ó<ˆ
Ø×2Ñ2°<Ó@ˆØ!×'Ñ'¨Ñ*ˆ
à"×2Ñ2Ð3FÓGÐØ1×6Ñ6°r¸4¿>¹>È4Ï=É=ÓYÐØ1×4Ñ4¸<×;MÑ;MÐ4ÓNÐà×&Ñ& q¨!¨Q°°1Ó5ˆØ˜j×0Ñ0°°A°q¸!¸QÓ?Ñ?ˆ	à—‘ z°4·>±>À2ÀtÇ}Á}ÓUˆØ Ð#6×#>Ñ#>¸qÀ!ÀQÓ#GÑGˆ	Ø×%Ñ% j°$·.±.À*ÈdÏoÉoÐ_aÓbˆ	Ø—O‘O IÓ.ˆ	à  9Ñ,ˆØ# d§l¡lÑ2ˆÜ—z‘z ,Ó/ˆØ# d§l¡lÑ2ˆàÐ%Ø'×3Ñ3Ø×*Ñ*Ó,¨d¯k©k×.XÑ.XóˆLô —y‘y °2¼U¿]¹]ÔK×NÑNÈ|×OaÑOaÓbˆØ" \×%9Ñ%9¸!¸QÀÀ1ÀaÓ%HÑHˆØ!×)Ñ)¨!¨Q°°1°aÓ8×@Ñ@ÀÈZÐZ^×ZiÑZiÑMiÐkmÓnˆØ!¢! [ j [ .Ñ1×<Ñ<Ó>ˆØ—i‘i §¡¨}×/BÑ/BÓ CÓDˆà˜LÐ(Ð(rH   rp   )r<   r=   r>   r?   r0   rs   rf   r@   rF   rÓ   r×   rÝ   rV   rE   rr   rt   ru   s   @rI   r³   r³   ù   sÅ   ø„ Ù=ðhÐ0ð h¸Sõ hð4p¨u¯|©|ð pÀÇÁó pð*°E·L±Lð *ÀUÇ\Á\ó *ðS˜EŸL™Lð S¨U¯\©\ó Sð 37ñ	1)à—|‘|ð1)ð #Ÿ\™\ð1)ð ×(Ñ(¨4Ñ/ð	1)ð
 
ˆu�|‰|˜TÐ!Ñ	"÷1)rH   r³   c                   ó^   ‡ — e Zd Zˆ fd„Zddej
                  dej
                  dz  fd„Zˆ xZS )Ú'Gemma4AudioSubSampleConvProjectionLayerc                 óÐ   •— t         ‰| �  «        t        j                  ||dddd¬«      | _        t        j
                  ||dd¬«      | _        t        j                  «       | _        y )N)r
   r
   )r-   r-   r/   F)Úin_channelsÚout_channelsÚkernel_sizeÚstrideÚpaddingr_   T)ry   Úelementwise_affiner_   )	re   rf   r   ÚConv2dÚconvÚ	LayerNormÚnormÚReLUÚact)rm   rú   rû   Únorm_epsrn   s       €rI   rf   z0Gemma4AudioSubSampleConvProjectionLayer.__init__f  sW   ø€ Ü‰ÑÔÜ—I‘IØ#Ø%ØØØØô
ˆŒ	ô —L‘L °8ÐPTÐ[`ÔaˆŒ	Ü—7‘7“9ˆ�rH   NrO   Úmaskc           
      ó¢  — |�,|j                  |j                  ¬«      }||d d …d d d …d f   z  }| j                  |j                  | j                  j                  j                  «      «      }| j                  | j                  |j                  dddd«      «      j                  dddd«      j                  «       «      }|�|d d …d d d…f   }||fS )Nr¤   r   r-   r
   r/   )	rª   r¥   r  r   r©   r  r  rã   rÏ   )rm   rO   r  s      rI   rr   z/Gemma4AudioSubSampleConvProjectionLayer.forwards  sÇ   € ØÐØ—7‘7 -×"6Ñ"6�7Ó7ˆDØ)¨D²°Dº!¸TÐ1AÑ,BÑBˆMàŸ	™	 -×"2Ñ"2°4·9±9×3CÑ3C×3IÑ3IÓ"JÓKˆØŸ™ §¡¨=×+@Ñ+@ÀÀAÀqÈ!Ó+LÓ!M×!UÑ!UÐVWÐYZÐ\]Ð_`Ó!a×!lÑ!lÓ!nÓoˆàÐØš™3˜Q˜3˜‘<ˆDà˜dÐ"Ð"rH   rp   )r<   r=   r>   rf   r@   rF   rr   rt   ru   s   @rI   rø   rø   e  s(   ø„ ôñ# U§\¡\ð #¸¿¹ÈÑ9L÷ #rH   rø   c            	       óœ   ‡ — e Zd Zdefˆ fd„Z	 ddej                  dej                  dz  deej                  ej                  f   fd„Zˆ xZ	S )	Ú"Gemma4AudioSubSampleConvProjectionrY   c                 óv  •— t         ‰| �  «        t        d|j                  d   |j                  ¬«      | _        t        |j                  d   |j                  d   |j                  ¬«      | _        |j                  d   dz  |j                  d   z  }t        j                  ||j                  d¬«      | _
        y )Nr/   r   )rú   rû   r  rà   Fr^   )re   rf   rø   Úsubsampling_conv_channelsÚrms_norm_epsÚlayer0Úlayer1r   rh   r”   Úinput_proj_linear)rm   rY   Úproj_input_dimrn   s      €rI   rf   z+Gemma4AudioSubSampleConvProjection.__init__‚  s«   ø€ Ü‰ÑÔÜ=ØØ×9Ñ9¸!Ñ<Ø×(Ñ(ô
ˆŒô
 >Ø×8Ñ8¸Ñ;Ø×9Ñ9¸!Ñ<Ø×(Ñ(ô
ˆŒð
 !×:Ñ:¸1Ñ=ÀÑBÀf×FfÑFfÐghÑFiÑiˆÜ!#§¡¨>¸6×;MÑ;MÐTYÔ!ZˆÕrH   NÚinput_featuresÚinput_features_maskr\   c                 ó&  — |j                  d«      }| j                  ||«      \  }}| j                  ||«      \  }}|j                  \  }}}}|j	                  dddd«      j                  «       j                  ||d«      }| j                  |«      |fS )Nr/   r   r-   r
   r�   )rž   r  r  rË   rã   rÏ   rÎ   r  )rm   r  r  rO   r  rÐ   rë   rÑ   s           rI   rr   z*Gemma4AudioSubSampleConvProjection.forward‘  s™   € ð
 '×0Ñ0°Ó3ˆØ"Ÿk™k¨-Ð9LÓMÑˆ�tØ"Ÿk™k¨-¸Ó>Ñˆ�tà$1×$7Ñ$7Ñ!ˆ
�A�w Ø%×-Ñ-¨a°°A°qÓ9×DÑDÓF×NÑNÈzÐ[bÐdfÓgˆØ×%Ñ% mÓ4°dÐ:Ð:rH   rp   )
r<   r=   r>   r0   rf   r@   rF   rE   rr   rt   ru   s   @rI   r
  r
  �  sW   ø„ ð[Ð0õ [ð$ 48ñ;àŸ™ð;ð #Ÿ\™\¨DÑ0ð;ð 
ˆu�|‰|˜UŸ\™\Ð)Ñ	*÷	;rH   r
  c                   ó\   ‡ — e Zd Zdefˆ fd„Zdej                  dej                  fd„Zˆ xZS )ÚGemma4AudioFeedForwardrY   c                 ó°  •— t         ‰| �  «        || _        t        ||j                  |j                  dz  «      | _        t        ||j                  dz  |j                  «      | _        t        |j                  «      | _        t        |j                  «      | _	        t        |j                     | _        |j                  | _        |j                  | _        y )Nrà   )re   rf   rY   rX   r”   Úffw_layer_1Úffw_layer_2rw   Úpre_layer_normÚpost_layer_normr   Ú
hidden_actÚact_fnÚgradient_clippingÚresidual_weightÚpost_layer_scale©rm   rY   rn   s     €rI   rf   zGemma4AudioFeedForward.__init__   s¯   ø€ Ü‰ÑÔØˆŒä0°¸×9KÑ9KÈV×M_ÑM_ÐbcÑMcÓdˆÔÜ0°¸×9KÑ9KÈaÑ9OÐQW×QcÑQcÓdˆÔä+¨F×,>Ñ,>Ó?ˆÔÜ,¨V×-?Ñ-?Ó@ˆÔÜ˜V×.Ñ.Ñ/ˆŒà!'×!9Ñ!9ˆÔØ &× 6Ñ 6ˆÕrH   rO   r\   c                 ó¶  — t        | j                  t        j                  |j                  «      j
                  «      }|}t        j                  || |«      }| j                  |«      }| j                  |«      }| j                  |«      }| j                  |«      }t        j                  || |«      }| j                  |«      }|| j                  z  }||z  }|S rp   )Úminr  r@   Úfinfor©   r›   rq   r  r  r  r  r  r   )rm   rO   r  Úresiduals       rI   rr   zGemma4AudioFeedForward.forward®  sË   € ä × 6Ñ 6¼¿¹ÀM×DWÑDWÓ8X×8\Ñ8\Ó]Ðà ˆÜŸ™ MÐ4EÐ3EÐGXÓYˆØ×+Ñ+¨MÓ:ˆà×(Ñ(¨Ó7ˆØŸ™ MÓ2ˆØ×(Ñ(¨Ó7ˆäŸ™ MÐ4EÐ3EÐGXÓYˆØ×,Ñ,¨]Ó;ˆØ˜×.Ñ.Ñ.ˆØ˜Ñ!ˆàÐrH   ©	r<   r=   r>   r0   rf   r@   rF   rr   rt   ru   s   @rI   r  r  Ÿ  s+   ø„ ð7Ð0õ 7ð U§\¡\ð °e·l±l÷ rH   r  c                   ó`   ‡ — e Zd Zed„ «       Zdej                  dej                  fˆ fd„Zˆ xZS )ÚGemma4AudioCausalConv1dc                 óp   — | j                   d   dz
  | j                  d   z  dz   }|| j                  d   z
  S )Nr   r/   )rü   Údilationrý   )rm   Úeffective_kernel_sizes     rI   Úleft_padz Gemma4AudioCausalConv1d.left_padÑ  s>   € à!%×!1Ñ!1°!Ñ!4°qÑ!8¸D¿M¹MÈ!Ñ<LÑ LÈqÑ PÐØ$ t§{¡{°1¡~Ñ5Ð5rH   rØ   r\   c                 óz   •— t         j                  j                  || j                  df«      }t        ‰| �  |«      S ©Nr   )r   r	   rÍ   r,  re   rr   )rm   rØ   rn   s     €rI   rr   zGemma4AudioCausalConv1d.forwardÖ  s3   ø€ ô �M‰M×Ñ˜a $§-¡-°Ð!3Ó4ˆä‰w‰˜qÓ!Ð!rH   )	r<   r=   r>   r   r,  r@   rF   rr   rt   ru   s   @rI   r(  r(  Ã  s;   ø„ ð ñ6ó ð6ð"à�<‰<ð"ð 
�‰÷	"ñ "rH   r(  c                   ó\   ‡ — e Zd Zdefˆ fd„Zdej                  dej                  fd„Zˆ xZS )ÚGemma4AudioLightConv1drY   c                 ó6  •— t         ‰| �  «        || _        t        ||j                  |j                  dz  «      | _        t        ||j                  |j                  «      | _        t        |j                  |j                  |j                  |j                  d¬«      | _	        t        |j                  |j                  d¬«      | _        t        |j                  |j                  d¬«      | _        t        |j                     | _        |j"                  | _        y )Nr-   F)rú   rû   rü   Úgroupsr_   T©ry   rz   )re   rf   rY   rX   r”   Úlinear_startÚ
linear_endr(  Úconv_kernel_sizeÚdepthwise_conv1drw   r  r  Ú	conv_normr   r  r  r  r!  s     €rI   rf   zGemma4AudioLightConv1d.__init__å  så   ø€ Ü‰ÑÔØˆŒä1°&¸&×:LÑ:LÈf×N`ÑN`ÐcdÑNdÓeˆÔÜ/°¸×8JÑ8JÈF×L^ÑL^Ó_ˆŒÜ 7Ø×*Ñ*Ø×+Ñ+Ø×/Ñ/Ø×%Ñ%Øô!
ˆÔô ,¨F×,>Ñ,>ÀF×DWÑDWÐdhÔiˆÔÜ& v×'9Ñ'9¸v×?RÑ?RÐ_cÔdˆŒÜ˜V×.Ñ.Ñ/ˆŒà!'×!9Ñ!9ˆÕrH   rO   r\   c                 ó  — |}| j                  |«      }| j                  |«      }t        j                  j	                  |d¬«      }| j                  |j                  dd«      «      j                  dd«      }t        | j                  t        j                  |j                  «      j                  «      }t        j                  || |«      }| j                  |«      }| j                  |«      }| j!                  |«      }||z  }|S )Nr�   r§   r/   r-   )r  r4  r   r	   Úglur7  Ú	transposer#  r  r@   r$  r©   r›   rq   r8  r  r5  )rm   rO   r%  r  s       rI   rr   zGemma4AudioLightConv1d.forwardù  sç   € Ø ˆà×+Ñ+¨MÓ:ˆØ×)Ñ)¨-Ó8ˆÜŸ™×)Ñ)¨-¸RÐ)Ó@ˆà×-Ñ-¨m×.EÑ.EÀaÈÓ.KÓL×VÑVÐWXÐZ[Ó\ˆô   × 6Ñ 6¼¿¹ÀM×DWÑDWÓ8X×8\Ñ8\Ó]ÐÜŸ™ MÐ4EÐ3EÐGXÓYˆØŸ™ }Ó5ˆàŸ™ MÓ2ˆØŸ™¨Ó6ˆØ˜Ñ!ˆØÐrH   r&  ru   s   @rI   r0  r0  ä  s+   ø„ ð:Ð0õ :ð( U§\¡\ð °e·l±l÷ rH   r0  c            
       ó    ‡ — e Zd Zdedefˆ fd„Zdej                  dej                  dz  dej                  de	e
   d	ej                  f
d
„Zˆ xZS )ÚGemma4AudioLayerrY   r´   c                 óp  •— t         ‰| �  «        || _        t        |«      | _        t        |«      | _        t        ||«      | _        t        |«      | _	        t        |j                  «      | _        t        |j                  «      | _        t        |j                  «      | _        |j                  | _        y rp   )re   rf   rY   r  Úfeed_forward1Úfeed_forward2r³   Ú	self_attnr0  Úlconv1drw   r”   Únorm_pre_attnÚnorm_post_attnÚnorm_outr  rÉ   s      €rI   rf   zGemma4AudioLayer.__init__  s�   ø€ Ü‰ÑÔØˆŒä3°FÓ;ˆÔÜ3°FÓ;ˆÔÜ-¨f°iÓ@ˆŒÜ-¨fÓ5ˆŒä*¨6×+=Ñ+=Ó>ˆÔÜ+¨F×,>Ñ,>Ó?ˆÔÜ% f×&8Ñ&8Ó9ˆŒà!'×!9Ñ!9ˆÕrH   rO   rU   NrÞ   Úkwargsr\   c                 ó@  — t        | j                  t        j                  | j                  j
                  j                  «      j                  «      }| j                  |«      }|}t        j                  || |«      }| j	                  |«      }| j                  |||¬«      \  }}t        j                  || |«      }| j                  |«      }||z  }| j                  |«      }| j                  |«      }t        j                  || |«      }| j                  |«      }|S )N)rO   rÞ   rU   )r#  r  r@   r$  rC  r   r©   r›   r?  rq   rA  rD  rB  r@  rE  )rm   rO   rU   rÞ   rF  r  r%  rë   s           rI   rr   zGemma4AudioLayer.forward  s  € ô   × 6Ñ 6¼¿¹ÀD×DVÑDV×D]ÑD]×DcÑDcÓ8d×8hÑ8hÓiÐà×*Ñ*¨=Ó9ˆØ ˆäŸ™ MÐ4EÐ3EÐGXÓYˆØ×*Ñ*¨=Ó9ˆàŸ>™>Ø'Ø 3Ø)ð *ó 
Ñˆ�qô Ÿ™ MÐ4EÐ3EÐGXÓYˆØ×+Ñ+¨MÓ:ˆØ˜Ñ!ˆàŸ™ ]Ó3ˆØ×*Ñ*¨=Ó9ˆäŸ™ MÐ4EÐ3EÐGXÓYˆØŸ™ mÓ4ˆàÐrH   )r<   r=   r>   r0   rs   rf   r@   rF   rV   r"   r$   rr   rt   ru   s   @rI   r=  r=    si   ø„ ð:Ð0ð :¸Sõ :ð à—|‘|ð ð ×(Ñ(¨4Ñ/ð ð #Ÿ\™\ð	 ð
 Ð+Ñ,ð ð 
�‰÷ rH   r=  c                   óÜ   ‡ — e Zd Zdefˆ fd„Zdej                  dej                  dej                  fd„Zdej                  dej                  dej                  dej                  fd„Zˆ xZ	S )	ÚGemma4VisionPatchEmbedderrY   c                 óŠ  •— t         ‰| �  «        || _        |j                  | _        |j                  | _        |j
                  | _        t        j                  d| j                  dz  z  | j                  d¬«      | _        t        j                  t        j                  d| j
                  | j                  «      «      | _        y )Nr
   r-   Fr^   )re   rf   rY   r”   Ú
patch_sizeÚposition_embedding_sizer   rh   Ú
input_projr}   r@   r~   Úposition_embedding_tabler!  s     €rI   rf   z"Gemma4VisionPatchEmbedder.__init__D  s’   ø€ Ü‰ÑÔØˆŒØ!×-Ñ-ˆÔØ ×+Ñ+ˆŒØ'-×'EÑ'EˆÔ$äŸ)™) A¨¯©¸Ñ(:Ñ$:¸D×<LÑ<LÐSXÔYˆŒÜ(*¯©´U·Z±ZÀÀ4×C_ÑC_Ðae×aqÑaqÓ5rÓ(sˆÕ%rH   Úpixel_position_idsÚpadding_positionsr\   c                 ó  — |j                  d¬«      }t        j                  |d   | j                  d   «      }t        j                  |d   | j                  d   «      }||z   }t	        j
                  |j                  d«      d|«      }|S )ak  Compute 2-D patch position embeddings via embedding lookup.

        ``pixel_position_ids`` has shape ``(batch, num_patches, 2)`` where the
        last dimension holds (x, y) indices into ``position_embedding_table``
        (shape ``(2, position_embedding_size, hidden_size)``).  The result is the
        sum of the x- and y-embeddings for each patch.
        r   ©r#  ©.r   ©.r/   r/   r�   ç        )rq   rÌ   Ú	embeddingrN  r@   Úwhererž   )rm   rO  rP  Úclamped_positionsÚx_embÚy_embrÞ   s          rI   Ú_position_embeddingsz.Gemma4VisionPatchEmbedder._position_embeddingsN  sŽ   € ð /×4Ñ4¸Ð4Ó;Ðô —‘Ð-¨fÑ5°t×7TÑ7TÐUVÑ7WÓXˆÜ—‘Ð-¨fÑ5°t×7TÑ7TÐUVÑ7WÓXˆØ# e™mÐÜ#Ÿk™kÐ*;×*EÑ*EÀbÓ*IÈ3ÐPcÓdÐØ"Ð"rH   Úpixel_valuesc                 óÜ   — d|dz
  z  }| j                   j                  j                  x}j                  r|j	                  |«      }| j                  |«      }| j                  ||«      }||z   S )Nr-   ç      à?)rM  r   r©   Úis_floating_pointrª   r[  )rm   r\  rO  rP  Útarget_dtyperO   rÞ   s          rI   rr   z!Gemma4VisionPatchEmbedder.forwardd  sn   € ð ˜L¨3Ñ.Ñ/ˆØ ŸO™O×2Ñ2×8Ñ8Ð8ˆL×KÒKØ'Ÿ?™?¨<Ó8ˆLØŸ™¨Ó5ˆØ"×7Ñ7Ð8JÐL]Ó^ÐØÐ2Ñ2Ð2rH   )
r<   r=   r>   r3   rf   r@   rF   r[  rr   rt   ru   s   @rI   rI  rI  C  su   ø„ ðtÐ1õ tð#°u·|±|ð #ÐX]×XdÑXdð #Ðin×iuÑiuó #ð,	3Ø!ŸL™Lð	3Ø>C¿l¹lð	3Ø_d×_kÑ_kð	3à	�‰÷	3rH   rI  c                   ó.  ‡ — e Zd ZdZdefˆ fd„Zdej                  dej                  dede	ej                  ej                  f   fd„Z
	 ddej                  dej                  d
ej                  ded	z  de	ej                  ej                  f   f
d„Zˆ xZS )ÚGemma4VisionPoolera[  Spatial pooling and ``sqrt(hidden_size)`` scaling for vision encodings.

    The scaling expands the activation magnitude, which can exceed the float16 range, so it is
    computed in float32 and the pooled features are returned in float32. The caller
    (``Gemma4VisionModel.forward``) standardizes them and casts back to the working dtype.
    rY   c                 ól   •— t         ‰| �  «        |j                  | _        | j                  dz  | _        y )Nr^  )re   rf   r”   Úroot_hidden_sizer!  s     €rI   rf   zGemma4VisionPooler.__init__x  s/   ø€ Ü‰ÑÔØ!×-Ñ-ˆÔØ $× 0Ñ 0°#Ñ 5ˆÕrH   rO   rO  Úlengthr\   c                 óŽ  — |j                   d   }t        ||z  dz  «      }|dz  }||z  |k7  r%t        d|j                   › d|› d|›d|›d|› d	�«      ‚|j                  d
¬«      }|d   j	                  dd¬«      d
   dz   }t        j                  ||d¬«      }	|	d   ||z  |	d   z  z   }	t        j                  |	j                  «       |«      j                  «       |z  }
|
j                  dd«      |j                  «       z  }t        j                  |
d
k(  j                  d¬«      «      }|j                  |j                  «      |fS )zÙ
        2D spatial pooling according to patch positions.
        Pools the input tokens by averaging patches within a `k^2` grid, where `k` is determined by the ratio between
        input and output lengths
        r/   r^  r-   zCannot pool z to z: k=z^2 times length=z	 must be ú.r   rR  rS  r�   T©rx   r‚   Úfloor)Úrounding_moderT  r§   )rË   rs   Ú
ValueErrorrq   r›   r@   ÚdivrÌ   Úone_hotÚlongrl   r;  ræ   Úallrª   r©   )rm   rO   rO  re  Úinput_seq_lenÚkÚ	k_squaredrX  Úmax_xÚkernel_idxsÚweightsÚoutputr  s                rI   Ú_avg_pool_by_positionsz)Gemma4VisionPooler._avg_pool_by_positions}  sh  € ð &×+Ñ+¨AÑ.ˆÜ� &Ñ(¨SÑ0Ó1ˆØ�q‘Dˆ	Ø�vÑ Ò.ÜØ˜}×2Ñ2Ð3°4¸°x¸uÀ!ÀÐEVÈvÈiÐW`ÐanÐ`oÐopÐqóð ð /×4Ñ4¸Ð4Ó;ÐØ! &Ñ)×-Ñ-°"¸dÐ-ÓCÀAÑFÈÑJˆÜ—i‘iÐ 1°1ÀGÔLˆØ! &Ñ)¨U°a©Z¸;ÀvÑ;NÑ,NÑNˆÜ—)‘)˜K×,Ñ,Ó.°Ó7×=Ñ=Ó?À)ÑKˆØ×"Ñ" 1 aÓ(¨=×+>Ñ+>Ó+@Ñ@ˆÜ× Ñ  '¨Q¡,×!3Ñ!3¸Ð!3Ó!:Ó;ˆØ�y‰y˜×,Ñ,Ó-¨tÐ3Ð3rH   NrP  Úoutput_lengthc                 ó8  — ||j                   d   kD  rt        d|› d|j                   d   › d�«      ‚|j                  |j                  d«      d«      }|j                   d   |k7  r| j	                  |||«      \  }}|j                  «       | j                  z  }||fS )Nr/   z*Cannot output more soft tokens (requested z) than there are patches (z9). Change the value of `num_soft_tokens` when processing.r�   rU  )rË   rk  rå   rž   rw  rl   rd  )rm   rO   rO  rP  rx  s        rI   rr   zGemma4VisionPooler.forward˜  sÄ   € ð ˜=×.Ñ.¨qÑ1Ò1ÜØ<¸]¸Oð LØ"×(Ñ(¨Ñ+Ð,Ð,eðgóð ð
 &×1Ñ1Ð2C×2MÑ2MÈbÓ2QÐSVÓWˆà×Ñ˜qÑ! ]Ò2Ø/3×/JÑ/JØÐ1°=ó0Ñ,ˆMÐ,ð &×+Ñ+Ó-°×0EÑ0EÑEˆØÐ/Ð/Ð/rH   rp   )r<   r=   r>   r?   r3   rf   r@   rF   rs   rE   rw  rr   rt   ru   s   @rI   rb  rb  p  s±   ø„ ñð6Ð1õ 6ð
4Ø"Ÿ\™\ð4Ø?D¿|¹|ð4ØUXð4à	ˆu�|‰|˜UŸ\™\Ð)Ñ	*ó4ð@ %)ñ0à—|‘|ð0ð "ŸL™Lð0ð !Ÿ<™<ð	0ð
 ˜T‘zð0ð 
ˆu�|‰|˜UŸ\™\Ð)Ñ	*÷0rH   rb  c                   ó*   ‡ — e Zd Zdefˆ fd„Zd„ Zˆ xZS )ÚGemma4VisionMLPrY   c                 óˆ  •— t         ‰| �  «        || _        |j                  | _        |j                  | _        t        || j                  | j                  «      | _        t        || j                  | j                  «      | _        t        || j                  | j                  «      | _        t        |j                     | _        y rp   )re   rf   rY   r”   Úintermediate_sizerX   Ú	gate_projÚup_projÚ	down_projr   Úhidden_activationr  r!  s     €rI   rf   zGemma4VisionMLP.__init__´  s—   ø€ Ü‰ÑÔØˆŒØ!×-Ñ-ˆÔØ!'×!9Ñ!9ˆÔÜ.¨v°t×7GÑ7GÈ×I_ÑI_Ó`ˆŒÜ,¨V°T×5EÑ5EÀt×G]ÑG]Ó^ˆŒÜ.¨v°t×7MÑ7MÈt×O_ÑO_Ó`ˆŒÜ˜V×5Ñ5Ñ6ˆ�rH   c                 óˆ   — | j                  | j                  | j                  |«      «      | j                  |«      z  «      }|S rp   ©r€  r  r~  r  ©rm   rØ   r€  s      rI   rr   zGemma4VisionMLP.forward¾  ó6   € Ø—N‘N 4§;¡;¨t¯~©~¸aÓ/@Ó#AÀDÇLÁLÐQRÃOÑ#SÓTˆ	ØÐrH   )r<   r=   r>   r3   rf   rr   rt   ru   s   @rI   r{  r{  ³  s   ø„ ð7Ð1õ 7örH   r{  c                   óØ   ‡ — e Zd ZU ej                  ed<   ddefˆ fd„Ze	 	 	 ddedz  dej                  dz  de
dz  dedef   fd	„«       Z ej                  «       ed
„ «       «       Zˆ xZS )ÚGemma4VisionRotaryEmbeddingÚinv_freqNrY   c                 ó®  •— t         ‰| �  «        |j                  | _        |j                  | _        || _        | j
                  j                  d   | _        | j                  }| j                  dk7  rt        | j                     } || j
                  |«      \  }| _
        | j                  d|d¬«       | j                  d|j                  «       d¬«       y )NÚ	rope_typeÚdefaultrˆ  Fr’   Úoriginal_inv_freq)re   rf   Úmax_position_embeddingsÚmax_seq_len_cachedÚoriginal_max_seq_lenrY   Úrope_parametersrŠ  Úcompute_default_rope_parametersr   Úattention_scalingrj   Úclone)rm   rY   r¥   Úrope_init_fnrˆ  rn   s        €rI   rf   z$Gemma4VisionRotaryEmbedding.__init__Æ  s¶   ø€ Ü‰ÑÔØ"(×"@Ñ"@ˆÔØ$*×$BÑ$BˆÔ!àˆŒàŸ™×4Ñ4°[ÑAˆŒØ!%×!EÑ!EˆØ�>‰>˜YÒ&Ü.¨t¯~©~Ñ>ˆLÙ+7¸¿¹ÀVÓ+LÑ(ˆ�$Ô(à×Ñ˜Z¨¸eÐÔDØ×ÑÐ0°(·.±.Ó2BÈuÐÕUrH   r¥   rÑ   r\   útorch.Tensorc                 ó$  — | j                   d   }t        | dd«      xs | j                  | j                  z  }|dz  }d}d|t	        j
                  d|dt        j                  ¬«      j                  |t        j                  ¬«      |z  z  z  }||fS )	a¨  
        Computes the inverse frequencies according to the original RoPE implementation
        Args:
            config ([`~transformers.PreTrainedConfig`]):
                The model configuration.
            device (`torch.device`):
                The device to use for initialization of the inverse frequencies.
            seq_len (`int`, *optional*):
                The current sequence length. Unused for this type of RoPE.
        Returns:
            Tuple of (`torch.Tensor`, `float`), containing the inverse frequencies for the RoPE embeddings and the
            post-processing scaling factor applied to the computed cos/sin (unused in this type of RoPE).
        Ú
rope_thetarº   Nr-   r�   r   r¨   ©r¥   r©   ©	r�  Úgetattrr”   r¹   r@   r�   Úint64rª   rl   )rY   r¥   rÑ   Úbaserx   Úspatial_dimÚattention_factorrˆ  s           rI   r‘  z;Gemma4VisionRotaryEmbedding.compute_default_rope_parametersÖ  s�   € ð& ×%Ñ% lÑ3ˆÜ�f˜j¨$Ó/Òc°6×3EÑ3EÈ×IcÑIcÑ3cˆð ˜Q‘hˆàÐØØÜ—‘˜Q ¨Q´e·k±kÔB×EÑEÈVÔ[`×[fÑ[fÐEÓgÐjuÑuñwñ
ˆð Ð)Ð)Ð)rH   c                 ó.  — | j                   d d d …d f   j                  «       j                  |j                  d   dd«      j	                  |j
                  «      }t        |j
                  j                  t        «      r/|j
                  j                  dk7  r|j
                  j                  nd}g g }}t        d«      D ]ä  }|d d …d d …|f   }|d d …d d d …f   j                  «       }	t        |d¬«      5  |j                  «       |	j                  «       z  j                  dd«      }
t        j                  |
|
fd¬	«      }|j                  «       | j                  z  }|j!                  «       | j                  z  }d d d «       |j#                  «       |j#                  «       Œæ t        j                  |d¬	«      j	                  |j$                  ¬
«      }t        j                  |d¬	«      j	                  |j$                  ¬
«      }||fS # 1 sw Y   Œ“xY w)Nr   r�   r/   ÚmpsÚcpur-   F©Údevice_typeÚenabledr§   r¨   )rˆ  rl   ÚexpandrË   rª   r¥   Ú
isinstanceÚtyperD   Úranger)   r;  r@   r«   r­   r’  r¬   Úappendr©   )rm   rØ   r®   Úinv_freq_expandedr£  Úall_cosÚall_sinÚiÚdim_position_idsÚdim_position_ids_expandedÚfreqsÚembr­   r¬   s                 rI   rr   z#Gemma4VisionRotaryEmbedding.forwardù  s¿  € ð !ŸM™M¨$²°4¨-Ñ8×>Ñ>Ó@×GÑGÈ×HZÑHZÐ[\ÑH]Ð_aÐcdÓe×hÑhÐij×iqÑiqÓrÐÜ'1°!·(±(·-±-ÄÔ'EÈ!Ï(É(Ï-É-Ð[`ÒJ`�a—h‘h—m’mÐfkˆð ˜r�ˆÜ�q“ò 
	 ˆAØ+ªAªq°!¨GÑ4ÐØ(8º¸DÂ!¸Ñ(D×(JÑ(JÓ(LÐ%ä¨KÀÔGñ 9Ø*×0Ñ0Ó2Ð5N×5TÑ5TÓ5VÑV×aÑaÐbcÐefÓg�Ü—i‘i ¨ °BÔ7�Ø—g‘g“i $×"8Ñ"8Ñ8�Ø—g‘g“i $×"8Ñ"8Ñ8�÷	9ð
 �N‰N˜3ÔØ�N‰N˜3Õð
	 ô �i‰i˜ RÔ(×+Ñ+°!·'±'Ð+Ó:ˆÜ�i‰i˜ RÔ(×+Ñ+°!·'±'Ð+Ó:ˆØ�Cˆxˆ÷9ð 9ús   Ã4BHÈH	rp   ©NNN)r<   r=   r>   r@   rF   rB   r3   rf   Ústaticmethodr¥   rs   rE   rl   r‘  r±   r   rr   rt   ru   s   @rI   r‡  r‡  Ã  sž   ø… Ø�l‰lÓñVÐ1õ Vð  à,0Ø&*Ø"ñ *Ø" TÑ)ð *à—‘˜tÑ#ð *ð �t‘ð *ð 
ˆ~˜uÐ$Ñ	%ò	 *ó ð *ðD €U‡]�]ƒ_Øñó ó ôrH   r‡  c                 óš   — | dd| j                   d   dz  …f   }| d| j                   d   dz  d…f   }t        j                  | |fd¬«      S )z*Rotates half the hidden dims of the input..Nr�   r-   r§   )rË   r@   r«   )rØ   Úx1Úx2s      rI   Úrotate_halfr·    sZ   € à	
ˆ3Ð"�!—'‘'˜"‘+ Ñ"Ð"Ð"Ñ	#€BØ	
ˆ3�—‘˜‘˜qÑ Ñ"Ð"Ñ	#€BÜ�9‰9�r�c˜2�Y BÔ'Ð'rH   rØ   r­   r¬   Úunsqueeze_dimc                 ón   — |j                  |«      }|j                  |«      }| |z  t        | «      |z  z   S )a\  Applies Rotary Position Embedding to the query and key tensors.

    Args:
        x (`torch.Tensor`): The tensor to embed.
        cos (`torch.Tensor`): The cosine part of the rotary embedding.
        sin (`torch.Tensor`): The sine part of the rotary embedding.
        unsqueeze_dim (`int`, *optional*, defaults to 1):
            The 'unsqueeze_dim' argument specifies the dimension along which to unsqueeze cos[position_ids] and
            sin[position_ids] so that they can be properly broadcasted to the dimensions of q and k. For example, note
            that cos[position_ids] and sin[position_ids] have the shape [batch_size, seq_len, head_dim]. Then, if q and
            k have the shape [batch_size, heads, seq_len, head_dim], then setting unsqueeze_dim=1 makes
            cos[position_ids] and sin[position_ids] broadcastable to the shapes of q and k. Similarly, if q and k have
            the shape [batch_size, seq_len, heads, head_dim], then set unsqueeze_dim=2.
    Returns:
        `tuple(torch.Tensor)` comprising of the query and key tensors rotated using the Rotary Position Embedding.
    )rž   r·  ©rØ   r­   r¬   r¸  s       rI   Úapply_rotary_pos_embr»    s8   € ð" �-‰-˜Ó
&€CØ
�-‰-˜Ó
&€CØ�‰Gœ A›¨Ñ,Ñ-Ð-rH   rO   Ún_repr\   c                 óª   — | j                   \  }}}}|dk(  r| S | dd…dd…ddd…dd…f   j                  |||||«      } | j                  |||z  ||«      S )zÔ
    This is the equivalent of torch.repeat_interleave(x, dim=1, repeats=n_rep). The hidden states go from (batch,
    num_key_value_heads, seqlen, head_dim) to (batch, num_attention_heads, seqlen, head_dim)
    r/   N)rË   r¥  rÎ   )rO   r¼  ÚbatchÚnum_key_value_headsÚslenrº   s         rI   Ú	repeat_kvrÁ  /  so   € ð
 2?×1DÑ1DÑ.€EÐ  hØ�‚zØÐØ!¢!¢Q¨ªa²Ð"2Ñ3×:Ñ:¸5ÐBUÐW\Ð^bÐdlÓm€MØ× Ñ  Ð(;¸eÑ(CÀTÈ8ÓTÐTrH   ÚmoduleÚqueryÚkeyÚvaluerU   ÚdropoutÚscalingr¶   c                 ó|  — |€| j                   dz  }t        || j                  «      }	t        || j                  «      }
t        j                  ||	j                  dd«      «      |z  }|�||z  }t        j                  |«      }||z  }|�||z   }t        j                  j                  |dt        j                  ¬«      j                  |j                  «      }t        j                  j                  ||| j                  ¬«      }t        j                  ||
«      }|j                  dd«      j                  «       }||fS )Nrƒ   r-   r
   r�   rá   )ÚpÚtrainingr/   )rº   rÁ  Únum_key_value_groupsr@   Úmatmulr;  rä   r   r	   rè   ré   rª   r©   rÆ  rÊ  rÏ   )rÂ  rÃ  rÄ  rÅ  rU   rÆ  rÇ  r¶   rF  rî   rï   rõ   rö   s                rI   Úeager_attention_forwardrÍ  ;  s  € ð €Ø—/‘/ 4Ñ'ˆä˜3 × ;Ñ ;Ó<€JÜ˜U F×$?Ñ$?Ó@€Lä—<‘<  z×';Ñ';¸A¸qÓ'AÓBÀWÑL€LàÐØ# gÑ-ˆÜ—z‘z ,Ó/ˆØ# gÑ-ˆØÐ!Ø# nÑ4ˆô —=‘=×(Ñ(¨¸2ÄUÇ]Á]Ð(ÓS×VÑVÐW\×WbÑWbÓc€LÜ—=‘=×(Ñ(¨¸È6Ï?É?Ð(Ó[€LÜ—,‘,˜|¨\Ó:€KØ×'Ñ'¨¨1Ó-×8Ñ8Ó:€KØ˜Ð$Ð$rH   r®   c           	      ó¸  — |j                   d   }| j                   d   }d|d|z  z  z  }|dk  rt        d|› d|› d|› d�«      ‚|g|z  }t        j                  | |d¬«      }	t        j                  ||d¬«      }
t        j                  ||d¬«      }t	        |«      D �cg c]  }t        |	|   |
|   ||   |¬	«      ‘Œ }}t        j                  |d¬«      S c c}w )
ak  Applies multidimensional RoPE to inputs.

    Args:
        x (`torch.Tensor`): The tensor to embed.
        cos (`torch.Tensor`): The cosine part of the rotary embedding.
        sin (`torch.Tensor`): The sine part of the rotary embedding.
        position_ids (`torch.Tensor`, *optional*):
            If position_ids.ndim + 2 == x.ndim, then this function passes through to `apply_rotary_pos_emb()`.
            Otherwise, position_ids is used to split the inputs, x, into multiple pieces, where each piece is fed to
            `apply_rotary_pos_emb()`, and then concatenated back together.
        unsqueeze_dim (`int`, *optional*, defaults to 1):
            The 'unsqueeze_dim' argument specifies the dimension along which to unsqueeze cos[position_ids] and
            sin[position_ids] so that they can be properly broadcasted to the dimensions of q and k. For example, note
            that cos[position_ids] and sin[position_ids] have the shape [batch_size, seq_len, head_dim]. Then, if q and
            k have the shape [batch_size, heads, seq_len, head_dim], then setting unsqueeze_dim=1 makes
            cos[position_ids] and sin[position_ids] broadcastable to the shapes of q and k. Similarly, if q and k have
            the shape [batch_size, seq_len, heads, head_dim], then set unsqueeze_dim=2.

    Returns:
      Tensor of shape [B, L, N, H] with RoPE applied.
    r�   r-   r   zEInvalid configuration: num_rotated_channels_per_dim must be > 0, got z (num_input_channels=z, ndim=ú)r§   rº  )rË   rk  r@   Úsplitr¨  r»  r«   )rØ   r­   r¬   r®   r¸  ÚndimÚnum_input_channelsÚnum_rotated_channels_per_dimÚsplit_sizesÚx_partsÚ	cos_partsÚ	sin_partsrq  Úy_partss                 rI   Úapply_multidimensional_roperÙ  ]  s  € ð8 ×Ñ˜bÑ!€DØŸ™ ™ÐØ#$Ð(:¸qÀ4¹xÑ(HÑ#IÐ à# qÒ(ÜðØ,Ð-Ð-BÐCUÐBVð WØ�F˜!ðó
ð 	
ð 0Ð0°4Ñ7€KÜ�k‰k˜!˜[¨bÔ1€GÜ—‘˜C °"Ô5€IÜ—‘˜C °"Ô5€Iô �t“öð ô 	Ø�a‰jØ˜!‘Ø˜!‘Ø'ö		
ð€Gð ô �9‰9�W "Ô%Ð%ùòs   ÂCc                   ó  ‡ — e Zd ZdZdedefˆ fd„Z	 	 	 ddej                  dej                  dej                  dz  d	ej                  dz  d
e
e   deej                  ej                  dz  eej                     dz  f   fd„Zˆ xZS )ÚGemma4VisionAttentionú=Multi-headed attention from 'Attention Is All You Need' paperrY   r´   c                 óà  •— t         ‰| �  «        t        |d«      r|j                  |   nd | _        || _        || _        t        |d|j                  |j                  z  «      | _
        |j                  |j                  z  | _        d| _        | j
                  j                  | _        d| _        t!        ||j                  |j                  | j                  z  «      | _        t!        ||j                  |j                  | j                  z  «      | _        t!        ||j                  |j                  | j                  z  «      | _        t!        ||j                  | j                  z  |j                  «      | _        t+        |j                  |j,                  ¬«      | _        t+        |j                  |j,                  ¬«      | _        t+        | j                  |j,                  d¬«      | _        y )NÚlayer_typesrº   r�   F©rx   ry   r3  )re   rf   ÚhasattrrÞ  Ú
layer_typerY   r´   rš  r”   r¹   rº   r¿  rË  rÇ  Úattention_dropoutÚ	is_causalrX   rÂ   rÃ   rÄ   Úo_projrw   r  Úq_normÚk_normÚv_normrÉ   s      €rI   rf   zGemma4VisionAttention.__init__˜  s€  ø€ Ü‰ÑÔÜ;BÀ6È=Ô;Y˜&×,Ñ,¨YÒ7Ð_cˆŒØˆŒØ"ˆŒÜ ¨
°F×4FÑ4FÈ&×JdÑJdÑ4dÓeˆŒØ$*×$>Ñ$>À&×B\ÑB\Ñ$\ˆÔ!ØˆŒØ!%§¡×!>Ñ!>ˆÔØˆŒÜ+¨F°F×4FÑ4FÈ×HbÑHbÐei×erÑerÑHrÓsˆŒÜ+¨F°F×4FÑ4FÈ×HbÑHbÐei×erÑerÑHrÓsˆŒÜ+¨F°F×4FÑ4FÈ×HbÑHbÐei×erÑerÑHrÓsˆŒÜ+¨F°F×4NÑ4NÐQU×Q^ÑQ^Ñ4^Ð`f×`rÑ`rÓsˆŒä#¨¯©¸V×=PÑ=PÔQˆŒÜ#¨¯©¸V×=PÑ=PÔQˆŒÜ# D§M¡M°v×7JÑ7JÐW\Ô]ˆ�rH   NrO   rÞ   rU   r®   rF  r\   c                 óN  — |j                   d d }g |¢d‘| j                  ‘­}|\  }}	| j                  |«      j                  |«      }
| j	                  |
«      }
t        |
||	|«      }
|
j                  dd«      }
| j                  |«      j                  |«      }| j                  |«      }t        |||	|«      }|j                  dd«      }| j                  |«      j                  |«      }| j                  |«      }|j                  dd«      }t        j                  | j                  j                  t        «      } || |
|||f| j                   r| j"                  nd| j$                  dœ|¤Ž\  }} |j&                  g |¢d‘­Ž j)                  «       }| j+                  |«      }||fS )Nr�   r/   r-   rU  )rÆ  rÇ  )rË   rº   rÂ   rÚ   rå  rÙ  r;  rÃ   ræ  rÄ   rç  r    Úget_interfacerY   Ú_attn_implementationrÍ  rÊ  râ  rÇ  rÎ   rÏ   rä  )rm   rO   rÞ   rU   r®   rF  Úinput_shaperì   r­   r¬   rí   rî   rï   Úattention_interfacerö   rõ   s                   rI   rr   zGemma4VisionAttention.forward«  sª  € ð $×)Ñ)¨#¨2Ð.ˆØ8˜Ð8 bÐ8¨$¯-©-Ñ8ˆà&‰ˆˆSà—{‘{ =Ó1×6Ñ6°|ÓDˆØ—{‘{ <Ó0ˆÜ2°<ÀÀcÈ<ÓXˆØ#×-Ñ-¨a°Ó3ˆà—[‘[ Ó/×4Ñ4°\ÓBˆ
Ø—[‘[ Ó,ˆ
Ü0°¸SÀ#À|ÓTˆ
Ø×)Ñ)¨!¨QÓ/ˆ
à—{‘{ =Ó1×6Ñ6°|ÓDˆØ—{‘{ <Ó0ˆØ#×-Ñ-¨a°Ó3ˆä(?×(MÑ(MØ�K‰K×,Ñ,Ô.Eó)
Ðñ %8ØØØØØð	%
ð /3¯mªm�D×*Ò*ÀØ—L‘Lñ	%
ð ñ	%
Ñ!ˆ�\ð *�k×)Ñ)Ð;¨;Ð;¸Ò;×FÑFÓHˆØ—k‘k +Ó.ˆØ˜LÐ(Ð(rH   r²  )r<   r=   r>   r?   r3   rs   rf   r@   rF   Ú
LongTensorr"   r$   rE   rr   rt   ru   s   @rI   rÛ  rÛ  •  s°   ø„ ÙGð^Ð1ð ^¸cõ ^ð, -1Ø.2Ø04ñ,)à—|‘|ð,)ð #Ÿ\™\ð,)ð Ÿ™ tÑ+ð	,)ð
 ×&Ñ&¨Ñ-ð,)ð Ð+Ñ,ð,)ð 
ˆu�|‰|˜UŸ\™\¨DÑ0°%¸¿¹Ñ2EÈÑ2LÐLÑ	M÷,)rH   rÛ  c                   ó  ‡ — e Zd Zdedefˆ fd„Z	 	 	 ddej                  dej                  dej                  dz  dej                  dz  d	e	e
   d
eej                  eej                  ej                  f   dz  f   fd„Zˆ xZS )ÚGemma4VisionEncoderLayerrY   r´   c                 óÔ  •— t         ‰| �  «        || _        |j                  | _        || _        t        ||¬«      | _        t        |«      | _        t        | j                  |j                  ¬«      | _        t        | j                  |j                  ¬«      | _        t        | j                  |j                  ¬«      | _        t        | j                  |j                  ¬«      | _        y )N©rY   r´   ©ry   )re   rf   rY   r”   r´   rÛ  rA  r{  Úmlprw   r  Úinput_layernormÚpost_attention_layernormÚpre_feedforward_layernormÚpost_feedforward_layernormrÉ   s      €rI   rf   z!Gemma4VisionEncoderLayer.__init__Û  s°   ø€ Ü‰ÑÔØˆŒØ!×-Ñ-ˆÔØ"ˆŒÜ.°fÈ	ÔRˆŒÜ" 6Ó*ˆŒÜ,¨T×-=Ñ-=À6×CVÑCVÔWˆÔÜ(5°d×6FÑ6FÈF×L_ÑL_Ô(`ˆÔ%Ü)6°t×7GÑ7GÈV×M`ÑM`Ô)aˆÔ&Ü*7¸×8HÑ8HÈf×NaÑNaÔ*bˆÕ'rH   NrO   rÞ   rU   r®   rF  r\   c                 ó   — |}| j                  |«      } | j                  d||||dœ|¤Ž\  }}| j                  |«      }||z   }|}| j                  |«      }| j	                  |«      }| j                  |«      }||z   }|S )N)rO   rÞ   rU   r®   rG   )rô  rA  rõ  rö  ró  r÷  )rm   rO   rÞ   rU   r®   rF  r%  rë   s           rI   rr   z Gemma4VisionEncoderLayer.forwardç  s¨   € ð !ˆà×,Ñ,¨]Ó;ˆà)˜4Ÿ>™>ð 
Ø'Ø 3Ø)Ø%ñ	
ð
 ñ
Ñˆ�qð ×5Ñ5°mÓDˆØ  =Ñ0ˆà ˆØ×6Ñ6°}ÓEˆØŸ™ Ó/ˆØ×7Ñ7¸ÓFˆØ  =Ñ0ˆàÐrH   r²  )r<   r=   r>   r3   rs   rf   r@   rF   rí  r"   r$   rE   rA   rr   rt   ru   s   @rI   rï  rï  Ú  s²   ø„ ð
cÐ1ð 
c¸cõ 
cð -1Ø.2Ø04ñà—|‘|ðð #Ÿ\™\ðð Ÿ™ tÑ+ð	ð
 ×&Ñ&¨Ñ-ðð Ð+Ñ,ðð 
ˆu× Ñ  %¨×(9Ñ(9¸5×;LÑ;LÐ(LÑ"MÐPTÑ"TÐTÑ	U÷rH   rï  c                   óŒ   ‡ — e Zd Zdefˆ fd„Z	 d
dej                  dej                  dej                  dz  dee	   de
f
d	„Zˆ xZS )ÚGemma4VisionEncoderrY   c           	      ó  •— t         ‰| �  «        || _        |j                  | _        t        |«      | _        t        j                  t        | j                  «      D �cg c]  }t        ||¬«      ‘Œ c}«      | _        y c c}w )Nrñ  )re   rf   rY   Únum_hidden_layersÚ
num_layersr‡  Ú
rotary_embr   Ú
ModuleListr¨  rï  Úlayers)rm   rY   r­  rn   s      €rI   rf   zGemma4VisionEncoder.__init__  sc   ø€ Ü‰ÑÔØˆŒØ ×2Ñ2ˆŒÜ5°fÓ=ˆŒÜ—m‘mÜKPÐQU×Q`ÑQ`ÓKaÖbÀaÔ%¨V¸qÖAÒbó
ˆ�ùÚbs   ÁA?NÚinputs_embedsrU   rO  rF  r\   c                 óÜ   — t        | j                  ||¬«      }|}| j                  ||«      }| j                  d| j                  j                   D ]  } ||f|||dœ|¤Ž}Œ t        |¬«      S )z�
        pixel_position_ids (torch.Tensor):
            Patch positions as (x, y) coordinates in the image as [batch, num_patches, 2].
        )rY   r  rU   N)rU   rÞ   r®   ©Úlast_hidden_state)r   rY   rþ  r   rü  r   )rm   r  rU   rO  rF  rO   rÞ   Údecoder_layers           rI   rr   zGemma4VisionEncoder.forward  s�   € ô 3Ø—;‘;Ø'Ø)ô
ˆð &ˆØ"Ÿo™o¨mÐ=OÓPÐð "Ÿ[™[Ð)H¨4¯;©;×+HÑ+HÐIò 	ˆMÙ)Øðà-Ø$7Ø/ñ	ð
 ñ‰Mð	ô '¸ÔGÐGrH   rp   )r<   r=   r>   r3   rf   r@   rF   rí  r"   r$   r   rr   rt   ru   s   @rI   rú  rú    si   ø„ ð
Ð1õ 
ð 7;ñ	Hà—|‘|ðHð Ÿ™ðHð "×,Ñ,¨tÑ3ð	Hð
 Ð+Ñ,ðHð 
!÷HrH   rú  c                   ó.   ‡ — e Zd Zdedefˆ fd„Zd„ Zˆ xZS )ÚGemma4TextMLPrY   r´   c                 óJ  •— t         ‰| �  «        |j                  |j                  z
  }||cxk\  xr dkD  nc }|j                  xr |}|| _        |j                  | _        |j                  |rdndz  | _        t        j                  | j                  | j                  d¬«      | _
        t        j                  | j                  | j                  d¬«      | _        t        j                  | j                  | j                  d¬«      | _        t        |j                     | _        y )Nr   r-   r/   Fr^   )re   rf   rü  Únum_kv_shared_layersÚuse_double_wide_mlprY   r”   r}  r   rh   r~  r  r€  r   r�  r  )rm   rY   r´   Úfirst_kv_shared_layer_idxÚis_kv_shared_layerr
  rn   s         €rI   rf   zGemma4TextMLP.__init__3  së   ø€ Ü‰ÑÔØ$*×$<Ñ$<¸v×?ZÑ?ZÑ$ZÐ!Ø&Ð*CÖGÀaÔGÐØ$×8Ñ8ÒOÐ=OÐØˆŒØ!×-Ñ-ˆÔØ!'×!9Ñ!9ÑBU¹QÐ[\Ñ!]ˆÔÜŸ™ 4×#3Ñ#3°T×5KÑ5KÐRWÔXˆŒÜ—y‘y ×!1Ñ!1°4×3IÑ3IÐPUÔVˆŒÜŸ™ 4×#9Ñ#9¸4×;KÑ;KÐRWÔXˆŒÜ˜V×5Ñ5Ñ6ˆ�rH   c                 óˆ   — | j                  | j                  | j                  |«      «      | j                  |«      z  «      }|S rp   rƒ  r„  s      rI   rr   zGemma4TextMLP.forward@  r…  rH   )r<   r=   r>   r2   rs   rf   rr   rt   ru   s   @rI   r  r  2  s   ø„ ð7Ð/ð 7¸Cõ 7örH   r  c                   óÒ   ‡ — e Zd ZU ej                  ed<   ddefˆ fd„Ze	 	 	 	 ddedz  de	d   de
dz  dedz  d	ed
ef   f
d„«       Z ej                  «       edd„«       «       Zˆ xZS )ÚGemma4TextRotaryEmbeddingrˆ  NrY   c                 ó†  •— t         ‰
| �  «        |j                  | _        |j                  | _        || _        t        |j                  «      | _        i | _        i | _	        | j                  D ]Ò  }| j
                  j                  |   }|€Œ|d   x}dk7  r
t        |   }n| j                  }|| j                  |<   || j                  |<   ||dœ}|dk(  r
|dk(  rd|d<    || j
                  fi |¤Ž\  }}	| j                  |› d�|d	¬
«       | j                  |› d�|j                  «       d	¬
«       t        | |› d�|	«       ŒÔ y )NrŠ  r‹  )r¥   rá  Úfull_attentionÚproportionalÚglobal_head_dimÚhead_dim_keyÚ	_inv_freqFr’   Ú_original_inv_freqÚ_attention_scaling)re   rf   r�  rŽ  r�  rY   ÚsetrÞ  Úrope_init_fnsrŠ  r�  r   r‘  rj   r“  Úsetattr)rm   rY   r¥   rá  Úrope_paramsrŠ  r”  Úrope_init_fn_kwargsÚcurr_inv_freqÚcurr_attention_scalingrn   s             €rI   rf   z"Gemma4TextRotaryEmbedding.__init__H  se  ø€ Ü‰ÑÔØ"(×"@Ñ"@ˆÔØ$*×$BÑ$BˆÔ!àˆŒÜ˜v×1Ñ1Ó2ˆÔØSUˆÔØ)+ˆŒà×*Ñ*ò 	UˆJØŸ+™+×5Ñ5°jÑAˆKØÐ"Øà(¨Ñ5Ð5�	¸)ÒCÜ2°9Ñ=‘à#×CÑC�à-9ˆD×Ñ˜zÑ*Ø)2ˆD�N‰N˜:Ñ&à-3À:Ñ"NÐØÐ-Ò-°)¸~Ò2MØ6GÐ# NÑ3á4@ÀÇÁÑ4dÐPcÑ4dÑ1ˆMÐ1Ø× Ñ  J <¨yÐ!9¸=ÐUZÐ Ô[Ø× Ñ  J <Ð/AÐ!BÀM×DWÑDWÓDYÐfkÐ ÔlÜ�D˜Z˜LÐ(:Ð;Ð=SÕTñ)	UrH   r¥   ztorch.devicerÑ   rá  r\   r•  c                 ó   — | j                   |   d   }t        | dd«      xs | j                  | j                  z  }d}d|t	        j
                  d|dt        j                  ¬«      j                  |t        j                  ¬«      |z  z  z  }||fS )	a|  
        Computes the inverse frequencies according to the original RoPE implementation
        Args:
            config ([`~transformers.PreTrainedConfig`]):
                The model configuration.
            device (`torch.device`):
                The device to use for initialization of the inverse frequencies.
            seq_len (`int`, *optional*):
                The current sequence length. Unused for this type of RoPE.
            layer_type (`str`, *optional*):
                The current layer type if the model has different RoPE parameters per type.
                Should not be used unless `config.layer_types is not None`

        Returns:
            Tuple of (`torch.Tensor`, `float`), containing the inverse frequencies for the RoPE embeddings and the
            post-processing scaling factor applied to the computed cos/sin (unused in this type of RoPE).
        r—  rº   Nr�   r   r-   r¨   r˜  r™  )rY   r¥   rÑ   rá  rœ  rx   rž  rˆ  s           rI   r‘  z9Gemma4TextRotaryEmbedding.compute_default_rope_parametersh  s•   € ð2 ×%Ñ% jÑ1°,Ñ?ˆÜ�f˜j¨$Ó/Òc°6×3EÑ3EÈ×IcÑIcÑ3cˆàÐð Ø”U—\‘\ ! S¨!´5·;±;Ô?×BÑBÈ&ÔX]×XcÑXcÐBÓdÐgjÑjÑkñ
ˆð Ð)Ð)Ð)rH   c                 óN  — t        | |› d�«      }t        | |› d�«      }|d d d …d f   j                  «       j                  |j                  d   dd«      j	                  |j
                  «      }|d d …d d d …f   j                  «       }t        |j
                  j                  t        «      r/|j
                  j                  dk7  r|j
                  j                  nd}t        |d¬	«      5  |j                  «       |j                  «       z  j                  dd
«      }	t        j                  |	|	fd¬«      }
|
j                  «       |z  }|
j                  «       |z  }d d d «       j	                  |j                  ¬«      j	                  |j                  ¬«      fS # 1 sw Y   ŒAxY w)Nr  r  r   r�   r/   r   r¡  Fr¢  r-   r§   r¨   )rš  rl   r¥  rË   rª   r¥   r¦  r§  rD   r)   r;  r@   r«   r­   r¬   r©   )rm   rØ   r®   rá  rˆ  r’  rª  Úposition_ids_expandedr£  r°  r±  r­   r¬   s                rI   rr   z!Gemma4TextRotaryEmbedding.forwardŒ  sl  € ô ˜4 J <¨yÐ!9Ó:ˆÜ# D¨Z¨LÐ8JÐ*KÓLÐà$ Tª1¨d ]Ñ3×9Ñ9Ó;×BÑBÀ<×CUÑCUÐVWÑCXÐZ\Ð^_Ó`×cÑcÐde×dlÑdlÓmÐØ ,ªQ°²a¨ZÑ 8× >Ñ >Ó @Ðä'1°!·(±(·-±-ÄÔ'EÈ!Ï(É(Ï-É-Ð[`ÒJ`�a—h‘h—m’mÐfkˆÜ¨¸UÔCñ 	0Ø&×,Ñ,Ó.Ð1F×1LÑ1LÓ1NÑN×YÑYÐZ[Ð]^Ó_ˆEÜ—)‘)˜U E˜N°Ô3ˆCØ—'‘'“)Ð/Ñ/ˆCØ—'‘'“)Ð/Ñ/ˆC÷		0ð �v‰v˜AŸG™GˆvÓ$ c§f¡f°1·7±7 fÓ&;Ð;Ð;÷	0ð 	0ús   Ã*A1FÆF$©NN)NNNNrp   )r<   r=   r>   r@   rF   rB   r2   rf   r³  r   rs   rD   rE   rl   r‘  r±   r   rr   rt   ru   s   @rI   r  r  E  s¬   ø… Ø�l‰lÓñUÐ/õ Uð@ à*.Ø+/Ø"Ø!%ñ	!*Ø  4Ñ'ð!*à˜Ñ(ð!*ð �t‘ð!*ð ˜$‘Jð	!*ð
 
ˆ~˜uÐ$Ñ	%ò!*ó ð!*ðF €U‡]�]ƒ_Øò<ó ó ô<rH   r  c                   ó  ‡ — e Zd ZdZdedefˆ fd„Z	 ddej                  dej                  dej                  dz  d	e	e
eej                  ej                  f   f   d
edz  dee   deej                  ej                  dz  f   fd„Zˆ xZS )ÚGemma4TextAttentionrÜ  rY   r´   c                 óØ  •— t         ‰| �  «        t        |d«      r|j                  |   nd | _        || _        || _        | j                  dk(  | _        | j                  r|j                  nd | _        | j                  s|j                  r|j                  n|j                  | _
        |j                  xr | j                   | _        | j                  r|j                  n|j                  }|j                  |z  | _        d| _        | j
                  j$                  | _        |j&                  dk7  | _        | j
                  j*                  t-        | j
                  dd«      z
  }||cxk\  xr dk\  nc | _        |j                  d | }| j.                   xr6 |t1        |«      dz
  |d d d…   j3                  |j                  |   «      z
  k(  | _        t7        j8                  |j:                  |j                  | j                  z  |j<                  ¬	«      | _        tA        | j                  |jB                  ¬
«      | _"        | j.                  s×tA        | j                  |jB                  ¬
«      | _#        tA        | j                  |jB                  d¬«      | _$        t7        j8                  |j:                  || j                  z  |j<                  ¬	«      | _%        | j                  s9t7        j8                  |j:                  || j                  z  |j<                  ¬	«      nd | _&        t7        j8                  |j                  | j                  z  |j:                  |j<                  ¬	«      | _'        y )NrÞ  Úsliding_attentionr�   ro  r	  r   r/   r�   r^   rß  Fr3  )(re   rf   rà  rÞ  rá  rY   r´   Ú
is_slidingÚsliding_windowr  rº   Úattention_k_eq_vÚuse_alternative_attentionÚnum_global_key_value_headsr¿  r¹   rË  rÇ  râ  Úuse_bidirectional_attentionrã  rü  rš  r  ÚlenÚindexÚstore_full_length_kvr   rh   r”   Úattention_biasrÂ   rw   r  rå  ræ  rç  rÃ   rÄ   rä  )rm   rY   r´   r¿  r  Úprev_layersrn   s         €rI   rf   zGemma4TextAttention.__init__¢  sÑ  ø€ Ü‰ÑÔÜ;BÀ6È=Ô;Y˜&×,Ñ,¨YÒ7Ð_cˆŒØˆŒØ"ˆŒØŸ/™/Ð-@Ñ@ˆŒØ7;·²˜f×3Ò3ÈDˆÔà6:·o²oÈ&×J`ÒJ`˜×.Ò.Ðfl×fuÑfuˆŒØ)/×)@Ñ)@Ò)XÈÏÉÐEXˆÔ&à15×1OÒ1OˆF×-Ò-ÐU[×UoÑUoð 	ð %+×$>Ñ$>ÐBUÑ$UˆÔ!ØˆŒØ!%§¡×!>Ñ!>ˆÔØ×;Ñ;¸uÑDˆŒð %)§K¡K×$AÑ$AÄGÈDÏKÉKÐYoÐqrÓDsÑ$sÐ!Ø"+Ð/HÖ"MÈAÔ"MˆÔØ×(Ñ(Ð)CÐ*CÐDˆØ(,×(?Ñ(?Ð$?ò %/ÀIÔQTÐU`ÓQaÐdeÑQeÐhsÙˆbˆDñi
ç
‰%�×"Ñ" 9Ñ-Ó
.ñR/ñ E/ˆÔ!ô —i‘iØ×Ñ × :Ñ :¸T¿]¹]Ñ JÐQW×QfÑQfô
ˆŒô $¨¯©¸6×;NÑ;NÔOˆŒð ×&Ò&Ü'¨D¯M©M¸v×?RÑ?RÔSˆDŒKÜ'¨¯©¸6×;NÑ;NÐ[`ÔaˆDŒKäŸ)™)Ø×"Ñ"Ð$7¸$¿-¹-Ñ$GÈf×NcÑNcôˆDŒKð
 ×5Ò5ô —	‘	˜&×,Ñ,Ð.AÀDÇMÁMÑ.QÐX^×XmÑXmÕnàð ŒKô —i‘iØ×&Ñ&¨¯©Ñ6¸×8JÑ8JÐQW×QfÑQfô
ˆ�rH   NrO   rÞ   rU   r;   rN   rF  r\   c                 óÄ  — |j                   d d }g |¢d‘| j                  ‘­}|\  }	}
| j                  |«      j                  |«      }| j	                  |«      }t        ||	|
d¬«      }|j                  dd«      }| j                  rI|| j                     \  }}|j                  |j                  «      }|j                  |j                  «      }n£| j                  |«      j                  |«      }| j                  � | j                  |«      j                  |«      n|}| j                  |«      }t        ||	|
d¬«      }|j                  dd«      }| j                  |«      }|j                  dd«      }|�,| j                  s |j                  ||| j                   «      \  }}| j"                  r||f|| j                  <   t%        j&                  | j(                  j*                  t,        «      } || ||||f| j.                  r| j0                  nd| j2                  | j4                  dœ|¤Ž\  }} |j6                  g |¢d‘­Ž j9                  «       }| j;                  |«      }||fS )Nr�   r-   )r¸  r/   rU  )rÆ  rÇ  r(  )rË   rº   rÂ   rÚ   rå  r»  r;  r  rá  rª   r¥   rÃ   rÄ   ræ  rç  Úupdater´   r/  r    ré  rY   rê  rÍ  rÊ  râ  rÇ  r(  rÎ   rÏ   rä  )rm   rO   rÞ   rU   r;   rN   rF  rë  rì   r­   r¬   rí   rî   rï   rì  rö   rõ   s                    rI   rr   zGemma4TextAttention.forwardÓ  sR  € ð $×)Ñ)¨#¨2Ð.ˆØ8˜Ð8 bÐ8¨$¯-©-Ñ8ˆà&‰ˆˆSà—{‘{ =Ó1×6Ñ6°|ÓDˆØ—{‘{ <Ó0ˆÜ+¨L¸#¸sÐRSÔTˆØ#×-Ñ-¨a°Ó3ˆð
 ×"Ò"Ø'7¸¿¹Ñ'HÑ$ˆJ˜à#Ÿ™ |×':Ñ':Ó;ˆJØ'Ÿ?™?¨<×+>Ñ+>Ó?‰LàŸ™ ]Ó3×8Ñ8¸ÓFˆJØLPÏKÉKÐLc˜4Ÿ;™; }Ó5×:Ñ:¸<ÔHÐisˆLàŸ™ ZÓ0ˆJÜ-¨j¸#¸sÐRSÔTˆJØ#×-Ñ-¨a°Ó3ˆJàŸ;™; |Ó4ˆLØ'×1Ñ1°!°QÓ7ˆLàÐ&¨t×/FÒ/FØ'6×'=Ñ'=¸jÈ,ÐX\×XfÑXfÓ'gÑ$ˆJ˜Ø×$Ò$Ø0:¸LÐ0HÐ˜TŸ_™_Ñ-ä(?×(MÑ(MØ�K‰K×,Ñ,Ô.Eó)
Ðñ %8ØØØØØð
%
ð /3¯mªm�D×*Ò*ÀØ—L‘LØ×.Ñ.ñ
%
ð ñ
%
Ñ!ˆ�\ð *�k×)Ñ)Ð;¨;Ð;¸Ò;×FÑFÓHˆØ—k‘k +Ó.ˆØ˜LÐ(Ð(rH   rp   )r<   r=   r>   r?   r2   rs   rf   r@   rF   rC   rD   rE   r   r"   r   rr   rt   ru   s   @rI   r$  r$  Ÿ  s·   ø„ ÙGð/
Ð/ð /
¸Cõ /
ðn )-ñ=)à—|‘|ð=)ð #Ÿ\™\ð=)ð Ÿ™ tÑ+ð	=)ð
 ˜s E¨%¯,©,¸¿¹Ð*DÑ$EÐEÑFð=)ð  ™ð=)ð Ð-Ñ.ð=)ð 
ˆu�|‰|˜UŸ\™\¨DÑ0Ð0Ñ	1÷=)rH   r$  c                   ó�   ‡ — e Zd ZdZdefˆ fd„Zdej                  dej                  dej                  dej                  fd„Zˆ xZ	S )	ÚGemma4TextExpertsz2Collection of expert weights stored as 3D tensors.rY   c                 óò  •— t         ‰| �  «        |j                  | _        |j                  | _        |j
                  | _        t        j                  t        j                  | j                  d| j                  z  | j                  «      «      | _        t        j                  t        j                  | j                  | j                  | j                  «      «      | _        t        |j                     | _        y )Nr-   )re   rf   Únum_expertsr”   Ú
hidden_dimÚmoe_intermediate_sizeÚintermediate_dimr   r}   r@   ÚemptyÚgate_up_projr€  r   r�  r  r!  s     €rI   rf   zGemma4TextExperts.__init__  s­   ø€ Ü‰ÑÔØ!×-Ñ-ˆÔØ ×,Ñ,ˆŒØ &× <Ñ <ˆÔÜŸL™L¬¯©°T×5EÑ5EÀqÈ4×K`ÑK`ÑG`Ðbf×bqÑbqÓ)rÓsˆÔÜŸ™¤e§k¡k°$×2BÑ2BÀDÇOÁOÐUY×UjÑUjÓ&kÓlˆŒÜ˜V×5Ñ5Ñ6ˆ�rH   rO   Útop_k_indexÚtop_k_weightsr\   c                 óf  — t        j                  |«      }t        j                  «       5  t         j                  j                  j                  || j                  ¬«      }|j                  ddd«      }t        j                  |j                  d¬«      d«      j                  «       }d d d «       D ]ð  }|d   }|| j                  k(  rŒt        j                  |   «      \  }}	||	   }
t        j                  j                  |
| j                  |   «      j                  dd¬«      \  }}| j                  |«      |z  }t        j                  j                  || j                   |   «      }|||	|d f   z  }|j#                  d|	|j%                  |j&                  «      «       Œò |S # 1 sw Y   �ŒxY w)N)Únum_classesr-   r/   r   )r�   éþÿÿÿr§   r�   )r@   Ú
zeros_liker±   r   r	   rm  r7  rã   ÚgreaterÚsumÚnonzerorW  ri   r<  Úchunkr  r€  Ú
index_add_rª   r©   )rm   rO   r=  r>  Úfinal_hidden_statesÚexpert_maskÚ
expert_hitÚ
expert_idxÚ	top_k_posÚ	token_idxÚcurrent_stateÚgateÚupÚcurrent_hidden_statess                 rI   rr   zGemma4TextExperts.forward   s™  € ô $×.Ñ.¨}Ó=ÐÜ�]‰]‹_ñ 	SÜŸ(™(×-Ñ-×5Ñ5°kÈt×O_ÑO_Ð5Ó`ˆKØ%×-Ñ-¨a°°AÓ6ˆKÜŸ™ {§¡¸8 Ó'DÀaÓH×PÑPÓRˆJ÷	Sð
 %ò 
	nˆJØ# A™ˆJØ˜T×-Ñ-Ò-ØÜ#(§;¡;¨{¸:Ñ/FÓ#GÑ ˆI�yØ)¨)Ñ4ˆMÜ—}‘}×+Ñ+¨M¸4×;LÑ;LÈZÑ;XÓY×_Ñ_Ð`aÐgiÐ_Ój‰HˆD�"Ø$(§K¡K°Ó$5¸Ñ$:Ð!Ü$&§M¡M×$8Ñ$8Ð9NÐPT×P^ÑP^Ð_iÑPjÓ$kÐ!Ø$9¸MÈ)ÐU^Ð`dÐJdÑ<eÑ$eÐ!Ø×*Ñ*¨1¨iÐ9N×9QÑ9QÐRe×RkÑRkÓ9lÕmð
	nð #Ð"÷#	Sñ 	Sús   ªA=F&Æ&F0)
r<   r=   r>   r?   r2   rf   r@   rF   rr   rt   ru   s   @rI   r5  r5    sN   ø„ á<ð7Ð/õ 7ð#à—|‘|ð#ð —\‘\ð#ð —|‘|ð	#ð
 
�‰÷#rH   r5  c                   óz   ‡ — e Zd Zdefˆ fd„Zdej                  deej                  ej                  f   fd„Zˆ xZ	S )ÚGemma4TextRouterrY   c                 ó(  •— t         ‰| �  «        || _        |j                  | _        | j                  dz  | _        |j
                  | _        t        | j                  | j                  d¬«      | _        t        j                  |j                  |j                  d¬«      | _        t        j                  t        j                  | j                  «      «      | _        t        j                  t        j                  |j                  «      «      | _        y )Nrƒ   Fr3  r^   )re   rf   rY   r”   Úscalar_root_sizer  ry   rw   r  r   rh   r7  Úprojr}   r@   r~   ÚscaleÚper_expert_scaler!  s     €rI   rf   zGemma4TextRouter.__init__<  s¼   ø€ Ü‰ÑÔØˆŒØ!×-Ñ-ˆÔØ $× 0Ñ 0°$Ñ 6ˆÔØ×&Ñ&ˆŒä! $×"2Ñ"2¸¿¹ÈUÔSˆŒ	Ü—I‘I˜f×0Ñ0°&×2DÑ2DÈ5ÔQˆŒ	Ü—\‘\¤%§*¡*¨T×-=Ñ-=Ó">Ó?ˆŒ
Ü "§¡¬U¯Z©Z¸×8JÑ8JÓ-KÓ LˆÕrH   rO   r\   c                 ó–  — | j                  |«      }|| j                  z  | j                  z  }| j                  |«      }t        j
                  j                  |dt        j                  ¬«      }t        j                  || j                  j                  d¬«      \  }}||j                  dd¬«      z  }|| j                  |   z  }|||fS )Nr�   rá   )rq  rx   Trh  )r  rW  rU  rV  r   r	   rè   r@   ré   ÚtopkrY   Útop_k_expertsrD  rX  )rm   rO   Úexpert_scoresÚrouter_probabilitiesr>  r=  s         rI   rr   zGemma4TextRouter.forwardH  sÂ   € ØŸ	™	 -Ó0ˆØ%¨¯
©
Ñ2°T×5JÑ5JÑJˆàŸ	™	 -Ó0ˆä!Ÿ}™}×4Ñ4°]ÈÔRW×R_ÑR_Ð4Ó`Ðô &+§Z¡ZØ Ø�k‰k×'Ñ'Øô&
Ñ"ˆ�{ð 	˜×*Ñ*¨r¸4Ð*Ó@Ñ@ˆð &¨×(=Ñ(=¸kÑ(JÑJˆà# ]°KÐ?Ð?rH   )
r<   r=   r>   r2   rf   r@   rF   rE   rr   rt   ru   s   @rI   rS  rS  ;  s>   ø„ ð
MÐ/õ 
Mð@ U§\¡\ð @°e¸E¿L¹LÈ%Ï,É,Ð<VÑ6W÷ @rH   rS  c                   ó0  ‡ — e Zd Zdeez  defˆ fd„Z	 	 	 	 	 	 ddej                  dej                  de	e
eej                  ej                  f   f   dz  dej                  d	ej                  dz  d
ej                  dz  dedz  dej                  fd„Zˆ xZS )ÚGemma4TextDecoderLayerrY   r´   c                 óú  •— t         ‰| �  «        || _        |j                  | _        || _        t        ||¬«      | _        t        ||«      | _        t        | j                  |j                  ¬«      | _        t        | j                  |j                  ¬«      | _        t        | j                  |j                  ¬«      | _        t        | j                  |j                  ¬«      | _        | j                  dt!        j"                  d«      «       |j$                  | _        | j$                  r t&        |j(                     | _        t-        j.                  | j                  | j$                  d¬«      | _        t-        j.                  | j$                  | j                  d¬«      | _        t        | j                  |j                  ¬«      | _        |j6                  | _        | j6                  r“t9        |«      | _        t=        |«      | _        t        | j                  |j                  ¬«      | _         t        | j                  |j                  ¬«      | _!        t        | j                  |j                  ¬«      | _"        y y )Nrñ  rò  Úlayer_scalarr/   Fr^   )#re   rf   rY   r”   r´   r$  rA  r  ró  rw   r  rô  rõ  rö  r÷  rj   r@   r~   Úhidden_size_per_layer_inputr   r�  r  r   rh   Úper_layer_input_gateÚper_layer_projectionÚpost_per_layer_input_normÚenable_moe_blockrS  Úrouterr5  ÚexpertsÚpost_feedforward_layernorm_1Úpost_feedforward_layernorm_2Úpre_feedforward_layernorm_2rÉ   s      €rI   rf   zGemma4TextDecoderLayer.__init__a  sÜ  ø€ Ü‰ÑÔØˆŒØ!×-Ñ-ˆÔØ"ˆŒÜ,°FÀiÔPˆŒÜ  ¨Ó3ˆŒÜ,¨T×-=Ñ-=À6×CVÑCVÔWˆÔÜ(5°d×6FÑ6FÈF×L_ÑL_Ô(`ˆÔ%Ü)6°t×7GÑ7GÈV×M`ÑM`Ô)aˆÔ&Ü*7¸×8HÑ8HÈf×NaÑNaÔ*bˆÔ'Ø×Ñ˜^¬U¯Z©Z¸«]Ô;à+1×+MÑ+MˆÔ(Ø×+Ò+Ü  ×!9Ñ!9Ñ:ˆDŒKÜ(*¯	©	°$×2BÑ2BÀD×DdÑDdÐkpÔ(qˆDÔ%Ü(*¯	©	°$×2RÑ2RÐTX×TdÑTdÐkpÔ(qˆDÔ%Ü-:¸4×;KÑ;KÐQW×QdÑQdÔ-eˆDÔ*à &× 7Ñ 7ˆÔØ× Ò Ü*¨6Ó2ˆDŒKÜ,¨VÓ4ˆDŒLÜ0=¸d×>NÑ>NÐTZ×TgÑTgÔ0hˆDÔ-Ü0=¸d×>NÑ>NÐTZ×TgÑTgÔ0hˆDÔ-Ü/<¸T×=MÑ=MÐSY×SfÑSfÔ/gˆDÕ,ð !rH   NrO   Úper_layer_inputr;   rÞ   rU   r®   rN   r\   c           
      ó&  — |}	| j                  |«      } | j                  d||||||dœ|¤Ž\  }}
| j                  |«      }|	|z   }|}	| j                  |«      }| j	                  |«      }| j
                  rš| j                  |«      }|	j                  d|	j                  d   «      }| j                  |«      \  }
}}| j                  |«      }| j                  |||«      }|j                  |	j                  «      }| j                  |«      }||z   }| j                  |«      }|	|z   }| j                  rP|}	| j                  |«      }| j!                  |«      }||z  }| j#                  |«      }| j%                  |«      }|	|z   }|| j&                  z  }|S )N)rO   rÞ   rU   r;   r®   rN   r�   rG   )rô  rA  rõ  rö  ró  rf  ri  rÎ   rË   rg  rk  rh  rj  r÷  rb  rc  r  rd  re  ra  )rm   rO   rl  r;   rÞ   rU   r®   rN   rF  r%  rë   Úhidden_states_1Úhidden_states_flatr>  r=  Úhidden_states_2s                   rI   rr   zGemma4TextDecoderLayer.forward}  s¾  € ð !ˆà×,Ñ,¨]Ó;ˆØ)˜4Ÿ>™>ð 
Ø'Ø 3Ø)Ø-Ø%Ø+ñ
ð ñ
Ñˆ�qð ×5Ñ5°mÓDˆØ  =Ñ0ˆà ˆØ×6Ñ6°}ÓEˆØŸ™ Ó/ˆà× Ò Ø"×?Ñ?ÀÓNˆOð "*×!1Ñ!1°"°h·n±nÀRÑ6HÓ!IÐØ,0¯K©KÐ8JÓ,KÑ)ˆAˆ}˜kØ"×>Ñ>Ð?QÓRˆOØ"Ÿl™l¨?¸KÈÓWˆOØ-×5Ñ5°h·n±nÓEˆOØ"×?Ñ?ÀÓPˆOð ,¨oÑ=ˆMà×7Ñ7¸ÓFˆØ  =Ñ0ˆà×+Ò+Ø$ˆHØ ×5Ñ5°mÓDˆMØ ŸK™K¨Ó6ˆMØ)¨OÑ;ˆMØ ×5Ñ5°mÓDˆMØ ×:Ñ:¸=ÓIˆMØ$ }Ñ4ˆMà˜×*Ñ*Ñ*ˆØÐrH   )NNNNNN)r<   r=   r>   r2   r3   rs   rf   r@   rF   rC   rD   rE   rí  r   rr   rt   ru   s   @rI   r_  r_  `  sÑ   ø„ ðhÐ/Ð2DÑDð hÐQTõ hð> )-ØPTØ,0Ø.2Ø04Ø(,ñ9à—|‘|ð9ð Ÿ™ð9ð ˜s E¨%¯,©,¸¿¹Ð*DÑ$EÐEÑFÈÑMð	9ð
 #Ÿ\™\ð9ð Ÿ™ tÑ+ð9ð ×&Ñ&¨Ñ-ð9ð  ™ð9ð 
�‰÷9rH   r_  c            	       óZ   ‡ — e Zd ZdZd	dedededefˆ fd„Zdej                  fˆ fd„Z	ˆ xZ
S )
ÚGemma4TextScaledWordEmbeddingz\
    This module overrides nn.Embeddings' forward by multiplying with embeddings scale.
    Únum_embeddingsÚembedding_dimÚpadding_idxÚembed_scalec                 ó„   •— t         ‰| �  |||«       || _        | j                  dt	        j
                  |«      d¬«       y )Nrv  Fr’   )re   rf   Úscalar_embed_scalerj   r@   rk   )rm   rs  rt  ru  rv  rn   s        €rI   rf   z&Gemma4TextScaledWordEmbedding.__init__¾  s;   ø€ Ü‰Ñ˜¨¸ÔDØ"-ˆÔØ×Ñ˜]¬E¯L©L¸Ó,EÐRWÐÕXrH   Ú	input_idsc                 ó‚   •— t         ‰| �  |«      | j                  j                  | j                  j
                  «      z  S rp   )re   rr   rv  rª   r   r©   )rm   ry  rn   s     €rI   rr   z%Gemma4TextScaledWordEmbedding.forwardÃ  s2   ø€ Ü‰w‰˜yÓ)¨D×,<Ñ,<×,?Ñ,?ÀÇÁ×@QÑ@QÓ,RÑRÐRrH   )r�   )r<   r=   r>   r?   rs   rl   rf   r@   rF   rr   rt   ru   s   @rI   rr  rr  ¹  sG   ø„ ññY sð Y¸3ð YÈSð YÐ_dõ Yð
S §¡÷ Sñ SrH   rr  c            	       óþ   ‡ — e Zd ZU eed<   dZdZg d¢ZddgZdZ	dZ
dZdZdZdZdZ ej"                  «       ˆ fd	„«       Zd
„ Zd„ Z	 	 	 ddedz  dedz  dedej0                  fˆ fd„Z	 	 	 ddedz  dedz  defd„Zˆ xZS )ÚGemma4PreTrainedModelrY   ÚmodelT)r_  rï  rI  r=  rN   r;   N)ÚimageÚtextÚvideoÚaudioc                 óÌ	  •— t         ‰| �  |«       t        |t        «      r t	        j
                  |j                  «       y t        |t        «      r©d}d}|j                  dz  }t        j                  ||z  «      t        |dz
  d«      z  }|t        j                  t        j                  |«      | z  «      z  }t	        j                  |j                   |j#                  d«      j#                  d«      «       y t        |t$        «      rJt	        j&                  |j(                  |j*                  «       t	        j,                  |j.                  «       y t        |t0        «      rŸ|j2                  j5                  «       D ]�  \  }}d|i}	|dk(  r|j6                  |   dk(  rd	|	d
<    ||j8                  fi |	¤Ž\  }
}t	        j                  t;        ||› d�«      |
«       t	        j                  t;        ||› d�«      |
«       Œƒ y t        |t<        «      r„|j6                  dk7  rt>        |j6                     n|j@                  } ||j8                  «      \  }}t	        j                  |jB                  |«       t	        j                  |jD                  |«       y t        |tF        «      r+t	        j&                  |jH                  |jJ                  «       y t        |tL        «      r?t	        j
                  |jN                  «       t	        j
                  |jP                  «       y t        |tR        «      r[| j8                  jT                  }t	        jV                  |jX                  d|¬«       t	        jV                  |jZ                  d|¬«       y t        |t\        «      r t	        j
                  |j^                  «       y t        |t`        «      r³|jb                  r§t	        j&                  |jd                  tg        d«       «       t	        j&                  |jh                  tg        d«      «       t	        j&                  |jj                  tg        d«       «       t	        j&                  |jl                  tg        d«      «       y t        |tn        «      rV|j8                  jp                  r?t	        j,                  |jr                  «       t	        j
                  |jt                  «       y y y )Nr�   r‘   r-   r/   r   rá  r  r  r  r  r  r  r‹  rU  )r…   Ústdra   );re   Ú_init_weightsr¦  rI  ÚinitÚones_rN  r�   r”   r™   rš   r›   r@   rœ   r�   Úcopy_rŽ   rž   r³   Ú	constant_r¶   r¸   Úzeros_rÈ   r  r  ÚitemsrŠ  rY   rš  r‡  r   r‘  rˆ  rŒ  rr  rv  rx  rS  rW  rX  r5  Úinitializer_rangeÚnormal_r<  r€  r_  ra  rX   rg   r`   rl   rb   rc   rd   ÚGemma4VisionModelÚstandardizeÚstd_biasÚ	std_scale)rm   rÂ  rŸ   r    r¡   r¢   rŽ   rá  r”  r  r  rë   Úrope_fnÚbuffer_valuerƒ  rn   s                  €rI   r„  z#Gemma4PreTrainedModel._init_weightsÜ  s—  ø€ ä‰Ñ˜fÔ%Ü�fÔ7Ô8Ü�J‰J�v×6Ñ6Õ7Ü˜Ô @ÔAØˆMØ#ˆMØ#×/Ñ/°1Ñ4ˆNÜ&*§h¡h¨}¸}Ñ/LÓ&MÔPSÐTbÐefÑTfÐhiÓPjÑ&jÐ#Ø*¬U¯Y©Y´u·|±|ÀNÓ7SÐWnÐVnÑ7nÓ-oÑoˆNÜ�J‰J�v×,Ñ,¨n×.FÑ.FÀqÓ.I×.SÑ.SÐTUÓ.VÕWÜ˜Ô 4Ô5Ü�N‰N˜6Ÿ>™>¨6×+KÑ+KÔLÜ�K‰K˜×,Ñ,Õ-Ü˜Ô 9Ô:Ø,2×,@Ñ,@×,FÑ,FÓ,Hò ^Ñ(�
˜LØ'3°ZÐ&@Ð#ØÐ!1Ò1°f×6FÑ6FÀzÑ6RÐVdÒ6dØ:KÐ'¨Ñ7á#/°·±Ñ#UÐATÑ#UÑ �˜qÜ—
‘
œ7 6¨j¨\¸Ð+CÓDÀmÔTÜ—
‘
œ7 6¨j¨\Ð9KÐ+LÓMÈ}Õ]ñ^ô ˜Ô ;Ô<ð ×#Ñ# yÒ0ô $ F×$4Ñ$4Ò5à×;Ñ;ð ñ
 & f§m¡mÓ4‰OˆL˜!Ü�J‰J�v—‘¨Ô5Ü�J‰J�v×/Ñ/°Õ>Ü˜Ô =Ô>Ü�N‰N˜6×-Ñ-¨v×/HÑ/HÕIÜ˜Ô 0Ô1Ü�J‰J�v—|‘|Ô$Ü�J‰J�v×.Ñ.Õ/Ü˜Ô 1Ô2Ø—+‘+×/Ñ/ˆCÜ�L‰L˜×,Ñ,°3¸CÕ@Ü�L‰L˜×)Ñ)°¸Ö=Ü˜Ô 6Ô7Ü�J‰J�v×*Ñ*Õ+Ü˜Ô 5Ô6¸6×;UÒ;UÜ�N‰N˜6×+Ñ+¬e°E«l¨]Ô;Ü�N‰N˜6×+Ñ+¬U°5«\Ô:Ü�N‰N˜6×,Ñ,¬u°U«|¨mÔ<Ü�N‰N˜6×,Ñ,¬e°E«lÕ;Ü˜Ô 1Ô2°v·}±}×7PÒ7PÜ�K‰K˜Ÿ™Ô(Ü�J‰J�v×'Ñ'Õ(ð 8QÐ2rH   c                 ó.   — | j                   j                  S rp   ©Ú
base_modelÚembed_tokens_per_layer©rm   s    rI   Úget_per_layer_input_embeddingsz4Gemma4PreTrainedModel.get_per_layer_input_embeddings  s   € Ø�‰×5Ñ5Ð5rH   c                 ó&   — || j                   _        y rp   r”  ©rm   rÅ  s     rI   Úset_per_layer_input_embeddingsz4Gemma4PreTrainedModel.set_per_layer_input_embeddings  s   € Ø16ˆ�‰Õ.rH   Únew_num_tokensÚpad_to_multiple_ofÚmean_resizingr\   c                 óR   •— t         ‰| �  |||¬«      }| j                  |||«       |S )N)rœ  r�  rž  )re   Úresize_token_embeddingsÚ_resize_per_layer_embeddings)rm   rœ  r�  rž  r  rn   s        €rI   r   z-Gemma4PreTrainedModel.resize_token_embeddings  s=   ø€ ô ™Ñ7Ø)Ø1Ø'ð 8ó 
ˆð
 	×)Ñ)¨.Ð:LÈmÔ\ØÐrH   c                 óœ  — | j                   | j                  j                  «       _        | j                  j                  «       j                  r| j                  «       }| j                  ||||«      }t        |d«      r|j                  }t        ||«       |j                  |j                  j                  «       | j                  |«       y y )NÚ_hf_hook)Ú
vocab_sizerY   Úget_text_configÚvocab_size_per_layer_inputrb  r˜  Ú_get_resized_embeddingsrà  r£  r4   Úrequires_grad_r   r|   r›  )rm   rœ  r�  rž  r–  Únew_embeddings_per_layerÚhooks          rI   r¡  z2Gemma4PreTrainedModel._resize_per_layer_embeddings%  s²   € ð DHÇ?Á?ˆ�‰×#Ñ#Ó%Ô@Ø�;‰;×&Ñ&Ó(×DÒDØ%)×%HÑ%HÓ%JÐ"Ø'+×'CÑ'CØ&¨Ð8JÈMó(Ð$ô Ð-¨zÔ:Ø-×6Ñ6�Ü"Ð#;¸TÔBØ$×3Ñ3Ð4J×4QÑ4Q×4_Ñ4_Ô`Ø×/Ñ/Ð0HÕIð ErH   )NNT)r<   r=   r>   r1   rB   Úbase_model_prefixÚsupports_gradient_checkpointingÚ_no_split_modulesÚ_skip_keys_device_placementÚ_supports_flash_attnÚ_supports_sdpaÚ_supports_flex_attnÚ_can_compile_fullgraphÚ_supports_attention_backendÚ_can_record_outputsÚinput_modalitiesr@   r±   r„  r˜  r›  rs   r‹   r   Ú	Embeddingr   r¡  rt   ru   s   @rI   r|  r|  Ç  só   ø… àÓØÐØ&*Ð#òÐð $5Ð6HÐ"IÐØÐØ€NØÐà!ÐØ"&ÐØÐØ:Ðà€U‡]�]ƒ_ó2)ó ð2)òh6ò7ð
 &*Ø)-Ø"ñ	à˜d™
ðð   $™Jðð ð	ð
 
�‰õð  &*Ø)-Ø"ñ	Jà˜d™
ðJð   $™JðJð ÷	JrH   r|  zAThe base Gemma 4 language model without a language modeling head.c                   óô  ‡ — e Zd ZU eed<   dZ eed¬«      ee	dœZ
defˆ fd„Zeee	 	 	 	 	 	 	 ddej                   dz  d	ej"                  dz  d
ej                   dz  dedz  dej&                  dz  dej"                  dz  dedz  dee   defd„«       «       «       Zdej"                  dz  dej"                  dz  dej"                  fd„Z	 ddej"                  dej"                  dz  dej"                  fd„Zˆ xZS )ÚGemma4TextModelrY   )r  r   )r.  )Úrouter_logitsrO   rP   c           
      ó  •— t         ‰| �  |«       |j                  | _        |j                  | _        t        |j                  |j                  | j                  | j                  j                  dz  ¬«      | _        t        j                  t        |j                  «      D �cg c]  }t        ||«      ‘Œ c}«      | _        t        |j                  |j                   ¬«      | _        t%        |«      | _        d| _        t+        | j                  j,                  «      | _        |j0                  | _        | j0                  rËt        |j2                  |j                  |j0                  z  | j                  |j0                  dz  ¬«      | _        d| _        t        j8                  |j                  |j                  |j0                  z  d¬«      | _        |j                  dz  | _        t        |j0                  |j                   ¬«      | _        g | _         tC        | j                  «      D ]K  \  }}|jD                  jF                  sŒ| j@                  jI                  dD �cg c]
  }d	|› d
|› �‘Œ c}«       ŒM | jK                  «        y c c}w c c}w )Nr^  )rv  rò  FgÍ;fž æ?r^   rƒ   )rÃ   rÄ   ræ  rç  zlayers.z.self_attn.)&re   rf   Úpad_token_idru  r¤  rr  r”   rY   Úembed_tokensr   rÿ  r¨  rü  r_  r   rw   r  r  r  rþ  Úgradient_checkpointingr  rÞ  Úunique_layer_typesrb  r¦  r–  Úper_layer_input_scalerh   Úper_layer_model_projectionÚ per_layer_model_projection_scaleÚper_layer_projection_normÚ"_keys_to_ignore_on_load_unexpectedÚ	enumeraterA  r  ÚextendÚ	post_init)rm   rY   r´   r­  ÚlayerÚnamern   s         €rI   rf   zGemma4TextModel.__init__B  s$  ø€ Ü‰Ñ˜Ô Ø!×.Ñ.ˆÔØ ×+Ñ+ˆŒô :Ø×Ñ˜v×1Ñ1°4×3CÑ3CÐQU×Q\ÑQ\×QhÑQhÐjmÑQmô
ˆÔô —m‘mÜHMÈf×NfÑNfÓHgÖh¸9Ô# F¨IÕ6Òhó
ˆŒô " &×"4Ñ"4¸&×:MÑ:MÔNˆŒ	Ü3°FÓ;ˆŒØ&+ˆÔ#Ü"% d§k¡k×&=Ñ&=Ó">ˆÔð
 ,2×+MÑ+MˆÔ(Ø×+Ò+Ü*GØ×1Ñ1Ø×(Ñ(¨6×+MÑ+MÑMØ× Ñ Ø"×>Ñ>ÀÑCô	+ˆDÔ'ð *3ˆDÔ&Ü.0¯i©iØ×"Ñ"Ø×(Ñ(¨6×+MÑ+MÑMØô/ˆDÔ+ð
 5;×4FÑ4FÈÑ4LˆDÔ1Ü-:¸6×;]Ñ;]Ðci×cvÑcvÔ-wˆDÔ*ð 35ˆÔ/Ü! $§+¡+Ó.ò 	‰HˆAˆuØ�‰×1Ó1Ø×7Ñ7×>Ñ>Ø@hÖi¸�w˜q˜c ¨T¨FÒ3Òiõð	ð 	�‰ÕùòI iùò@ js   Â"JÉJ

Nry  rU   r®   rN   r  Úper_layer_inputsÚ	use_cacherF  r\   c           
      ó<  — |du |duz  rt        d«      ‚|�|�t        d«      ‚|�| j                  |«      }| j                  r&|€| j                  ||«      }| j	                  ||«      }|r|€t        | j                  ¬«      }|€V|�|j                  «       nd}	t        j                  |j                  d   |j                  ¬«      |	z   }|j                  d«      }t        |x}
t        «      s)| j                  ||||dœ}t        di |¤Žt!        di |¤Žd	œ}
|}i }| j"                  D ]  }| j%                  |||«      ||<   Œ |j'                  d
t)        «       «      }t+        | j,                  d| j                  j.                   «      D ]\  \  }}|�|dd…dd…|dd…f   nd} |||f||| j                  j0                  |      |
| j                  j0                  |      ||dœ|¤Ž}Œ^ | j3                  |«      }t5        |||j7                  dd«      r|¬«      S d¬«      S )ak  
        per_layer_inputs (`torch.Tensor`, *optional*):
            Pre-computed per-layer input text embeddings of shape `(batch_size, sequence_length, num_hidden_layers,
            hidden_size_per_layer_input)`. When provided, these are used directly instead of being computed from `input_ids`
            via `get_per_layer_inputs()` in the text model. If calling the `forward` with `inputs_embeds` instead of `input_ids`,
            you should probably precompute them and forward them along `inputs_embeds`, otherwise recomputing them needs
            to reverse the main embedding, which is expensive.
        Nú:You must specify exactly one of input_ids or inputs_embedsú<You cannot specify per_layer_inputs if input_ids is provided©rY   r   r/   r¤   ©rY   r  rU   rN   r®   ©r  r&  r;   )r;   rÞ   rU   r®   rN   Úreturn_shared_kv_statesF)r  rN   r;   rG   )rk  r¼  rb  Úget_per_layer_inputsÚproject_per_layer_inputsr   rY   Úget_seq_lengthr@   r�   rË   r¥   rž   r¦  rC   r   r   r¾  rþ  Úpopr   rÄ  r   rü  rÞ  r  rR   Úget)rm   ry  rU   r®   rN   r  rÉ  rÊ  rF  Úpast_seen_tokensÚcausal_mask_mappingÚmask_kwargsrO   rÞ   rá  r;   r­  r  rl  s                      rI   rr   zGemma4TextModel.forwardr  s}  € ð, ˜Ð -°tÐ";Ò<ÜÐYÓZÐZàÐ Ð%5Ð%AÜÐ[Ó\Ð\àÐ Ø ×-Ñ-¨iÓ8ˆMà×+Ò+ØÐ'Ø#'×#<Ñ#<¸YÈÓ#VÐ Ø#×<Ñ<¸]ÐL\Ó]Ðá˜Ð0Ü*°$·+±+Ô>ˆOàÐØCRÐC^˜×=Ñ=Ô?ÐdeÐÜ Ÿ<™<¨×(;Ñ(;¸AÑ(>À}×G[ÑG[Ô\Ð_oÑoˆLØ'×1Ñ1°!Ó4ˆLô °Ð?Ð-ÄÔFð Ÿ+™+Ø!.Ø"0Ø#2Ø ,ñˆKô #5Ñ"C°{Ñ"CÜ%FÑ%UÈÑ%Uñ#Ðð &ˆØ ÐØ×1Ñ1ò 	gˆJØ.2¯o©o¸mÈ\Ð[eÓ.fÐ 
Ò+ð	gð "Ÿ:™:Ð&8¼(»*ÓEÐô !*¨$¯+©+Ð6U¸¿¹×8UÑ8UÐ*VÓ Wò 	ÑˆAˆ}Ø>NÐ>ZÐ.ªq²!°Qº¨zÒ:Ð`dˆOá)ØØð	ð "2Ø$7¸¿¹×8OÑ8OÐPQÑ8RÑ$SØ2°4·;±;×3JÑ3JÈ1Ñ3MÑNØ)Ø /ñ	ð ñ	‰Mð	ð Ÿ	™	 -Ó0ˆä,Ø+Ø+Ø17·±Ð<UÐW\Ô1]Ð-ô
ð 	
ð dhô
ð 	
rH   c                 óŠ  — | j                   st        d| j                  › �«      ‚|€­t        j                  «       5  |dd…dd…ddd…f   | j
                  j                  dddd…dd…f   | j                  j                  dz  z  k(  j                  d¬«      j                  «       dd…df   }	 |j                  |j                  dd «      }	 ddd«        | j                  |«      j                  g |j                  ¢| j                  j                  ‘| j                   ‘­Ž S # t        $ r t        d«      ‚w xY w# 1 sw Y   ŒnxY w)a  Compute the token-identity component of Per-Layer Embeddings (PLE).

        Looks up `input_ids` in `embed_tokens_per_layer` (a scaled embedding that multiplies
        by `sqrt(hidden_size_per_layer_input)`) and reshapes the packed output from
        `[batch, seq, num_hidden_layers * hidden_size_per_layer_input]` to
        `[batch, seq, num_hidden_layers, hidden_size_per_layer_input]`.

        If only `inputs_embeds` is provided (no `input_ids`), reverses the main embedding
        to recover `input_ids` for the PLE lookup.
        z}Attempting to call get_per_layer_inputs() from a model initialized with a config that does not support per-layer embeddings. Nr^  r
   r§   r-   a)  It seems like you tried to call `forward` from `inputs_embeds` without providing `input_ids`, and that the `inputs_embeds` you provided do not exactly match the embedding weights. Since Gemma4 needs to reverse the embedding to compute another embedding, make sure you provide exact `inputs_embeds`)rb  ÚRuntimeErrorrY   r@   r±   r¼  r   r”   ro  rE  rÚ   rË   r–  rÎ   rü  )rm   ry  r  s      rI   rÒ  z$Gemma4TextModel.get_per_layer_inputsÐ  sU  € ð ×/Ò/Üð*Ø*.¯+©+¨ð8óð ð ÐÜ—‘“ñ ð &¢aª¨D²! mÑ4Ø×,Ñ,×3Ñ3°D¸$ÂÂ1Ð4DÑEÈÏÉ×H_ÑH_ÐadÑHdÑdñe÷ ‘S˜Q�S“Zß‘W“Yšq !˜tñ%ð ðØ )§¡¨}×/BÑ/BÀ2ÀAÐ/FÓ G‘I÷ð$ >ˆt×*Ñ*¨9Ó5×=Ñ=ð 
Ø�_‰_ð
à�K‰K×)Ñ)ð
ð ×,Ñ,ò
ð 	
øô $ò Ü&ðróð ðú÷ð ús   »A1D9Â-D!Ä!D6Ä6D9Ä9Ec                 óV  — | j                   st        d| j                  › �«      ‚| j                  |«      | j                  z  } |j
                  g |j                  dd ¢| j                  j                  ‘| j                   ‘­Ž }| j                  |«      }|€|S ||z   | j                  z  S )aŒ  Compute the context-aware component of PLE and combine with token-identity.

        Projects `inputs_embeds` through `per_layer_model_projection` (Linear), scales by
        `1/sqrt(hidden_size)`, reshapes to `[batch, seq, num_layers, ple_dim]`, and normalizes
        with `per_layer_projection_norm` (RMSNorm).

        If `per_layer_inputs` (the token-identity component from `get_per_layer_inputs()`)
        is provided, combines both: `(context_projection + token_identity) * (1/sqrt(2))`.
        If `per_layer_inputs` is None (e.g. for multimodal inputs where input_ids are not
        available), returns just the context projection.
        z�Attempting to call project_per_layer_inputs() from a model initialized with a config that does not support per-layer embeddings. Nr�   )
rb  rÛ  rY   rÀ  rÁ  rÎ   rË   rü  rÂ  r¿  )rm   r  rÉ  rd  s       rI   rÓ  z(Gemma4TextModel.project_per_layer_inputsü  sÏ   € ð  ×/Ò/Üð2Ø26·+±+°ð@óð ð
  $×>Ñ>¸}ÓMÐPT×PuÑPuÑuÐØ;Ð3×;Ñ;ð  
Ø× Ñ   "Ð%ð 
à�K‰K×)Ñ)ð 
ð ×,Ñ,ò 
Ðð
  $×=Ñ=Ð>RÓSÐàÐ#Ø'Ð'à$Ð'7Ñ7¸4×;UÑ;UÑUÐUrH   )NNNNNNNrp   )r<   r=   r>   r2   rB   rµ  r+   rS  r_  r$  r´  rf   r*   r,   r%   r@   rí  rF   r   rA   r‹   r"   r$   rR   rr   rÒ  rÓ  rt   ru   s   @rI   r¸  r¸  8  s‰  ø… àÓØ Ðá'Ð(8ÀÔBØ/Ø)ñÐð.Ð/õ .ð`  ØØð .2Ø.2Ø04Ø(,Ø26Ø04Ø!%ñY
à×#Ñ# dÑ*ðY
ð Ÿ™ tÑ+ðY
ð ×&Ñ&¨Ñ-ð	Y
ð
  ™ðY
ð ×(Ñ(¨4Ñ/ðY
ð  Ÿ,™,¨Ñ-ðY
ð ˜$‘;ðY
ð Ð+Ñ,ðY
ð 
'òY
ó ó ó  ðY
ðv*
¨e¯l©l¸TÑ.Að *
ÐRW×R^ÑR^ÐaeÑReð *
Ðjo×jvÑjvó *
ð^ 15ñ!Và—|‘|ð!Vð  Ÿ,™,¨Ñ-ð!Vð 
�‰÷	!VrH   r¸  z>The base Gemma 4 language model with a language modeling head.c                   óx  ‡ — e Zd ZU ddiZddiZddgdgfiZeed<   dZdefˆ fd	„Z	e
e	 	 	 	 	 	 	 	 	 ddej                  d
z  dej                  d
z  dej                  d
z  ded
z  dej                   d
z  dej                  d
z  ded
z  deej                  z  dej                  d
z  dee   defd„«       «       Zˆ xZS )ÚGemma4ForCausalLMúlm_head.weightzmodel.embed_tokens.weightÚlm_headÚcolwise_gather_outputrO   rM   rY   r}  c                 óè   •— t         ‰| �  |«       t        |«      | _        |j                  | _        t        j                  |j                  |j                  d¬«      | _        | j                  «        y ©NFr^   )
re   rf   r¸  r}  r¤  r   rh   r”   rà  rÆ  r!  s     €rI   rf   zGemma4ForCausalLM.__init__(  sU   ø€ Ü‰Ñ˜Ô Ü$ VÓ,ˆŒ
Ø ×+Ñ+ˆŒÜ—y‘y ×!3Ñ!3°V×5FÑ5FÈUÔSˆŒð 	�‰ÕrH   Nry  rU   r®   rN   r  ÚlabelsrÊ  Úlogits_to_keeprÉ  rF  r\   c
                 ó4  —  | j                   d||||||	|dœ|
¤Ž}|j                  }t        |t        «      rt	        | d«      n|}| j                  |dd…|dd…f   «      }| j                  j                  �G|| j                  j                  z  }t        j                  |«      }|| j                  j                  z  }d}|� | j                  ||| j                  fi |
¤Ž}t        |||j                  |j                  |j                  |j                   ¬«      S )aí  
        per_layer_inputs (`torch.Tensor`, *optional*):
            Pre-computed per-layer input text embeddings of shape `(batch_size, sequence_length, num_hidden_layers,
            hidden_size_per_layer_input)`. When provided, these are used directly instead of being computed from `input_ids`
            via `get_per_layer_inputs()` in the text model. If calling the `forward` with `inputs_embeds` instead of `input_ids`,
            you should probably precompute them and forward them along `inputs_embeds`, otherwise recomputing them needs
            to reverse the main embedding, which is expensive.

        Example:

        ```python
        >>> from transformers import AutoTokenizer, Gemma4ForCausalLM

        >>> model = Gemma4ForCausalLM.from_pretrained("google/gemma-4-E2B-it")
        >>> tokenizer = AutoTokenizer.from_pretrained("google/gemma-4-E2B-it")

        >>> prompt = "What is your favorite condiment?"
        >>> inputs = tokenizer(prompt, return_tensors="pt")

        >>> # Generate
        >>> generate_ids = model.generate(inputs.input_ids, max_length=30)
        >>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
        "What is your favorite condiment?"
        ```)ry  rU   r®   rN   r  rÉ  rÊ  N)rL   rM   rN   rO   rP   r;   rG   )r}  r  r¦  rs   Úslicerà  rY   Úfinal_logit_softcappingr@   rä   Úloss_functionr¤  rK   rN   rO   rP   r;   )rm   ry  rU   r®   rN   r  rä  rÊ  rå  rÉ  rF  ÚoutputsrO   Úslice_indicesrM   rL   s                   rI   rr   zGemma4ForCausalLM.forward1  s"  € ðP 2<°·±ð 	2
ØØ)Ø%Ø+Ø'Ø-Øñ	2
ð ñ	2
ˆð  ×1Ñ1ˆä8BÀ>ÔSVÔ8Wœ˜~˜o¨tÔ4Ð]kˆØ—‘˜mªA¨}ºaÐ,?Ñ@ÓAˆØ�;‰;×.Ñ.Ð:Ø˜dŸk™k×AÑAÑAˆFÜ—Z‘Z Ó'ˆFØ˜dŸk™k×AÑAÑAˆFàˆØÐØ%�4×%Ñ% f¨f°d·o±oÑPÈÑPˆDä+ØØØ#×3Ñ3Ø!×/Ñ/Ø×)Ñ)Ø$×5Ñ5ô
ð 	
rH   )	NNNNNNNr   N)r<   r=   r>   Ú_tied_weights_keysÚ_tp_planÚ_pp_planr2   rB   r«  rf   r&   r%   r@   rí  rF   r   rA   r‹   rs   r"   r$   rK   rr   rt   ru   s   @rI   rÞ  rÞ     sN  ø… à*Ð,GÐHÐØÐ2Ð3€HØ˜_Ð-°¨zÐ:Ð;€HØÓØÐðÐ/õ ð Øð .2Ø.2Ø04Ø(,Ø26Ø*.Ø!%Ø-.Ø04ñE
à×#Ñ# dÑ*ðE
ð Ÿ™ tÑ+ðE
ð ×&Ñ&¨Ñ-ð	E
ð
  ™ðE
ð ×(Ñ(¨4Ñ/ðE
ð × Ñ  4Ñ'ðE
ð ˜$‘;ðE
ð ˜eŸl™lÑ*ðE
ð  Ÿ,™,¨Ñ-ðE
ð Ð+Ñ,ðE
ð 
&òE
ó ó ôE
rH   rÞ  r(  c           
      óP   ‡ — dt         dt         dt         dt         dt        f
ˆ fd„}|S )zL
    This creates uni/bidirectional attention mask with sliding window.
    Ú	batch_idxÚhead_idxÚq_idxÚkv_idxr\   c                 óP   •— ‰	\  }}||z
  }|dk\  ||k  z  }|dk  | |k  z  }||z  S r.  rG   )
rð  rñ  rò  ró  Úleft_window_sizeÚright_window_sizeÚdistÚ	left_maskÚ
right_maskr(  s
            €rI   Ú
inner_maskz0sliding_window_mask_function.<locals>.inner_mask€  sM   ø€ Ø.<Ñ+ÐÐ+à�v‰~ˆØ˜Q‘Y 4Ð*:Ñ#:Ñ;ˆ	Ø˜Q‘h D 5Ð+<Ñ#<Ñ=ˆ
Ø˜:Ñ%Ð%rH   )rs   r‹   )r(  rú  s   ` rI   Úsliding_window_mask_functionrû  {  s3   ø€ ð
&œcð &¬Sð &¼ð &Äcð &Ìdõ &ð ÐrH   c                   ó,  ‡ — e Zd ZU dZeed<   dZdZee	dœZ
defˆ fd„Zdej                  dej                  fd	„Zee ed
¬«      	 ddej                  dej                  dz  dee   deej                  ej*                  f   fd„«       «       «       Zˆ xZS )ÚGemma4AudioModelznAn audio encoder based on the [Universal Speech Model](https://huggingface.co/papers/2303.01037) architecture.rY   r  zmodel.audio_tower©rO   rP   c           	      óˆ  •— t         ‰| �  |«       || _        t        |«      | _        t        |«      | _        t        j                  t        |j                  «      D �cg c]  }t        ||«      ‘Œ c}«      | _        t        j                  |j                  |j                  d¬«      | _        | j#                  «        y c c}w )NTr^   )re   rf   rY   r
  Úsubsample_conv_projectionr�   Úrel_pos_encr   rÿ  r¨  rü  r=  r   rh   r”   Úoutput_proj_dimsÚoutput_projrÆ  rÉ   s      €rI   rf   zGemma4AudioModel.__init__–  s–   ø€ Ü‰Ñ˜Ô ØˆŒä)KÈFÓ)SˆÔ&Ü;¸FÓCˆÔÜ—m‘mÜBGÈ×H`ÑH`ÓBaÖb°YÔ˜f iÕ0Òbó
ˆŒô Ÿ9™9 V×%7Ñ%7¸×9PÑ9PÐW[Ô\ˆÔà�‰Õùò	 cs   ÁB?Úmask_4dr\   c                 ó€  — |j                   \  }}}}|j                  }| j                  j                  }| j                  j                  dz
  }| j                  j
                  }||z   dz
  |z  }	|	|z  }
|
|z
  }t        j                  |d|d|fd¬«      }|j                  |d|	||
«      }t        j                  |||fd¬«      }t        j                  |	|¬«      |z  }t        j                  ||z   |z   |¬«      }|dd…df   |ddd…f   z   }|dddd…ddd…f   j                  |dd|d«      }|j                  d|«      S )zÜ
        Convert a standard 4D attention mask `[batch_size, 1, seq_len, seq_len]` to the 5D blocked format
        `[batch_size, 1, num_blocks, chunk_size, context_size]` expected by the chunked local attention,
        r/   r   F)rÅ  r¤   Nr�   )rË   r¥   rY   r•   r–   r—   rÌ   rÍ   rÎ   r@   r�   r¥  Úgather)rm   r  rÐ   rë   rÑ   r¥   r¿   rÀ   rÁ   rÒ   Úpadded_seq_lenÚ
pad_amountÚmask_5dÚblock_startsÚoffsetsÚ
kv_indicess                   rI   Ú_convert_4d_mask_to_blocked_5dz/Gemma4AudioModel._convert_4d_mask_to_blocked_5d£  sN  € ð
 %,§M¡MÑ!ˆ
�A�w Ø—‘ˆà—[‘[×5Ñ5ˆ
ØŸ;™;×=Ñ=ÀÑAÐØ!Ÿ[™[×@Ñ@Ðà 
Ñ*¨QÑ.°:Ñ=ˆ
Ø# jÑ0ˆØ# gÑ-ˆ
ä—%‘%˜ ! Z°°JÐ!?ÀuÔMˆØ—/‘/ *¨a°¸ZÈÓXˆÜ—%‘%˜Ð"2Ð4FÐ!GÈuÔUˆä—|‘| J°vÔ>ÀÑKˆÜ—,‘,˜zÐ,<Ñ<Ð?QÑQÐZ`ÔaˆØ!¢! T 'Ñ*¨W°Tº1°WÑ-=Ñ=ˆ
Ø  dªA¨t²QÐ 6Ñ7×>Ñ>¸zÈ1ÈbÐR\Ð^`Óaˆ
à�~‰~˜b *Ó-Ð-rH   z&Encodes audio features to soft tokens.r5   NrU   rF  c           	      ó¶  — | j                  ||«      \  }}| j                  |«      }t        | j                  ||t	        | j                  j
                  dz
  | j                  j                  f«      ¬«      }|�| j                  |«      }| j                  d | j                  j                   D ]  } ||f||dœ|¤Ž}Œ | j                  |«      }t        ||¬«      S )Nr/   )rY   r  rU   Úand_mask_function)rU   rÞ   )r  rU   )r   r  r   rY   rû  r–   r—   r  r   rü  r  rT   )rm   r  rU   rF  rO   Úoutput_maskrÞ   Úencoder_layers           rI   rr   zGemma4AudioModel.forward¾  sì   € ð &*×%CÑ%CÀNÐTbÓ%cÑ"ˆ�{Ø"×.Ñ.¨}Ó=Ðä2Ø—;‘;Ø'Ø&Ü:Ø—‘×3Ñ3°aÑ7¸¿¹×9\Ñ9\Ð]óô	
ˆð Ð%Ø!×@Ñ@ÀÓPˆNà!Ÿ[™[Ð)H¨4¯;©;×+HÑ+HÐIò 	ˆMÙ)Øðà-Ø$7ñð ñ	‰Mð	ð ×(Ñ(¨Ó7ˆÜ%¸ÐVaÔbÐbrH   rp   )r<   r=   r>   r?   r0   rB   Úmain_input_namer«  r=  r³   r´  rf   r@   rF   r  r*   r,   r%   r"   r$   rE   rV   rr   rt   ru   s   @rI   rý  rý  ‹  sÐ   ø… ÙxàÓØ&€OØ+Ðà)Ø*ñÐð
Ð0õ ð.°e·l±lð .ÀuÇ|Á|ó .ð6  ØÙÐ!IÔJð /3ñcàŸ™ðcð Ÿ™ tÑ+ðcð Ð+Ñ,ð	cð
 
ˆu�|‰|˜U×-Ñ-Ð-Ñ	.òcó Kó ó  ôcrH   rý  c                   ó¨   ‡ — e Zd ZdZeZeedœZdefˆ fd„Z	e
e ed¬«      dej                  dej                  d	ee   d
efd„«       «       «       Zˆ xZS )r�  zThe Gemma 4 Vision Encoder.rþ  rY   c                 ó´  •— t         ‰| �  |«       t        |«      | _        t	        |«      | _        t        |«      | _        | j                  j                  rr| j                  dt        j                  | j                  j                  «      «       | j                  dt        j                  | j                  j                  «      «       | j                  «        y )Nr�  r�  )re   rf   rI  Úpatch_embedderrú  Úencoderrb  ÚpoolerrY   rŽ  rj   r@   r;  r”   rÆ  r!  s     €rI   rf   zGemma4VisionModel.__init__ê  s’   ø€ Ü‰Ñ˜Ô Ü7¸Ó?ˆÔÜ*¨6Ó2ˆŒÜ(¨Ó0ˆŒà�;‰;×"Ò"Ø× Ñ  ¬U¯[©[¸¿¹×9PÑ9PÓ-QÔRØ× Ñ  ¬e¯k©k¸$¿+¹+×:QÑ:QÓ.RÔSà�‰ÕrH   z1Encodes image pixels to soft tokens from patches.r5   r\  rO  rF  r\   c                 ó  — | j                   j                  }|j                  d   ||z  z  }|dk(  j                  d¬«      }| j	                  |||«      } | j
                  d|| |dœ|¤Ž}| j                  |j                  |||¬«      \  }	}
|	|
   }	| j                   j                  r8|	| j                  j                  «       z
  | j                  j                  «       z  }	|	j                  |j                  «      }	t        |	¬«      S )aà  
        pixel_values (`torch.FloatTensor` or `list[torch.FloatTensor]`):
            The images to encode. Either a single `[batch, channels, height, width]` tensor
            (all images same size) or a list of `[1, channels, height, width]` tensors (different sizes).
        pixel_position_ids (`torch.LongTensor` of shape `(batch_size, max_patches, 2)`):
            The patch positions as (x, y) coordinates in the image. Padding patches are indicated by (-1, -1).
        rA  r�   r§   )r  rU   rO  )rO   rO  rP  rx  r  rG   )rY   Úpooling_kernel_sizerË   ro  r  r  r  r  rŽ  r�  rl   r�  rª   r©   r   )rm   r\  rO  rF  r  rx  rP  r  rv  rO   Úpooler_masks              rI   rr   zGemma4VisionModel.forwardö  s  € ð  #Ÿk™k×=Ñ=ÐØ$×*Ñ*¨2Ñ.Ð3FÐI\Ñ3\Ñ]ˆà/°2Ñ5×:Ñ:¸rÐ:ÓBÐØ×+Ñ+¨LÐ:LÐN_Ó`ˆØ�—‘ð 
Ø'Ø-Ð-Ø1ñ
ð ñ	
ˆð &*§[¡[Ø ×2Ñ2Ø1Ø/Ø'ð	 &1ó &
Ñ"ˆ�{ð & kÑ2ˆð �;‰;×"Ò"Ø*¨T¯]©]×-@Ñ-@Ó-BÑBÀdÇnÁn×FZÑFZÓF\Ñ\ˆMØ%×(Ñ(¨×)<Ñ)<Ó=ˆä&¸ÔGÐGrH   )r<   r=   r>   r?   r3   rY   rï  rÛ  r´  rf   r*   r,   r%   r@   rA   rí  r"   r$   r   rr   rt   ru   s   @rI   r�  r�  á  s�   ø„ Ù%à€Fà1Ø+ñÐð

Ð1õ 
ð  ØÙÐ!TÔUð)Hà×'Ñ'ð)Hð "×,Ñ,ð)Hð Ð+Ñ,ð	)Hð
 
!ò)Hó Vó ó  ô)HrH   r�  c                   ój   ‡ — e Zd ZdZdeez  defˆ fd„Zdej                  dej                  fd„Z
ˆ xZS )ÚGemma4MultimodalEmbedderzQEmbeds token ids or soft tokens for multimodal content into language model space.Úmultimodal_configÚtext_configc                 óN  •— t         ‰| �  «        t        |d|j                  «      | _        |j
                  | _        |j                  | _        t        j                  | j                  | j                  d¬«      | _
        t        | j                  | j                  d¬«      | _        y )Nr  Fr^   r3  )re   rf   rš  r”   Úmultimodal_hidden_sizer  ry   Útext_hidden_sizer   rh   Úembedding_projectionrw   Úembedding_pre_projection_norm)rm   r  r  rn   s      €rI   rf   z!Gemma4MultimodalEmbedder.__init__(  s†   ø€ ô
 	‰ÑÔä&-Ð.?ÐASÐUf×UrÑUrÓ&sˆÔ#Ø$×1Ñ1ˆŒØ +× 7Ñ 7ˆÔÜ$&§I¡I¨d×.IÑ.IÈ4×K`ÑK`ÐglÔ$mˆÔ!Ü-:¸4×;VÑ;VÐ\`×\dÑ\dÐqvÔ-wˆÕ*rH   r  r\   c                 óF   — | j                  |«      }| j                  |«      S )a:  Embeds token ids or soft tokens for multimodal content into language model space.
        Args:
            inputs_embeds: A torch.Tensor containing the soft tokens to embed.
        Returns:
            A torch.Tensor of embeddings with shape `[batch_size, seq_len, self.config.text_config.hidden_size]`.
        )r#  r"  )rm   r  Úembs_normeds      rI   rr   z Gemma4MultimodalEmbedder.forward5  s%   € ð ×8Ñ8¸ÓGˆØ×(Ñ(¨Ó5Ð5rH   )r<   r=   r>   r?   r0   r3   r2   rf   r@   rF   rr   rt   ru   s   @rI   r  r  %  sA   ø„ Ù[ðxà,Ð/AÑAðxð &õxð6 U§\¡\ð 6°e·l±l÷ 6rH   r  rY   r  rN   Úblock_sequence_idsc                 óÞ   — | ||||dœ}t        di |¤Ž}t        di |¤ddi¤Ž\  }}	}	}	}
}	}|r|}nt        |||
|«      }t        di |¤t        |«      t	        | j
                  «      dœ¤Ž}||dœS )a‹  Create full_attention and sliding_attention masks with correct composition.

    For global (full attention) layers:  causal only (no bidirectional)
    For local (sliding window) layers:  AND(sliding_window, OR(causal, blockwise))

    Unlike Gemma 3 (which applies bidirectional attention on all layers), Gemma 4
    explicitly disables bidirectional attention on global attention layers.
    rÏ  r´   r   )Úor_mask_functionr  rÐ  rG   )r   r   r   r   r   r(  )rY   r  rU   rN   r®   r&  rÙ  Ú	full_maskÚ
early_exitrë   Ú	kv_lengthÚ	kv_offsetÚpadded_block_sequence_idsÚsliding_masks                 rI   Úcreate_masks_for_vision_modelr/  @  s¶   € ð" Ø&Ø(Ø*Ø$ñ€Kô #Ñ1 [Ñ1€Iô 4Nñ 4Ø
ñ4àò4Ñ0€J��1�a˜ A yñ Ø$6Ñ!ä$@Ø °	¸9ó%
Ð!ô &ñ Ø
ðä*Ð+DÓEÜ0°×1FÑ1FÓGó€Lð $Ø)ñð rH   Úmm_token_type_idsr¥   c                 ó  — | j                  |«      } | dk(  | dk(  z  }t        j                  |dd¬«      }d|d<   || z  }t        j                  |j	                  «       d¬«      dz
  }t        j
                  ||d«      }|S )Nr/   r-   r�   )ÚshiftsÚdimsFrS  r§   )rª   r@   ÚrollÚcumsumrs   rW  )r0  r¥   Ú	is_visionÚis_prev_visionÚnew_vision_startsÚvision_group_idsr&  s          rI   Úget_block_sequence_ids_for_maskr:  w  s‹   € Ø)×,Ñ,¨VÓ4Ðà" aÑ'Ð,=ÀÑ,BÑC€IÜ—Z‘Z 	°!¸"Ô=€NØ"€N�6ÑØ! ^ OÑ3ÐÜ—|‘|Ð$5×$9Ñ$9Ó$;ÀÔCÀaÑGÐÜŸ™ YÐ0@À"ÓEÐØÐrH   zŒ
    The base Gemma 4 model comprising a vision backbone, an audio backbone, and a language model without a
    language modeling head.
    c            $       óê  ‡ — e Zd ZdZdefˆ fd„Ze ed¬«      	 d dej                  dej                  dz  d	ee   d
efd„«       «       Z	 	 d!dej                  dz  dej                  dz  d
eej                   ej                   ej                   f   fd„Zeee	 	 	 	 	 	 	 	 	 	 	 	 	 	 d"dej                  dz  dej                  dz  dej                  dz  dej                  dz  dej&                  dz  dej&                  dz  dej                  dz  dedz  dej                  dz  dej                  dz  dedz  dej                  dz  dej                  dz  dej&                  dz  d	ee   d
ef d„«       «       «       Zd„ Zd„ Ze ed¬«      dej&                  dej&                  d	ee   d
eez  fd„«       «       Ze ed¬«      	 d dej                  dej                  dz  d	ee   d
efd„«       «       Zˆ xZS )#ÚGemma4ModelFrY   c                 ó’  •— t         ‰| �  |«       |j                  �t        j                  |j                  «      nd | _        |j                  j                  | _        t        j                  |j                  ¬«      }|| _        |j                  j                  | _	        |j                  �t        j                  |j                  «      nd | _        |j                  � t        |j                  |j                  «      nd | _        |j                  � t        |j                  |j                  «      nd | _        | j                  «        y )NrÎ  )re   rf   Úvision_configr.   Úfrom_configÚvision_towerr  r¤  Úlanguage_modelr¦  Úaudio_configÚaudio_towerr  Úembed_visionÚembed_audiorÆ  )rm   rY   rA  rn   s      €rI   rf   zGemma4Model.__init__�  s  ø€ Ü‰Ñ˜Ô ØKQ×K_ÑK_ÐKkœI×1Ñ1°&×2FÑ2FÔGÐquˆÔØ ×,Ñ,×7Ñ7ˆŒä"×.Ñ.°f×6HÑ6HÔIˆØ,ˆÔØ*0×*<Ñ*<×*WÑ*WˆÔ'ØIO×I\ÑI\ÐIhœ9×0Ñ0°×1DÑ1DÔEÐnrˆÔð ×#Ñ#Ð/ô % V×%9Ñ%9¸6×;MÑ;MÔNàð 	Ôð ×"Ñ"Ð.ô % V×%8Ñ%8¸&×:LÑ:LÔMàð 	Ôð
 	�‰ÕrH   zOProjects the last hidden state from the vision model into language model space.r5   Nr\  Úimage_position_idsrF  r\   c                 óv   —  | j                   d||dœ|¤Ž}|j                  }| j                  |¬«      |_        |S )zÝ
        image_position_ids (`torch.LongTensor` of shape `(batch_size, max_patches, 2)`, *optional*):
            The patch positions as (x, y) coordinates in the image. Padding patches are indicated by (-1, -1).
        ©r\  rO  ©r  rG   )r@  r  rD  Úpooler_output)rm   r\  rF  rF  Úvision_outputsr  s         rI   Úget_image_featureszGemma4Model.get_image_features¢  sV   € ð +˜×*Ñ*ð 
Ø%Ø1ñ
ð ñ
ˆð
 +×<Ñ<ÐØ'+×'8Ñ'8ÐGXÐ'8Ó'YˆÔ$ØÐrH   ry  r  c                 ó&  — |�M|| j                   j                  k(  }|| j                   j                  k(  }|| j                   j                  k(  }�n>| | j	                  «       t        j                  | j                   j                  t
        j                  |j                  ¬«      «      k(  j                  d«      }| | j	                  «       t        j                  | j                   j                  t
        j                  |j                  ¬«      «      k(  j                  d«      }| | j	                  «       t        j                  | j                   j                  t
        j                  |j                  ¬«      «      k(  j                  d«      }|||fS )a‹  
        Obtains mask for multimodal placeholders (replaced by soft tokens) and hard text tokens.

        Masks will be obtained from `mm_token_type_ids`, `input_ids`, or `inputs_embeds` as available and in that
        precedence order. If passing `input_ids` or `inputs_embeds`, the image mask will be derived using
        `config.image_token_id`. Same goes for audio and video masks

        Args:
            input_ids: A tensor containing the hard token IDs from the text tokenizer.
            inputs_embeds: A tensor containing the embeddings for all hard text tokens.

        Returns:
            image_mask, video_mask, audio_mask
        )r©   r¥   r�   )
rY   Úimage_token_idÚvideo_token_idÚaudio_token_idÚget_input_embeddingsr@   rk   rn  r¥   ro  )rm   ry  r  Úspecial_image_maskÚspecial_video_maskÚspecial_audio_masks         rI   Úget_placeholder_maskz Gemma4Model.get_placeholder_mask·  sP  € ð& Ð Ø!*¨d¯k©k×.HÑ.HÑ!HÐØ!*¨d¯k©k×.HÑ.HÑ!HÐØ!*¨d¯k©k×.HÑ.HÑ!HÒð Ø.�4×,Ñ,Ó.Ü—L‘L §¡×!;Ñ!;Ä5Ç:Á:ÐVc×VjÑVjÔkóñ÷ ‰c�"‹gð ð Ø.�4×,Ñ,Ó.Ü—L‘L §¡×!;Ñ!;Ä5Ç:Á:ÐVc×VjÑVjÔkóñ÷ ‰c�"‹gð ð Ø.�4×,Ñ,Ó.Ü—L‘L §¡×!;Ñ!;Ä5Ç:Á:ÐVc×VjÑVjÔkóñ÷ ‰c�"‹gð ð "Ð#5Ð7IÐIÐIrH   Úpixel_values_videosr  rU   r  r®   rN   r0  rÊ  Úvideo_position_idsrÉ  c                 ó&  — |du |
duz  rt        d«      ‚|�|�t        d«      ‚| j                  ||
«      \  }}}||z  |z  }d}|
€[|j                  «       }t        j                  || j
                  j                  j                  |«      } | j                  «       |«      }
|€Ë| j
                  j                  «       j                  r§| j                  j                  j                  | j
                  j                  j                  dd…f   }|j                  |
j                  «      }t        j                  |d   |j!                  ddd«      |
«      }| j                  j#                  ||«      }|��| j%                  ||d¬«      j&                  }|j                  |
j                  |
j(                  «      }|j+                  «       }|j-                  d«      j/                  |
«      j                  |
j                  «      }t1        |
|   j3                  «       |j3                  «       k(  d	|› d
|j4                  d   › �«       |
j7                  |j                  |
j                  «      |j                  |
j                  «      «      }
|��| j9                  ||d¬«      j&                  }|j                  |
j                  |
j(                  «      }|j+                  «       }|j-                  d«      j/                  |
«      j                  |
j                  «      }t1        |
|   j3                  «       |j3                  «       k(  d|› d
|j4                  d   › �«       |
j7                  |j                  |
j                  «      |j                  |
j                  «      «      }
|��+|��(| j;                  ||d¬«      }|j&                  }|j<                  }||j                  |j                  «         }|j+                  «       }|j-                  d«      j/                  |
«      j                  |
j                  «      }t1        |
|   j3                  «       |j3                  «       k(  d|› d
|j4                  d   |j4                  d   z  › �«       |
j7                  |j                  |
j                  «      |j                  |
j                  «      «      }
|€V|�|j?                  «       nd}t        j@                  |
j4                  d   |
j                  ¬«      |z   }|j-                  d«      }tC        |x} tD        «      s}| j
                  j                  «       |
|||dœ}!| j
                  j                  «       }"|"jF                  dk(  }#|#r'|	�%tI        |	|
j                  ¬«      }$tK        dd|$i|!¤Ž} ntM        di |!¤Ž}  | j                  d|| |||
|ddœ|¤Ž}%tO        |%jP                  |%jR                  |%jT                  |%jV                  |�nd|�nd|%jX                  ¬«      S )áK  
        input_features_mask (`torch.FloatTensor]` of shape `(num_images, seq_length)`):
            The attention mask for the input audio.
        image_position_ids (`torch.LongTensor` of shape `(batch_size, max_patches, 2)`, *optional*):
            2D patch position coordinates from the image processor, with `(-1, -1)` indicating padding.
            Passed through to the vision encoder for positional embedding computation.
        video_position_ids (`torch.LongTensor` of shape `(num_videos, num_frames, max_patches, 2)`, *optional*):
            2D patch position coordinates from the video processor, with `(-1, -1)` indicating padding.
            Passed through to the vision encoder for positional embedding computation.
        per_layer_inputs (`torch.Tensor`, *optional*):
            Pre-computed per-layer input text embeddings of shape `(batch_size, sequence_length, num_hidden_layers,
            hidden_size_per_layer_input)`. When provided, these are used directly instead of being computed from `input_ids`
            via `get_per_layer_inputs()` in the text model. If calling the `forward` with `inputs_embeds` instead of `input_ids`,
            you should probably precompute them and forward them along `inputs_embeds`, otherwise recomputing them needs
            to reverse the main embedding, which is expensive.
        NrÌ  rÍ  r¦   r/   r�   T)Úreturn_dictz6Image features and image tokens do not match, tokens: z, features: r   z6Video features and video tokens do not match, tokens: z6Audio features and audio tokens do not match, tokens: r¤   rÏ  Úvisionr&  )rÉ  rU   r®   rN   r  rÊ  rZ  )r  rN   rO   rP   r9   r:   r;   rG   )-rk  rU  r“  r@   rW  rY   r  r»  rQ  r¥  rb  rA  r¼  r   rª   r¥   rÚ   rÒ  rL  rJ  r©   rD  rž   Ú	expand_asr(   ÚnumelrË   Úmasked_scatterÚget_video_featuresÚget_audio_featuresrU   rÔ  r�   r¦  rC   r,  r:  r/  r   r8   r  rN   rO   rP   r;   )&rm   ry  r\  rV  r  rU   r  r®   rN   r0  r  rÊ  rF  rW  rÉ  rF  Ú
image_maskÚ
video_maskÚ
audio_maskÚmultimodal_maskÚllm_input_idsÚpad_embeddingÚllm_inputs_embedsÚimage_featuresÚn_image_tokensÚvideo_featuresÚn_video_tokensÚaudio_outputÚaudio_featuresÚaudio_mask_from_encoderÚn_audio_tokensr×  rØ  rÙ  r  Ú	use_bidirr&  rê  s&                                         rI   rr   zGemma4Model.forwardä  s  € ðJ ˜Ð -°tÐ";Ò<ÜÐYÓZÐZàÐ Ð%5Ð%AÜÐ[Ó\Ð\à-1×-FÑ-FÀyÐR_Ó-`Ñ*ˆ
�J 
Ø$ zÑ1°JÑ>ˆð ˆØÐ Ø%ŸO™OÓ-ˆMÜ!ŸK™K¨¸¿¹×9PÑ9P×9]Ñ9]Ð_lÓmˆMØ7˜D×5Ñ5Ó7¸ÓFˆMàÐ#¨¯©×(CÑ(CÓ(E×(aÒ(aØ ×/Ñ/×<Ñ<×CÑCÀDÇKÁK×D[ÑD[×DhÑDhÒjkÐDkÑlˆMØ-×0Ñ0°×1EÑ1EÓFˆOÜ %§¡¨O¸IÑ,FÈ×HZÑHZÐ[\Ð^_ÐacÓHdÐfsÓ tÐØ#×2Ñ2×GÑGÈÐWhÓiÐð Ñ#Ø!×4Ñ4°\ÐCUÐcgÐ4Óh×vÑvˆNØ+×.Ñ.¨}×/CÑ/CÀ]×EXÑEXÓYˆNð (Ÿ^™^Ó-ˆNØ#×-Ñ-¨bÓ1×;Ñ;¸MÓJ×MÑMÈm×NbÑNbÓcˆJÜ"Ø˜jÑ)×/Ñ/Ó1°^×5IÑ5IÓ5KÑKØHÈÐHXð YØ"×(Ñ(¨Ñ+Ð,ð.ôð *×8Ñ8Ø—‘˜m×2Ñ2Ó3°^×5FÑ5FÀ}×G[ÑG[Ó5\óˆMð Ñ*Ø!×4Ñ4Ø#Ð%7ÀTð 5ó ç‰mð ð ,×.Ñ.¨}×/CÑ/CÀ]×EXÑEXÓYˆNð (Ÿ^™^Ó-ˆNØ#×-Ñ-¨bÓ1×;Ñ;¸MÓJ×MÑMÈm×NbÑNbÓcˆJÜ"Ø˜jÑ)×/Ñ/Ó1°^×5IÑ5IÓ5KÑKØHÈÐHXð YØ"×(Ñ(¨Ñ+Ð,ð.ôð *×8Ñ8Ø—‘˜m×2Ñ2Ó3°^×5FÑ5FÀ}×G[ÑG[Ó5\óˆMð
 Ñ%Ð*=Ñ*IØ×2Ñ2°>ÐCVÐdhÐ2ÓiˆLØ)×7Ñ7ˆNØ&2×&AÑ&AÐ#ð
 ,Ð,C×,FÑ,FÀ~×G\ÑG\Ó,]Ñ^ˆNà'Ÿ^™^Ó-ˆNØ#×-Ñ-¨bÓ1×;Ñ;¸MÓJ×MÑMÈm×NbÑNbÓcˆJÜ"Ø˜jÑ)×/Ñ/Ó1°^×5IÑ5IÓ5KÑKØHÈÐHXð YØ"×(Ñ(¨Ñ+¨n×.BÑ.BÀ1Ñ.EÑEÐFðHôð *×8Ñ8Ø—‘˜m×2Ñ2Ó3°^×5FÑ5FÀ}×G[ÑG[Ó5\óˆMð
 ÐØCRÐC^˜×=Ñ=Ô?ÐdeÐÜ Ÿ<™<¨×(;Ñ(;¸AÑ(>À}×G[ÑG[Ô\Ð_oÑoˆLØ'×1Ñ1°!Ó4ˆLä°Ð?Ð-ÄÔFàŸ+™+×5Ñ5Ó7Ø!.Ø"0Ø#2Ø ,ñˆKð Ÿ+™+×5Ñ5Ó7ˆKØ#×?Ñ?À8ÑKˆIáÐ.Ð:Ü%DÐEVÐ_l×_sÑ_sÔ%tÐ"Ü&Cñ 'Ø'9ð'à!ñ'Ñ#ô '@Ñ&NÀ+Ñ&NÐ#à%�$×%Ñ%ð 	
Ø-Ø.Ø%Ø+Ø'ØØñ	
ð ñ	
ˆô )Ø%×7Ñ7Ø#×3Ñ3Ø!×/Ñ/Ø×)Ñ)Ø2>Ð2J¡ÐPTØ2@Ð2L¡ÐRVØ$×5Ñ5ô
ð 	
rH   c                 ó.   — | j                   j                  S rp   ©rA  r–  r—  s    rI   r˜  z*Gemma4Model.get_per_layer_input_embeddings�	  s   € Ø×"Ñ"×9Ñ9Ð9rH   c                 ó&   — || j                   _        y rp   rr  rš  s     rI   r›  z*Gemma4Model.set_per_layer_input_embeddings�	  s   € Ø5:ˆ×ÑÕ2rH   zPProjects the last hidden state from the audio encoder into language model space.c                 ó¢   — | j                   €t        d«      ‚ | j                   ||fddi|¤Ž}| j                  |j                  ¬«      |_        |S )a0  
        input_features (`torch.FloatTensor]` of shape `(num_images, seq_length, num_features)`):
            The tensors corresponding to the input audio.
        input_features_mask (`torch.FloatTensor]` of shape `(num_images, seq_length)`):
            The attention mask for the input audio.
        z•Audio features were requested, but the model was initialized without an audio_config. Cannot process audio without an audio tower and audio embedder.rZ  TrI  )rC  rk  rE  r  rJ  )rm   r  r  rF  Úaudio_outputss        rI   r`  zGemma4Model.get_audio_features“	  sh   € ð ×ÑÐ#ÜðRóð ð
 )˜×(Ñ(¨Ð9LÑiÐZ^ÐiÐbhÑiˆØ&*×&6Ñ&6À]×EdÑEdÐ&6Ó&eˆÔ#àÐrH   zQProjects the last hidden state from the vision encoder into language model space.c                 ó¾   — |j                  dd«      }|j                  dd«      } | j                  d||dœ|¤Ž}|j                  }| j                  |¬«      |_        |S )a9  
        video_position_ids (`torch.LongTensor` of shape `(num_videos, num_frames, max_patches, 2)`, *optional*):
            2D patch position coordinates from the video processor, with `(-1, -1)` indicating padding.
            Passed through to the vision encoder for positional embedding computation.
        r   r/   rH  rI  rG   )Úflattenr@  r  rD  rJ  )rm   rV  rW  rF  rK  r  s         rI   r_  zGemma4Model.get_video_features¬	  s|   € ð 2×9Ñ9¸!¸QÓ?ÐØ/×7Ñ7¸¸1Ó=ÐØ*˜×*Ñ*ð 
Ø,Ø1ñ
ð ñ
ˆð
 +×<Ñ<ÐØ'+×'8Ñ'8ÐGXÐ'8Ó'YˆÔ$ØÐrH   rp   r"  )NNNNNNNNNNNNNN)r<   r=   r>   Úaccepts_loss_kwargsr1   rf   r&   r%   r@   rA   rí  r"   r$   r   rL  rE   rV   rU  r*   rF   r   r‹   r8   rr   r˜  r›  rT   r`  r_  rt   ru   s   @rI   r<  r<  ƒ  s7  ø„ ð  Ðð˜|õ ð* ÙÐ!rÔsð 7;ñà×'Ñ'ðð "×,Ñ,¨tÑ3ðð Ð+Ñ,ð	ð
 
$òó tó ðð* .2Ø26ñ+Jà×#Ñ# dÑ*ð+Jð ×(Ñ(¨4Ñ/ð+Jð 
ˆu×Ñ ×!1Ñ!1°5×3CÑ3CÐCÑ	Dó	+JðZ  ØØð .2Ø15Ø8<Ø37Ø.2Ø37Ø04Ø(,Ø59Ø26Ø!%Ø6:Ø6:Ø04ñd
à×#Ñ# dÑ*ðd
ð ×'Ñ'¨$Ñ.ðd
ð #×.Ñ.°Ñ5ð	d
ð
 ×)Ñ)¨DÑ0ðd
ð Ÿ™ tÑ+ðd
ð #Ÿ\™\¨DÑ0ðd
ð ×&Ñ&¨Ñ-ðd
ð  ™ðd
ð !×+Ñ+¨dÑ2ðd
ð ×(Ñ(¨4Ñ/ðd
ð ˜$‘;ðd
ð "×,Ñ,¨tÑ3ðd
ð "×,Ñ,¨tÑ3ðd
ð  Ÿ,™,¨Ñ-ðd
ð  Ð+Ñ,ð!d
ð" 
#ò#d
ó ó ó  ðd
òL:ò;ð ÙÐ!sÔtðàŸ™ðð #Ÿ\™\ðð Ð+Ñ,ð	ð
 
Ð'Ñ	'òó uó ðð. ÙÐ!tÔuð 7;ñà"×.Ñ.ðð "×,Ñ,¨tÑ3ðð Ð+Ñ,ð	ð
 
$òó vó ôrH   r<  z…
    The base Gemma 4 model comprising a vision backbone, an audio backbone, a language model, and a language modeling
    head.
    c            '       óf  ‡ — e Zd ZddiZdZdZdefˆ fd„Ze	 d!de	j                  d	e	j                  dz  d
ee   fd„«       Zee	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d"de	j                  dz  de	j                  dz  de	j                  dz  de	j                  dz  de	j                   dz  de	j                   dz  de	j                  dz  d	e	j                  dz  de	j                  dz  dedz  de	j                  dz  de	j                  dz  de	j                  dz  dedz  dee	j                   z  de	j                   dz  d
ee   def$d„«       «       Z	 	 	 	 	 	 	 	 	 	 	 	 	 d#ˆ fd„	Zd„ Zd„ Ze	 	 d$dede	j                   de	j                   dz  dedz  de	j                   dz  de	j                   dz  dedz  defd „«       Zˆ xZS )%ÚGemma4ForConditionalGenerationrß  z(model.language_model.embed_tokens.weightFr}  rY   c                 óî   •— t         ‰| �  |«       t        |«      | _        t	        j
                  |j                  j                  |j                  j                  d¬«      | _	        | j                  «        y rã  )re   rf   r<  r}  r   rh   r  r”   r¤  rà  rÆ  r!  s     €rI   rf   z'Gemma4ForConditionalGeneration.__init__Ð	  sS   ø€ Ü‰Ñ˜Ô Ü  Ó(ˆŒ
Ü—y‘y ×!3Ñ!3×!?Ñ!?À×ASÑAS×A^ÑA^ÐejÔkˆŒØ�‰ÕrH   Nr\  rF  rF  c                 ó>   —  | j                   j                  ||fi |¤ŽS )a-  
        image_position_ids (`torch.LongTensor` of shape `(batch_size, max_patches, 2)`, *optional*):
            2D patch position coordinates from the image processor, with `(-1, -1)` indicating padding.
            Passed through to the vision encoder for positional embedding computation.
        )r}  rL  )rm   r\  rF  rF  s       rI   rL  z1Gemma4ForConditionalGeneration.get_image_featuresÖ	  s$   € ð -ˆt�z‰z×,Ñ,¨\Ð;MÑXÐQWÑXÐXrH   ry  rV  r  rU   r  r®   rW  rN   r0  r  rä  rÊ  rå  rÉ  r\   c           
      ó°  —  | j                   di d|“d|“d|“d|“d|“d|“d|“d|
“d	|“d
|“d|“d|“d|“d|“d|	“dd“|¤Ž}|j                  }t        |t        «      rt	        | d«      n|}| j                  |dd…|dd…f   «      }| j                  j                  «       j                  x}�||z  }t        j                  |«      }||z  }d}|�7 | j                  ||| j                  j                  «       j                  fi |¤Ž}t        |||j                  |j                  |j                   |j"                  |j$                  |j&                  ¬«      S )rY  ry  r\  rV  r  rU   r  r®   rN   r0  r  rÉ  rä  rÊ  rF  rW  rZ  TN)rL   rM   rN   rO   rP   r9   r:   r;   rG   )r}  r  r¦  rs   rç  rà  rY   r¥  rè  r@   rä   ré  r¤  rK   rN   rO   rP   r9   r:   r;   )rm   ry  r\  rV  r  rU   r  r®   rF  rW  rN   r0  r  rä  rÊ  rå  rÉ  rF  rê  rO   rë  rM   rè  rL   s                           rI   rr   z&Gemma4ForConditionalGeneration.forwardä	  s¼  € ðL �$—*‘*ò 
Ùð
á%ð
ñ !4ð
ñ *ð	
ñ
 *ð
ñ !4ð
ñ &ð
ñ ,ð
ñ 0ð
ñ (ð
ñ .ð
ñ ð
ñ  ð
ñ  2ð
ñ  2ð
ñ  Øñ#
ˆð(  ×1Ñ1ˆä8BÀ>ÔSVÔ8Wœ˜~˜o¨tÔ4Ð]kˆØ—‘˜mªA¨}ºaÐ,?Ñ@ÓAˆØ'+§{¡{×'BÑ'BÓ'D×'\Ñ'\Ð\Ð#ÐiØÐ5Ñ5ˆFÜ—Z‘Z Ó'ˆFØÐ5Ñ5ˆFàˆØÐØ%�4×%Ñ% f¨f°d·k±k×6QÑ6QÓ6S×6^Ñ6^ÑiÐbhÑiˆDä+ØØØ#×3Ñ3Ø!×/Ñ/Ø×)Ñ)Ø '× ;Ñ ;Ø '× ;Ñ ;Ø$×5Ñ5ô	
ð 		
rH   c                 óž   •— t        ‰| �  |f|||||||
|dœ|¤Ž}|s|s||d<   ||d<   ||d<   |	|d<   nd |d<   |s|j                  dd «      }|S )N)rN   r  rU   r®   rÊ  rå  Útoken_type_idsÚis_first_iterationr\  rV  r  r  r0  rÉ  )re   Úprepare_inputs_for_generationrÕ  )rm   ry  rN   r  r®   r\  rV  r  rU   r  r  rÊ  rå  rä  r€  rF  Úmodel_inputsrë   rn   s                     €rI   r�  z<Gemma4ForConditionalGeneration.prepare_inputs_for_generation6
  s›   ø€ ô& ‘wÑ<Øð
à+Ø'Ø)Ø%ØØ)Ø)Ø1ñ
ð ñ
ˆñ ¡YØ+7ˆL˜Ñ(Ø2EˆLÐ.Ñ/Ø-;ˆLÐ)Ñ*Ø2EˆLÐ.Ò/ð 15ˆLÐ,Ñ-ñ "Ø× Ñ Ð!3°TÓ:ˆAàÐrH   c                 ó6   — | j                   j                  «       S rp   )r}  r˜  r—  s    rI   r˜  z=Gemma4ForConditionalGeneration.get_per_layer_input_embeddingsf
  s   € Ø�z‰z×8Ñ8Ó:Ð:rH   c                 ó:   — | j                   j                  |«       y rp   )r}  r›  rš  s     rI   r›  z=Gemma4ForConditionalGeneration.set_per_layer_input_embeddingsi
  s   € Ø�
‰
×1Ñ1°%Õ8rH   r€  c                 óÔ   — | j                  «       ||||dœ}| j                  «       }	t        |	dd «      dk(  }
|
r&|�$t        ||j                  ¬«      }t	        dd|i|¤ŽS t        di |¤ŽS )NrÏ  r,  r[  r¤   r&  rG   )r¥  rš  r:  r¥   r/  r   )rY   r  rU   rN   r®   r0  r€  rF  rÙ  r  rp  r&  s               rI   r   z8Gemma4ForConditionalGeneration.create_masks_for_generatel
  s“   € ð ×,Ñ,Ó.Ø*Ø,Ø.Ø(ñ
ˆð ×,Ñ,Ó.ˆÜ˜KÐ)FÈÓMÐQYÑYˆ	áÐ*Ð6Ü!@ÐARÐ[h×[oÑ[oÔ!pÐÜ0ñ Ø#5ðàñð ô
 )Ñ7¨;Ñ7Ð7rH   rp   )NNNNNNNNNNNNNNr   N)NNNNNNNNNTNNF)NF)r<   r=   r>   rì  rx  r«  r1   rf   r%   r@   rA   rí  r"   r$   rL  r&   rF   r   r‹   rs   rK   rr   r�  r˜  r›  r³  r   rC   r   rt   ru   s   @rI   rz  rz  Å	  s÷  ø„ ð +Ð,VÐWÐØÐØÐð˜|õ ð ð 7;ñYà×'Ñ'ðYð "×,Ñ,¨tÑ3ðYð Ð+Ñ,ò	Yó ðYð Øð .2Ø15Ø8<Ø37Ø.2Ø37Ø04Ø6:Ø6:Ø(,Ø59Ø26Ø*.Ø!%Ø-.Ø04ñ#N
à×#Ñ# dÑ*ðN
ð ×'Ñ'¨$Ñ.ðN
ð #×.Ñ.°Ñ5ð	N
ð
 ×)Ñ)¨DÑ0ðN
ð Ÿ™ tÑ+ðN
ð #Ÿ\™\¨DÑ0ðN
ð ×&Ñ&¨Ñ-ðN
ð "×,Ñ,¨tÑ3ðN
ð "×,Ñ,¨tÑ3ðN
ð  ™ðN
ð !×+Ñ+¨dÑ2ðN
ð ×(Ñ(¨4Ñ/ðN
ð × Ñ  4Ñ'ðN
ð ˜$‘;ðN
ð  ˜eŸl™lÑ*ð!N
ð"  Ÿ,™,¨Ñ-ð#N
ð$ Ð+Ñ,ð%N
ð& 
&ò'N
ó ó ðN
ðf ØØØØ ØØØ ØØØØØ õ.ò`;ò9ð ð 26Ø*/ñ8Ø ð8à—|‘|ð8ð Ÿ™ tÑ+ð8ð  ™ð	8ð
 —l‘l TÑ)ð8ð !Ÿ<™<¨$Ñ.ð8ð ! 4™Kð8ð 
ò8ó ô8rH   rz  )rý  rÞ  rz  r<  r|  r¸  r�  )r/   )rU  NN)r-   )‚r™   Úcollectionsr   Úcollections.abcr   Údataclassesr   Ú	functoolsr   Útypingr   r@   r   Útorch.nnr	   rÌ   Ú r   r…  Úactivationsr   Úcache_utilsr   r   Úconfiguration_utilsr   Ú
generationr   Úintegrationsr   Úmasking_utilsr   r   r   r   r   r   r   r   Úmodeling_flash_attention_utilsr   Úmodeling_layersr   Úmodeling_outputsr   r   Úmodeling_rope_utilsr   r   Úmodeling_utilsr    r!   Úprocessing_utilsr"   Úutilsr#   r$   r%   r&   r'   r(   Úutils.genericr)   r*   Úutils.output_capturingr+   r,   Úauto.modeling_autor.   Úconfiguration_gemma4r0   r1   r2   r3   Úaccelerate.hooksr4   r8   rK   rR   rT   ÚModulerX   rw   r�   r³   rø   r
  r  ÚConv1dr(  r0  r=  rI  rb  r{  r‡  r·  rF   rs   r»  rÁ  rl   rE   rÍ  rÙ  rÛ  rï  rú  r  r  r$  r5  rS  r_  r¶  rr  r|  r¸  rÞ  rû  rý  r�  r  rC   r/  r¥   r:  r<  rz  Ú__all__rG   rH   rI   ú<module>r¢     sÓ  ðó* Ý  Ý $Ý !Ý %Ý ã Ý Ý $å &Ý !ß .Ý 3Ý )Ý 6÷	÷ 	ó 	õ CÝ 9ß Sß Kß FÝ &÷÷ ÷ Hß EÝ *ß gÓ gñ ÔÝ3ñ ðôð
 ôQÐ 7ó Qó óðQñ2 ðôð
 ôQ ;ó Qó óðQðD ô
QÐ$;ó 
Qó ð
Qð Ø
ô3Ð7ó 3ó ó ð3ô˜BŸI™Iô ô:4�B—I‘Iô 4ô*7 r§y¡yô 7ô>i)˜2Ÿ9™9ô i)ôX#¨b¯i©iô #ô8;¨¯©ô ;ô< ˜RŸY™Yô  ôH"˜bŸi™iô "ôB&˜RŸY™Yô &ôR0�r—y‘yô 0ôl*3 §	¡	ô *3ôZ@0˜Ÿ™ô @0ôF�b—i‘iô ô L "§)¡)ô Lò^(ñ.˜EŸL™Lð .¨u¯|©|ð .À%Ç,Á,ð .Ð_bó .ð,	U˜UŸ\™\ð 	U°#ð 	U¸%¿,¹,ó 	Uð$ Ø Ø ñ%Ø�I‰Ið%à�<‰<ð%ð 
�‰ð%ð �<‰<ð	%ð
 —L‘L 4Ñ'ð%ð �S‰[ð%ð �T‰\ð%ð �T‰\ð%ð ˆ5�<‰<˜Ÿ™Ð%Ñ&ó%ðN ñ5&Ø‡|�|ð5&à	�‰ð5&ð 
�‰ð5&ð —,‘,ð	5&ð
 ð5&ð ‡\�\ó5&ôpB)˜BŸI™Iô B)ôJ)Ð9ô )ôX)H˜"Ÿ)™)ô )HôX�B—I‘Iô ô&W< §	¡	ô W<ôtq)˜"Ÿ)™)ô q)ðh ô$#˜Ÿ	™	ó $#ó ð$#ôN"@�r—y‘yô "@ôJVÐ7ô VôrS B§L¡Lô Sð ômJ˜Oó mJó ðmJñ` Ð`ÔaôdVÐ+ó dVó bðdVñN Ð]Ô^ôW
Ð-¨ó W
ó _ðW
ðt°°s¸C°x±ð ÀXó ô ScÐ,ô ScôlAHÐ-ô AHôH6˜rŸy™yô 6ð64Øð4à—<‘<ð4ð —L‘L 4Ñ'ð4ð ˜T‘\ð	4ð
 —,‘, Ñ%ð4ð Ÿ™ð4ð 
ó4ðn	°u·|±|ð 	ÈUÏ\É\ð 	Ð^c×^jÑ^jó 	ñ ðôôyÐ'ó yóðyñx	 ðôô~8Ð%:¸Oó ~8óð~8òB�rH   