Ë
    ÛÓ^jÕé  ã                   ó
  — d dl Z d dlmZ d dlmZ d dlZd dlmZ d dlmc 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mZmZmZ dd
lmZ ddlmZmZmZ ddl m!Z! ddl"m#Z#m$Z$ ddl%m&Z&m'Z' ddl(m)Z) ddl*m+Z+m,Z,m-Z-m.Z.m/Z/ ddl0m1Z1 ddl2m3Z3 ddl4m5Z5m6Z6m7Z7m8Z8  e-d¬«      e G d„ de#«      «       «       Z9 e-d¬«      e G d„ de+«      «       «       Z: ed«       G d„ dejv                  «      «       Z< G d„ d ejv                  «      Z=d!ej|                  d"e?d#ej|                  fd$„Z@	 	 dbd%ejv                  d&ej|                  d'ej|                  d(ej|                  d)ej|                  dz  d*eAd+eAd,ej|                  dz  fd-„ZB G d.„ d/ejv                  «      ZC G d0„ d1ejv                  «      ZDe G d2„ d3ejv                  «      «       ZE G d4„ d5ejv                  «      ZF G d6„ d7ejv                  «      ZG G d8„ d9ejv                  «      ZHd:„ ZI ed;«      	 	 dcd!ej|                  d<ej|                  d=ej”                  d>ej”                  dz  d?eKdz  f
d@„«       ZL edA«      	 	 dcd!ej|                  d=ej”                  d>ej”                  dz  d?eKdz  fdB„«       ZM eeLeMg«       G dC„ dDejv                  «      «       ZN G dE„ dFe!«      ZOe- G dG„ dHe'«      «       ZPe- G dI„ dJeP«      «       ZQe- G dK„ dLePe«      «       ZR G dM„ dNejv                  «      ZS G dO„ dPeP«      ZT G dQ„ dRejv                  «      ZUdSe?d#eVe?   fdT„ZW	 dddUe?dVe?dWe?dXe?d#ej°                  f
dY„ZY G dZ„ d[eP«      ZZ e-d\¬«       G d]„ d^eP«      «       Z[ e-d\¬«       G d_„ d`ePe«      «       Z\g da¢Z]y)eé    N)ÚCallable)Ú	dataclassé   )Úinitialization)ÚACT2FN)ÚCacheÚDynamicCache)ÚGenerationMixin)Úuse_experts_implementationÚuse_kernel_forward_from_hubÚuse_kernel_func_from_hubÚuse_kernelized_func)Úforce_accelerate_hooks)Úcreate_causal_maskÚcreate_recurrent_attention_maskÚ!create_sliding_window_causal_mask)ÚGradientCheckpointingLayer)ÚBaseModelOutputWithPastÚBaseModelOutputWithPooling)ÚALL_ATTENTION_FUNCTIONSÚPreTrainedModel)ÚUnpack)ÚModelOutputÚTransformersKwargsÚauto_docstringÚcan_return_tupleÚtorch_compilable_check)Úmerge_with_config_defaults)Úcapture_outputsé   )ÚInklingAudioConfigÚInklingConfigÚInklingTextConfigÚInklingVisionConfigzL
    Base class for Inkling outputs, with hidden states and attentions.
    ©Úcustom_introc                   ó:   — e Zd ZU dZdZej                  dz  ed<   y)ÚInklingModelOutputWithPasta  
    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.
    NÚimage_hidden_states)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r)   ÚtorchÚFloatTensorÚ__annotations__© ó    úw/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/transformers/models/inkling/modeling_inkling.pyr(   r(   4   s   … ñð 59Ð˜×*Ñ*¨TÑ1Ô8r2   r(   zS
    Base class for Inkling causal language model (or autoregressive) outputs.
    c                   óú   — 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<   y)	ÚInklingCausalLMOutputWithPasta8  
    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.
    NÚlossÚlogitsÚpast_key_valuesÚhidden_statesÚ
attentionsr)   )r*   r+   r,   r-   r6   r.   r/   r0   r7   r8   r   r9   Útupler:   r)   r1   r2   r3   r5   r5   D   s‹   … ñð &*€Dˆ%×
Ñ
˜dÑ
"Ó)Ø'+€FˆE×Ñ Ñ$Ó+Ø$(€O�U˜T‘\Ó(Ø59€M�5˜×*Ñ*Ñ+¨dÑ2Ó9Ø26€J��e×'Ñ'Ñ(¨4Ñ/Ó6Ø48Ð˜×*Ñ*¨TÑ1Ô8r2   r5   ÚRMSNormc                   óh   ‡ — e Zd Zddeddfˆ fd„Zdej                  dej                  fd„Zd„ Zˆ xZ	S )	ÚInklingRMSNormÚepsÚreturnNc                 óŠ   •— t         ‰| �  «        t        j                  t	        j
                  |«      «      | _        || _        y)z=
        InklingRMSNorm is equivalent to T5LayerNorm
        N)ÚsuperÚ__init__ÚnnÚ	Parameterr.   ÚonesÚweightÚvariance_epsilon)ÚselfÚhidden_sizer?   Ú	__class__s      €r3   rC   zInklingRMSNorm.__init__d   s1   ø€ ô 	‰ÑÔÜ—l‘l¤5§:¡:¨kÓ#:Ó;ˆŒØ #ˆÕr2   r9   c                 ó"  — |j                   }|j                  t        j                  «      }|j	                  d«      j                  dd¬«      }|t        j                  || j                  z   «      z  }| j                  |j                  |«      z  S )Né   éÿÿÿÿT)Úkeepdim)	ÚdtypeÚtor.   Úfloat32ÚpowÚmeanÚrsqrtrH   rG   )rI   r9   Úinput_dtypeÚvariances       r3   ÚforwardzInklingRMSNorm.forwardl   sy   € Ø#×)Ñ)ˆØ%×(Ñ(¬¯©Ó7ˆØ ×$Ñ$ QÓ'×,Ñ,¨R¸Ð,Ó>ˆØ%¬¯©°H¸t×?TÑ?TÑ4TÓ(UÑUˆØ�{‰{˜]×-Ñ-¨kÓ:Ñ:Ð:r2   c                 ó^   — t        | j                  j                  «      › d| j                  › �S )Nz, eps=)r;   rG   ÚshaperH   )rI   s    r3   Ú
extra_reprzInklingRMSNorm.extra_reprs   s*   € Ü˜Ÿ™×)Ñ)Ó*Ð+¨6°$×2GÑ2GÐ1HÐIÐIr2   )ç�íµ ÷Æ°>)
r*   r+   r,   ÚfloatrC   r.   ÚTensorrX   r[   Ú__classcell__©rK   s   @r3   r>   r>   b   s7   ø„ ñ$¨ð $¸$õ $ð; U§\¡\ð ;°e·l±ló ;öJr2   r>   c                   ó”   ‡ — e Zd ZdZdedefˆ fd„Zdej                  dej                  dej                  dej                  fd	„Zˆ xZ	S )
ÚInklingRelativeLogitsa|  hidden states conditioned relative position bias. `proj` is a trained bank of bias-vs-distance profiles; each token's
    `relative_states` mixes them into one bias value per backward distance
    (`sglang RelLogitsProj` + the FA4 `score_mod`, materialized densely). The bias is zero
    outside `0 <= distance < rel_extent`; causality and padding stay in the attention mask.
    Úd_relÚ
rel_extentc                 óŒ   •— t         ‰| �  «        || _        t        j                  t        j                  ||«      «      | _        y ©N)rB   rC   rd   rD   rE   r.   ÚemptyÚproj)rI   rc   rd   rK   s      €r3   rC   zInklingRelativeLogits.__init__~   s0   ø€ Ü‰ÑÔØ$ˆŒÜ—L‘L¤§¡¨U°JÓ!?Ó@ˆ�	r2   Úrelative_statesÚquery_positionsÚkey_positionsr@   c                 ój  — || j                   z  j                  dd«      }|d d …d f   |d d d …f   z
  d d d d …d d …f   } |j                  d| j                  dz
  «      j                  g |j
                  d d ¢d‘d‘­Ž }|j                  d|«      }|j                  |dk  || j                  k\  z  d«      S )Nr    rM   r   rN   ç        )rh   Ú	transposeÚclamprd   ÚexpandrZ   ÚgatherÚmasked_fill)rI   ri   rj   rk   Ú
rel_logitsÚdistanceÚgather_indexÚposition_biass           r3   rX   zInklingRelativeLogits.forwardƒ   sÇ   € ð &¨¯	©	Ñ1×<Ñ<¸QÀÓBˆ
Ø#¢A t GÑ,¨}¸TÂ1¸WÑ/EÑEÀtÈTÒSTÒVWÐGWÑXˆØD�x—~‘~ a¨¯©¸1Ñ)<Ó=×DÑDÐcÀj×FVÑFVÐWYÐXYÐFZÐcÐ\^ÐcÐ`bÒcˆØ"×)Ñ)¨"¨lÓ;ˆØ×(Ñ(¨(°Q©,¸8ÀtÇÁÑ;VÑ)WÐY\Ó]Ð]r2   )
r*   r+   r,   r-   ÚintrC   r.   r^   rX   r_   r`   s   @r3   rb   rb   w   s^   ø„ ñðA˜cð A¨sõ Að
^àŸ™ð^ð Ÿ™ð^ð —|‘|ð	^ð
 
�‰÷^r2   rb   r9   Ú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)rZ   rp   Úreshape)r9   rx   ÚbatchÚnum_key_value_headsÚslenÚhead_dims         r3   Ú	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ÐTr2   ÚmoduleÚqueryÚkeyÚvalueÚattention_maskÚscalingÚdropoutrv   c                 ó&  — t        || j                  «      }	t        || j                  «      }
t        j                  ||	j	                  dd«      «      |z  }|�||z   }|�||z   }t
        j                  j                  |dt        j                  ¬«      j                  |j                  «      }t
        j                  j                  ||| j                  ¬«      }t        j                  ||
«      }|j	                  dd«      j                  «       }||fS )NrM   r   rN   )ÚdimrP   )ÚpÚtrainingr    )r   Únum_key_value_groupsr.   Úmatmulrn   rD   Ú
functionalÚsoftmaxrR   rQ   rP   r†   rŠ   Ú
contiguous)r€   r�   r‚   rƒ   r„   r…   r†   rv   ÚkwargsÚ
key_statesÚvalue_statesÚattn_weightsÚattn_outputs                r3   Úeager_attention_forwardr•   �   sð   € ô ˜3 × ;Ñ ;Ó<€JÜ˜U F×$?Ñ$?Ó@€Lä—<‘<  z×';Ñ';¸A¸qÓ'AÓBÀWÑL€LØÐ Ø# mÑ3ˆØÐ!Ø# nÑ4ˆä—=‘=×(Ñ(¨¸2ÄUÇ]Á]Ð(ÓS×VÑVÐW\×WbÑWbÓc€LÜ—=‘=×(Ñ(¨¸È6Ï?É?Ð(Ó[€LÜ—,‘,˜|¨\Ó:€KØ×'Ñ'¨¨1Ó-×8Ñ8Ó:€Kà˜Ð$Ð$r2   c                   óÚ   ‡ — e Zd Zdedefˆ fd„Z	 	 ddej                  dej                  dz  dej                  dz  dedz  d	e	e
   d
eej                  ej                  dz  f   fd„Zˆ xZS )ÚInklingAttentionÚconfigÚ	layer_idxc                 ó¼  •— t         ‰| �  «        || _        || _        |j                  | j                     dk(  | _        | j
                  r|j                  n|j                  | _        | j
                  r|j                  n|j                  | _
        | j
                  r|j                  n|j                  | _        | j                  | j                  z  | _        | j
                  r|j                  nd | _        | j
                  r|j                  n|j                   | _        d| j                  z  | _        |j$                  | _        d| _        t)        j*                  |j,                  | j                  | j                  z  d¬«      | _        t)        j*                  |j,                  | j                  | j                  z  d¬«      | _        t)        j*                  |j,                  | j                  | j                  z  d¬«      | _        t)        j*                  |j,                  | j                  |j4                  z  d¬«      | _        t)        j*                  | j                  | j                  z  |j,                  d¬«      | _        t;        | j                  | j                  z  |j<                  |d¬«      | _        t;        | j                  | j                  z  |j<                  |d¬«      | _         tC        | j                  |jD                  ¬	«      | _#        tC        | j                  |jD                  ¬	«      | _$        tK        |j4                  | j                   «      | _&        y )
NÚhybrid_slidingç      ð?TF©Úbiasr   )Úconv_idxr    ©r?   )'rB   rC   r˜   r™   Úlayer_typesÚ
is_slidingÚswa_head_dimr~   Úswa_num_attention_headsÚnum_attention_headsÚ	num_headsÚswa_num_key_value_headsr|   r‹   Úsliding_window_sizeÚsliding_windowrd   r…   Úattention_dropoutÚ	is_causalrD   ÚLinearrJ   Úq_projÚk_projÚv_projrc   Úr_projÚo_projÚInklingShortConvolutionÚsconv_kernel_sizeÚk_sconvÚv_sconvr>   Úrms_norm_epsÚq_normÚk_normrb   Úrel_logits_proj©rI   r˜   r™   rK   s      €r3   rC   zInklingAttention.__init__º   sg  ø€ Ü‰ÑÔØˆŒØ"ˆŒØ ×,Ñ,¨T¯^©^Ñ<Ð@PÑPˆŒØ/3¯ª˜×+Ò+ÀFÇOÁOˆŒØ;?¿?º?˜×7Ò7ÐPV×PjÑPjˆŒØEIÇ_Â_ 6×#AÒ#AÐZ`×ZtÑZtˆÔ Ø$(§N¡N°d×6NÑ6NÑ$NˆÔ!Ø<@¿OºO˜f×8Ò8ÐQUˆÔØ8<¿º˜&×4Ò4ÈV×M^ÑM^ˆŒà˜TŸ]™]Ñ*ˆŒØ!'×!9Ñ!9ˆÔØˆŒä—i‘i × 2Ñ 2°D·N±NÀTÇ]Á]Ñ4RÐY^Ô_ˆŒÜ—i‘i × 2Ñ 2°D×4LÑ4LÈtÏ}É}Ñ4\ÐchÔiˆŒÜ—i‘i × 2Ñ 2°D×4LÑ4LÈtÏ}É}Ñ4\ÐchÔiˆŒÜ—i‘i × 2Ñ 2°D·N±NÀVÇ\Á\Ñ4QÐX]Ô^ˆŒÜ—i‘i §¡°·±Ñ >À×@RÑ@RÐY^Ô_ˆŒÜ.Ø×$Ñ$ t§}¡}Ñ4°f×6NÑ6NÐPYÐdeô
ˆŒô /Ø×$Ñ$ t§}¡}Ñ4°f×6NÑ6NÐPYÐdeô
ˆŒô % T§]¡]¸×8KÑ8KÔLˆŒÜ$ T§]¡]¸×8KÑ8KÔLˆŒÜ4°V·\±\À4Ç?Á?ÓSˆÕr2   Nr9   r„   Ú	conv_maskr8   r�   r@   c                 óH  — |j                   d d }g |¢d‘| j                  ‘­}| j                  |«      }| j                  | j	                  |«      ||¬«      }	| j                  | j                  |«      ||¬«      }
| j                  |«      }| j                  |j                  |«      «      j                  dd«      }| j                  |	j                  |«      «      j                  dd«      }	|
j                  |«      j                  dd«      }
|j                   d   }|�[|j                  || j                  «      \  }}|j                  | j                  «      }|j                  |	|
| j                  «      \  }	}
n|	j                   d   }d\  }}t!        j"                  ||j$                  ¬«      |z   }t!        j"                  ||j$                  ¬«      |z   } |j                  g |¢| j&                  ‘d‘­Ž }| j)                  |||«      }| j*                  së| j,                  j.                  �Õ|dz   j1                  «       }d| j,                  j2                  t!        j4                  || j,                  j.                  z  j7                  d¬«      «      z  z   }|j                  dddd«      }|j1                  «       |z  j9                  |j:                  «      }|j1                  «       |z  j9                  |j:                  «      }t=        j>                  | j,                  j@                  tB        «      } || ||	|
|f| jD                  sd	n| jF                  | jH                  | jJ                  |d
œ|¤Ž\  }} |jL                  g |¢d‘­Ž jO                  «       }| jQ                  |«      }||fS )NrN   ©r8   r»   r    rM   )r   r   ©Údevicerœ   )Úminrm   )r†   r…   r©   rv   ))rZ   r~   r­   r´   r®   rµ   r¯   r°   r·   Úviewrn   r¸   Úget_mask_sizesr™   Úget_query_offsetÚupdater.   Úaranger¿   r¦   r¹   r¢   r˜   Úlog_scaling_n_floorr]   Úlog_scaling_alphaÚlogro   rQ   rP   r   Úget_interfaceÚ_attn_implementationr•   rŠ   rª   r…   r©   rz   r�   r±   )rI   r9   r„   r»   r8   r�   Úinput_shapeÚhidden_shapeÚquery_statesr‘   r’   ri   Úq_lengthÚ	kv_lengthÚ	kv_offsetÚq_offsetÚkv_positionsÚq_positionsrv   Úeffective_nÚtauÚattention_interfacer”   r“   s                           r3   rX   zInklingAttention.forwardÙ   s]  € ð $×)Ñ)¨#¨2Ð.ˆØ8˜Ð8 bÐ8¨$¯-©-Ñ8ˆà—{‘{ =Ó1ˆØ—\‘\ $§+¡+¨mÓ"<ÈoÐir�\Ósˆ
Ø—|‘| D§K¡K°Ó$>ÐP_Ðkt�|ÓuˆØŸ+™+ mÓ4ˆà—{‘{ <×#4Ñ#4°\Ó#BÓC×MÑMÈaÐQRÓSˆØ—[‘[ §¡°Ó!>Ó?×IÑIÈ!ÈQÓOˆ
Ø#×(Ñ(¨Ó6×@Ñ@ÀÀAÓFˆà×%Ñ% aÑ(ˆØÐ&à#2×#AÑ#AÀ(ÈDÏNÉNÓ#[Ñ ˆI�yØ&×7Ñ7¸¿¹ÓGˆHà'6×'=Ñ'=¸jÈ,ÐX\×XfÑXfÓ'gÑ$ˆJ™à"×(Ñ(¨Ñ+ˆIØ"&ÑˆH�iä—|‘| I°m×6JÑ6JÔKÈiÑWˆÜ—l‘l 8°M×4HÑ4HÔIÈHÑTˆØ.˜/×.Ñ.ÐP°ÐP¸T¿^¹^ÐPÈRÒPˆØ×,Ñ,¨_¸kÈ<ÓXˆð �Š 4§;¡;×#BÑ#BÐ#NØ&¨™?×1Ñ1Ó3ˆKØ˜Ÿ™×5Ñ5¼¿	¹	Ø˜tŸ{™{×>Ñ>Ñ>×EÑEÈ#ÐEÓNó9ñ ñ ˆCð —(‘(˜1˜a  QÓ'ˆCØ(×.Ñ.Ó0°3Ñ6×:Ñ:¸<×;MÑ;MÓNˆLØ*×0Ñ0Ó2°SÑ8×<Ñ<¸]×=PÑ=PÓQˆMä(?×(MÑ(MØ�K‰K×,Ñ,Ô.Eó)
Ðñ %8ØØØØØð%
ð  $Ÿ}š}‘C°$×2HÑ2HØ—L‘LØ×.Ñ.Ø'ñ%
ð ñ%
Ñ!ˆ�\ð *�k×)Ñ)Ð;¨;Ð;¸Ò;×FÑFÓHˆØ—k‘k +Ó.ˆØ˜LÐ(Ð(r2   ©NN)r*   r+   r,   r#   rw   rC   r.   r^   r   r   r   r;   rX   r_   r`   s   @r3   r—   r—   ¹   s    ø„ ðTÐ0ð T¸Sõ TðF *.Ø(,ñA)à—|‘|ðA)ð Ÿ™ tÑ+ðA)ð —<‘< $Ñ&ð	A)ð
  ™ðA)ð Ð+Ñ,ðA)ð 
ˆu�|‰|˜UŸ\™\¨DÑ0Ð0Ñ	1÷A)r2   r—   c                   ó\   ‡ — e Zd Zdefˆ fd„Zdej                  dej                  fd„Zˆ xZS )Ú
InklingMLPr˜   c                 ó$  •— t         ‰| �  «        || _        |j                  | _        |j                  | _        t        j                  | j                  | j                  d¬«      | _        t        j                  | j                  | j                  d¬«      | _        t        j                  | j                  | j                  d¬«      | _	        t        |j                     | _        t        j                  t        j                  d«      «      | _        y )NFr�   r    )rB   rC   r˜   rJ   Úintermediate_sizerD   r¬   Ú	gate_projÚup_projÚ	down_projr   Ú
hidden_actÚact_fnrE   r.   rF   Úglobal_scale©rI   r˜   rK   s     €r3   rC   zInklingMLP.__init__  s¿   ø€ Ü‰ÑÔØˆŒØ!×-Ñ-ˆÔØ!'×!9Ñ!9ˆÔÜŸ™ 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×.Ñ.Ñ/ˆŒÜŸL™L¬¯©°A«Ó7ˆÕr2   r9   r@   c                 ó¢   — | j                  | j                  | j                  |«      «      | j                  |«      z  «      }|| j                  z  S rf   )rÞ   rà   rÜ   rÝ   rá   ©rI   r9   s     r3   rX   zInklingMLP.forward)  sE   € ØŸ™ t§{¡{°4·>±>À-Ó3PÓ'QÐTX×T`ÑT`ÐanÓToÑ'oÓpˆØ˜t×0Ñ0Ñ0Ð0r2   )	r*   r+   r,   r#   rC   r.   r^   rX   r_   r`   s   @r3   rÙ   rÙ     s+   ø„ ð	8Ð0õ 	8ð1 U§\¡\ð 1°e·l±l÷ 1r2   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 )	ÚInklingExpertsz2Collection of expert weights stored as 3D tensors.r˜   c                 óò  •— t         ‰| �  «        |j                  | _        |j                  | _        |j                  | _        t        j                  t        j                  | j                  d| j                  z  | j
                  «      «      | _        t        j                  t        j                  | j                  | j
                  | j                  «      «      | _        t        |j                     | _        y )NrM   )rB   rC   Ún_routed_expertsÚnum_expertsrJ   Ú
hidden_dimÚmoe_intermediate_sizeÚintermediate_dimrD   rE   r.   rg   Úgate_up_projrÞ   r   rß   rà   râ   s     €r3   rC   zInklingExperts.__init__2  s­   ø€ Ü‰ÑÔØ!×2Ñ2ˆÔØ ×,Ñ,ˆŒØ &× <Ñ <ˆÔÜŸ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×.Ñ.Ñ/ˆ�r2   r9   Ú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_classesrM   r    r   )rN   éþÿÿÿ©rˆ   rN   )r.   Ú
zeros_likeÚno_gradrD   r�   Úone_hotré   ÚpermuteÚgreaterÚsumÚnonzeroÚwhereÚlinearrí   Úchunkrà   rÞ   Ú
index_add_rQ   rP   )rI   r9   rî   rï   Úfinal_hidden_statesÚexpert_maskÚ
expert_hitÚ
expert_idxÚ	top_k_posÚ	token_idxÚcurrent_stateÚgateÚupÚcurrent_hidden_statess                 r3   rX   zInklingExperts.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-   r#   rC   r.   r^   rX   r_   r`   s   @r3   ræ   ræ   .  sN   ø„ á<ð0Ð0õ 0ð#à—|‘|ð#ð —\‘\ð#ð —|‘|ð	#ð
 
�‰÷#r2   ræ   c                   ór   ‡ — e Zd Zˆ fd„Zdeej                  ej                  ej                  f   fd„Zˆ xZS )ÚInklingTopkRouterc                 óT  •— t         ‰| �  «        |j                  | _        |j                  | _        | j                  | j                  z   | _        |j                  | _        |j                  | _        |j                  | _
        t        j                  t        j                  | j
                  |j                  «      «      | _        t        j                  t        j                   d«      «      | _        t        j                  t        j                  | j                  «      «      | _        y ©Nr    )rB   rC   rè   ré   Ún_shared_expertsÚn_total_expertsrJ   rê   Úroute_scaleÚnum_experts_per_tokÚtop_krD   rE   r.   rg   rG   rF   rá   Úe_score_correction_biasrâ   s     €r3   rC   zInklingTopkRouter.__init__W  sË   ø€ Ü‰ÑÔØ!×2Ñ2ˆÔØ &× 7Ñ 7ˆÔØ#×/Ñ/°$×2GÑ2GÑGˆÔØ ×,Ñ,ˆŒØ!×-Ñ-ˆÔØ×/Ñ/ˆŒ
ä—l‘l¤5§;¡;¨t×/CÑ/CÀV×EWÑEWÓ#XÓYˆŒÜŸL™L¬¯©°A«Ó7ˆÔÜ')§|¡|´E·K±KÀ×@PÑ@PÓ4QÓ'RˆÕ$r2   r@   c                 ó  — |j                  d| j                  «      }t        j                  || j                  «      }|j                  «       }|dd | j                   …f   }|| j                  z   }t        j                  || j                  dd¬«      d   }|dd | j                   …f   }|d| j                   d …f   }	t        j                  |j                  d|«      |	gd¬«      }
t        j                  |
«      }t        j                  |t        j                  |dd¬«      z
  «      }|| j                   z  | j"                  z  }|d| j                   d …f   j%                  «       }|dd | j                  …f   j%                  «       }||||fS )	NrN   .F)rˆ   Úsortedr    ró   T)rˆ   rO   )rz   rê   ÚFrü   rG   Úsigmoidr  r  r.   Útopkr  Úcatrq   Ú
logsigmoidÚexpÚ	logsumexpr  rá   r�   )rI   r9   ÚflatÚrouter_logitsÚscoresÚrouted_scoresÚscores_for_choiceÚtopk_indicesÚrouted_logitsÚshared_logitsÚtopk_logitsÚtopk_log_probsÚtopk_weightsÚshared_gammass                 r3   rX   zInklingTopkRouter.forwardd  s…  € Ø×$Ñ$ R¨¯©Ó9ˆÜŸ™  t§{¡{Ó3ˆð ×&Ñ&Ó(ˆØ˜sÐ$< t×'<Ñ'<Ð&<Ð$<Ð<Ñ=ˆØ)¨D×,HÑ,HÑHÐÜ—z‘zÐ"3°T·Z±ZÀRÐPUÔVÐWXÑYˆà% cÐ+C¨d×.CÑ.CÐ-CÐ+CÐ&CÑDˆØ% c¨D×,AÑ,AÐ+AÑ+CÐ&CÑDˆÜ—i‘i ×!5Ñ!5°b¸,Ó!GÈÐ WÐ]_Ô`ˆÜŸ™ kÓ2ˆÜ—y‘y ´%·/±/À.ÐVXÐbfÔ2gÑ!gÓhˆà# d×&6Ñ&6Ñ6¸×9JÑ9JÑJˆà$ S¨4×+@Ñ+@Ð*@Ñ*BÐ%BÑC×NÑNÓPˆØ# C¨¨4¯:©:¨Ð$5Ñ6×AÑAÓCˆà˜l¨L¸-ÐGÐGr2   )	r*   r+   r,   rC   r;   r.   r^   rX   r_   r`   s   @r3   r
  r
  V  s/   ø„ ôSðH¨¨e¯l©l¸E¿L¹LÈ%Ï,É,Ð.VÑ(W÷ Hr2   r
  c                   ó$   ‡ — e Zd Zˆ fd„Zd„ Zˆ xZS )ÚInklingSharedExpertsc                 ó  •— t         ‰| �  «        |j                  | _        |j                  }t	        j
                  t        j                  |j                  ||j                  «      «      | _	        t	        j
                  t        j                  |j                  ||j                  «      «      | _
        t	        j
                  t        j                  |j                  |j                  |«      «      | _        t        |j                     | _        y rf   )rB   rC   r  rë   rD   rE   r.   rg   rJ   rÜ   rÝ   rÞ   r   rß   rà   )rI   r˜   rì   rK   s      €r3   rC   zInklingSharedExperts.__init__}  s¼   ø€ Ü‰ÑÔØ &× 7Ñ 7ˆÔØ!×7Ñ7Ðô
 Ÿ™¤e§k¡k°&×2IÑ2IÐK[Ð]c×]oÑ]oÓ&pÓqˆŒÜ—|‘|¤E§K¡K°×0GÑ0GÐIYÐ[a×[mÑ[mÓ$nÓoˆŒÜŸ™¤e§k¡k°&×2IÑ2IÈ6×K]ÑK]Ð_oÓ&pÓqˆŒÜ˜V×.Ñ.Ñ/ˆ�r2   c                 ó¸  — |j                   }|j                  dd|d   «      j                  | j                  dd«      }|j                  d| j                  d«      j	                  dd«      }t        j                  || j                  j	                  dd«      «      }t        j                  || j                  j	                  dd«      «      }| j                  |«      |z  |z  }t        j                  || j                  j	                  dd«      «      }|j                  «       j                  d¬«      j                  |j                  «      }|j                  |«      S )Nr    rN   r   rM   ró   )rZ   rz   rp   r  rn   r.   ÚbmmrÜ   rÝ   rà   rÞ   r]   rù   rQ   rP   rÁ   )	rI   r9   ÚgammasrË   r  r  Ú	activatedÚdownÚouts	            r3   rX   zInklingSharedExperts.forwardŠ  s  € Ø#×)Ñ)ˆØ%×-Ñ-¨a°°[À±_ÓE×LÑLÈT×MbÑMbÐdfÐhjÓkˆØ—‘  D×$9Ñ$9¸1Ó=×GÑGÈÈ1ÓMˆä�y‰y˜¨¯©×(@Ñ(@ÀÀAÓ(FÓGˆÜ�Y‰Y�} d§l¡l×&<Ñ&<¸QÀÓ&BÓCˆØ—K‘K Ó%¨Ñ*¨VÑ3ˆ	Ü�y‰y˜ D§N¡N×$<Ñ$<¸QÀÓ$BÓCˆà�j‰j‹l×Ñ 1ÐÓ%×(Ñ(¨×)<Ñ)<Ó=ˆØ�x‰x˜Ó$Ð$r2   ©r*   r+   r,   rC   rX   r_   r`   s   @r3   r)  r)  |  s   ø„ ô0ö%r2   r)  c                   óB   ‡ — e Zd ZdZˆ fd„Zdej                  fd„Zˆ xZS )Ú
InklingMoEz7Gate -> routed experts (+ shared experts), TML flavour.c                 ó�   •— t         ‰| �  «        || _        t        |«      | _        t        |«      | _        t        |«      | _        y rf   )	rB   rC   r˜   r
  r  ræ   Úexpertsr)  Úshared_expertsrâ   s     €r3   rC   zInklingMoE.__init__›  s:   ø€ Ü‰ÑÔØˆŒÜ% fÓ-ˆŒ	Ü% fÓ-ˆŒÜ2°6Ó:ˆÕr2   r@   c                 óø   — |}|j                   }| j                  |«      \  }}}}|j                  d|j                   d   «      } | j                  |||«      j                  |Ž }|| j	                  ||¬«      z   }|S )NrN   )r-  )rZ   r  rÁ   r5  r6  )rI   r9   Ú	residualsrË   Ú_r&  r!  r'  s           r3   rX   zInklingMoE.forward¢  s†   € Ø!ˆ	Ø#×)Ñ)ˆØ7;·y±yÀÓ7OÑ4ˆˆ<˜ }Ø%×*Ñ*¨2¨}×/BÑ/BÀ2Ñ/FÓGˆØT˜Ÿ™ ]°LÀ,ÓO×TÑTÐVaÐbˆØ%¨×(;Ñ(;¸IÈmÐ(;Ó(\Ñ\ˆØÐr2   )	r*   r+   r,   r-   rC   r.   r^   rX   r_   r`   s   @r3   r3  r3  ˜  s   ø„ ÙAô;ð¨¯©÷ r2   r3  c                 ó¦   — |�N|j                   d   dkD  r<|j                   d   dkD  r*| j                  }| |dd…dd…df   z  j                  |«      } | S )zm
    Tunes out the hidden states for padding tokens, see https://github.com/state-spaces/mamba/issues/66
    Nr    r   )rZ   rP   rQ   )r9   r„   rP   s      r3   Úapply_mask_to_padding_statesr;  ¬  sa   € ð
 Ð! n×&:Ñ&:¸1Ñ&=ÀÒ&AÀn×FZÑFZÐ[\ÑF]Ð`aÒFaØ×#Ñ#ˆØ&¨ºº1¸d¸
Ñ)CÑC×GÑGÈÓNˆàÐr2   Úcausal_conv1d_updateÚ
conv_staterG   rž   Ú
activationc                 ó¦  — | j                   \  }}}|j                   d   }t        j                  || gd¬«      j                  |j                  «      }	|j                  |	d d …d d …| d …f   «       t        j                  |	|j                  d«      |d|¬«      }
|
d d …d d …| d …f   }
|�t        |   |
«      }
|
j                  | j                  «      S )NrN   ró   r    r   )ÚpaddingÚgroups)
rZ   r.   r  rQ   rP   Úcopy_r  Úconv1dÚ	unsqueezer   )r9   r=  rG   rž   r>  r9  rJ   Úseq_lenÚ	state_lenÚhidden_states_newr0  s              r3   r<  r<  ¸  sË   € ð ,×1Ñ1Ñ€A€{�GØ× Ñ  Ñ$€IäŸ	™	 :¨}Ð"=À2ÔF×IÑIÈ&Ï,É,ÓWÐØ×ÑÐ&¢qª!¨i¨Z©[Ð'8Ñ9Ô:Ü
�(‰(Ð$ f×&6Ñ&6°qÓ&9¸4ÈÐS^Ô
_€CØ
Ša’�W�H‘IˆoÑ
€CØÐÜ�ZÑ  Ó%ˆØ�6‰6�-×%Ñ%Ó&Ð&r2   Úcausal_conv1d_fnc                 ó8  — | j                   \  }}}|j                   d   dz
  }t        j                  | j                  |j                  «      |j                  d«      |||¬«      d d …d d …d |…f   }	|�t        |   |	«      }	|	j                  | j                  «      S )NrN   r    )rG   rž   r@  rA  )rZ   r  rC  rQ   rP   rD  r   )
r9   rG   rž   r>  r�   r9  rJ   rE  r@  r0  s
             r3   rH  rH  Ì  s    € ð ,×1Ñ1Ñ€A€{�GØ�l‰l˜2Ñ Ñ"€Gä
�(‰(Ø×Ñ˜Ÿ™Ó&Ø×Ñ Ó"ØØØôò ŠˆHˆWˆH€nñ€Cð ÐÜ�ZÑ  Ó%ˆØ�6‰6�-×%Ñ%Ó&Ð&r2   c                   óž   ‡ — e Zd Zdedededefˆ fd„Z ed«      	 	 ddej                  d	edz  d
ej                  dz  de	e
   fd„«       Zˆ xZS )r²   rJ   Úconv_kernel_sizer™   rŸ   c                 ó’   •— t         ‰| �  «        || _        || _        || _        t        j                  |||||dz
  d¬«      | _        y )Nr    F)Úin_channelsÚout_channelsÚkernel_sizerA  r@  rž   )rB   rC   r™   rŸ   rK  rD   ÚConv1drC  )rI   rJ   rK  r™   rŸ   rK   s        €r3   rC   z InklingShortConvolution.__init__å  sK   ø€ Ü‰ÑÔØ"ˆŒØ ˆŒØ 0ˆÔä—i‘iØ#Ø$Ø(ØØ$ qÑ(Øô
ˆ�r2   rC  Nr9   r8   r»   r�   c                 ó¸  — |j                   }|j                  «       }|}t        ||«      }|j                  d   }|j	                  dd«      }|d uxr& |j                  | j                  | j                  «      }|rž|dk(  r™|j                  | j                     j                  sv|j                  | j                     j                  | j                     }	t        ||	| j                  j                  j                  d«      | j                  j                  «      }n›|�3|j!                  || j                  | j                  | j"                  ¬«      }t%        || j                  j                  j                  d«      | j                  j                  |j'                  d«      ¬«      }|r|d d …d d …| d …f   }|j	                  dd«      }||z   j)                  |¬«      }|S )Nr    rM   )Ú	state_idxrK  Úseq_idx)rS  )rP   )rP   r]   r;  rZ   rn   Úhas_previous_stater™   rŸ   ÚlayersÚrecord_pastÚconv_statesr<  rC  rG   Úsqueezerž   Úupdate_conv_staterK  rH  ÚgetrQ   )
rI   r9   r8   r»   r�   rV   ÚresidualrE  Úuse_precomputed_statesr=  s
             r3   rX   zInklingShortConvolution.forwardô  sµ  € ð $×)Ñ)ˆØ%×+Ñ+Ó-ˆà ˆÜ4°]ÀIÓNˆØ×%Ñ% aÑ(ˆØ%×/Ñ/°°1Ó5ˆà!0¸Ð!<ò "
À×AcÑAcØ�N‰N˜DŸM™MóB
Ðñ " g°¢l¸?×;QÑ;QÐRV×R`ÑR`Ñ;a×;mÒ;mØ(×/Ñ/°·±Ñ?×KÑKÈDÏMÉMÑZˆJä0Ø˜z¨4¯;©;×+=Ñ+=×+EÑ+EÀaÓ+HÈ$Ï+É+×JZÑJZó‰Mð Ð*Ø /× AÑ AØ! 4§>¡>¸T¿]¹]Ð]a×]rÑ]rð !Bó !�ô -Ø˜tŸ{™{×1Ñ1×9Ñ9¸!Ó<¸d¿k¹k×>NÑ>NÐX^×XbÑXbÐclÓXmôˆMñ
 &Ø -ªa²°W°H±I¨oÑ >�à%×/Ñ/°°1Ó5ˆØ&¨Ñ1×5Ñ5¸KÐ5ÓHˆØÐr2   r×   )r*   r+   r,   rw   rC   r   r.   r^   r   r   r   rX   r_   r`   s   @r3   r²   r²   ã  sƒ   ø„ ð
 Cð 
¸3ð 
È3ð 
ÐZ]õ 
ñ ˜HÓ%ð )-Ø)-ñ	*à—|‘|ð*ð  ™ð*ð —<‘< $Ñ&ð	*ð
 Ð+Ñ,ò*ó &ô*r2   r²   c                   ó¸   ‡ — e Zd Zdedefˆ fd„Z	 	 	 ddej                  dej                  dz  dej                  dz  dedz  d	e	e
   d
ej                  fd„Zˆ xZS )ÚInklingDecoderLayerr˜   r™   c                 ó(  •— t         ‰| �  «        |j                  | _        t        ||«      | _        |j
                  |   dk(  rt        |«      | _        nt        |«      | _        t        |j                  |j                  «      | _        t        |j                  |j                  «      | _        |j                  |   | _        t        |j                  |j                   |d¬«      | _        t        |j                  |j                   |d¬«      | _        y )NÚsparserM   )r™   rŸ   r   )rB   rC   rJ   r—   Ú	self_attnÚmlp_layer_typesr3  ÚmlprÙ   r>   r¶   Úinput_layernormÚpost_attention_layernormr¡   Ú
layer_typer²   rK  Ú
attn_sconvÚ	mlp_sconvrº   s      €r3   rC   zInklingDecoderLayer.__init__#  sã   ø€ Ü‰ÑÔØ!×-Ñ-ˆÔÜ)¨&°)Ó<ˆŒà×!Ñ! )Ñ,°Ò8Ü! &Ó)ˆD�Hä! &Ó)ˆDŒHä-¨f×.@Ñ.@À&×BUÑBUÓVˆÔÜ(6°v×7IÑ7IÈ6×K^ÑK^Ó(_ˆÔ%Ø ×,Ñ,¨YÑ7ˆŒÜ1Ø×Ñ × 7Ñ 7À9ÐWXô
ˆŒô 1Ø×Ñ × 7Ñ 7À9ÐWXô
ˆ�r2   Nr9   r„   r»   r8   r�   r@   c                 ó  — |}| j                  |«      } | j                  d||||dœ|¤Ž\  }}| j                  |||¬«      }||z   }|}| j                  |«      }| j	                  |«      }| j                  |||¬«      }||z   }|S )N)r9   r„   r»   r8   r½   r1   )rd  ra  rg  re  rc  rh  )rI   r9   r„   r»   r8   r�   r[  r9  s           r3   rX   zInklingDecoderLayer.forward7  s²   € ð !ˆØ×,Ñ,¨]Ó;ˆØ)˜4Ÿ>™>ð 
Ø'Ø)ØØ+ñ	
ð
 ñ
Ñˆ�qð Ÿ™¨ÀÐbk˜ÓlˆØ  =Ñ0ˆà ˆØ×5Ñ5°mÓDˆØŸ™ Ó/ˆØŸ™ }ÀoÐaj˜ÓkˆØ  =Ñ0ˆØÐr2   )NNN)r*   r+   r,   r#   rw   rC   r.   r^   r   r   r   rX   r_   r`   s   @r3   r^  r^  "  s…   ø„ ð
Ð0ð 
¸Sõ 
ð. /3Ø)-Ø(,ñà—|‘|ðð Ÿ™ tÑ+ðð —<‘< $Ñ&ð	ð
  ™ðð Ð+Ñ,ðð 
�‰÷r2   r^  c                   óŠ   ‡ — e Zd ZeZdZdZdgZdgZdZ	dZ
dZdZdZdgZg d¢ZeedœZ ej(                  «       ˆ fd	„«       Zˆ xZS )
ÚInklingPreTrainedModelÚmodelTr^  r8   Fzmodel\.mtp\..*)rg  rh  r´   rµ   )r9   r:   c                 ó¤  •— t         ‰| �  |«       | j                  j                  «       j                  }t        |t        «      r#t        j                  |j                  d|¬«       y t        |t        «      r t        j                  |j                  «       y t        |t        «      rEt        j                  |j                  d|¬«       t        j                  |j                  d|¬«       y t        |t         «      rat        j                  |j"                  d|¬«       t        j                  |j                  «       t        j$                  |j&                  «       y t        |t(        «      rgt        j                  |j*                  d|¬«       t        j                  |j,                  d|¬«       t        j                  |j                  d|¬«       y t        |t.        «      rlt1        | j                  d| j                  «      }t        j2                  |j4                  t7        j8                  |j:                  «      |j<                  z  «       y y )Nrm   )rT   ÚstdÚaudio_config)rB   Ú_init_weightsr˜   Úget_text_configÚinitializer_rangeÚ
isinstancerb   ÚinitÚnormal_rh   rÙ   Úones_rá   ræ   rí   rÞ   r
  rG   Úzeros_r  r)  rÜ   rÝ   ÚInklingAudioModelEmbeddingsÚgetattrrB  Úaudio_tokens_offsetsr.   rÅ   Ú
n_mel_binsÚmel_vocab_size)rI   r€   rn  ro  rK   s       €r3   rp  z$InklingPreTrainedModel._init_weightsh  s�  ø€ ä‰Ñ˜fÔ%Ø�k‰k×)Ñ)Ó+×=Ñ=ˆÜ�fÔ3Ô4Ü�L‰L˜Ÿ™¨3°CÖ8Ü˜¤
Ô+Ü�J‰J�v×*Ñ*Õ+Ü˜¤Ô/Ü�L‰L˜×,Ñ,°3¸CÕ@Ü�L‰L˜×)Ñ)°¸Ö=Ü˜Ô 1Ô2Ü�L‰L˜Ÿ™¨S°cÕ:Ü�J‰J�v×*Ñ*Ô+Ü�K‰K˜×6Ñ6Õ7Ü˜Ô 4Ô5Ü�L‰L˜×)Ñ)°¸Õ=Ü�L‰L˜Ÿ™¨c°sÕ;Ü�L‰L˜×)Ñ)°¸Ö=Ü˜Ô ;Ô<ô # 4§;¡;°ÀÇÁÓLˆLÜ�J‰JØ×+Ñ+Ü—‘˜\×4Ñ4Ó5¸×8SÑ8SÑSõð	 =r2   )r*   r+   r,   r"   Úconfig_classÚ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Ú"_keys_to_ignore_on_load_unexpectedÚ_keep_in_fp32_modules_strictr^  r—   Ú_can_record_outputsr.   rõ   rp  r_   r`   s   @r3   rk  rk  S  s~   ø„ à €LØÐØ&*Ð#Ø.Ð/ÐØ#4Ð"5Ðð !ÐØ€NØÐØ"ÐØ"'ÐØ*;Ð)<Ð&Ú#TÐ à,Ø&ñÐð
 €U‡]�]ƒ_óó ôr2   rk  c                   óþ   ‡ — e Zd ZU eed<   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dz  d
ee   defd„«       «       «       Zˆ xZS )ÚInklingTextModelr˜   c           	      ó6  •— t         ‰| �  |«       |j                  | _        |j                  | _        t        j                  |j                  |j                  | j                  «      | _        t        j                  t        |j                  «      D �cg c]  }t        ||«      ‘Œ c}«      | _        t        |j                  |j                  ¬«      | _        t        |j                  |j                  ¬«      | _        d| _        | j'                  «        y c c}w )Nr    F)rB   rC   Úpad_token_idÚpadding_idxÚ
vocab_sizerD   Ú	EmbeddingrJ   Úembed_tokensÚ
ModuleListÚrangeÚnum_hidden_layersr^  rU  r>   r¶   ÚnormÚ
embed_normÚgradient_checkpointingÚ	post_initrº   s      €r3   rC   zInklingTextModel.__init__‰  sÔ   ø€ Ü‰Ñ˜Ô Ø!×.Ñ.ˆÔØ ×+Ñ+ˆŒäŸL™L¨×):Ñ):¸F×<NÑ<NÐPT×P`ÑP`ÓaˆÔÜ—m‘mÜEJÈ6×KcÑKcÓEdÖe¸	Ô  ¨Õ3Òeó
ˆŒô # 6×#5Ñ#5¸6×;NÑ;NÔOˆŒ	Ü(¨×);Ñ);À×ATÑATÔUˆŒØ&+ˆÔ#ð 	�‰Õùò fs   ÂDNÚ	input_idsr„   Úposition_idsr8   Úinputs_embedsÚ	use_cacher�   r@   c                 ó¼  — |d u |d uz  rt        d«      ‚|€ | j                  | j                  |«      «      }|r|€t        | j                  ¬«      }|€V|�|j                  «       nd}t        j                  |j                  d   |j                  ¬«      |z   }|j                  d«      }t        |x}	t        «      s3| j                  ||||dœ}
t        di |
¤Žt        di |
¤Žt        di |
¤Ždœ}	|}t!        | j"                  «      D ]8  \  }}| j                  j$                  |   dk(  rd	nd
} ||f|	|   |	d   |dœ|¤Ž}Œ: | j'                  |«      }t)        ||¬«      S )Nú:You must specify exactly one of input_ids or inputs_embeds)r˜   r   r    r¾   ©r˜   r›  r„   r8   rš  ©Úfull_attentionÚsliding_attentionÚlinear_attentionÚhybridr¡  r¢  r£  )r„   r»   r8   )Úlast_hidden_stater8   r1   )Ú
ValueErrorr–  r‘  r	   r˜   Úget_seq_lengthr.   rÅ   rZ   r¿   rD  rs  Údictr   r   r   Ú	enumeraterU  r¡   r•  r   )rI   r™  r„   rš  r8   r›  rœ  r�   Úpast_seen_tokensÚcausal_mask_mappingÚmask_kwargsr9   ÚiÚdecoder_layerÚattention_types                  r3   rX   zInklingTextModel.forward™  s˜  € ð ˜Ð -°tÐ";Ò<ÜÐYÓZÐZàÐ Ø ŸO™O¨D×,=Ñ,=¸iÓ,HÓIˆMá˜Ð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Ü$CÑ$RÀkÑ$Rñ#Ðð &ˆÜ )¨$¯+©+Ó 6ò 	ÑˆAˆ}Ø15·±×1HÑ1HÈÑ1KÈxÒ1WÑ-Ð]pˆNÙ)Øðà2°>ÑBØ-Ð.@ÑAØ /ñ	ð
 ñ‰Mð	ð Ÿ	™	 -Ó0ˆÜ&Ø+Ø+ô
ð 	
r2   )NNNNNN)r*   r+   r,   r#   r0   rC   r   r   r   r.   Ú
LongTensorr^   r   r/   Úboolr   r   r   rX   r_   r`   s   @r3   r‹  r‹  …  sÔ   ø… àÓðÐ0õ ð   ØØð .2Ø.2Ø04Ø(,Ø26Ø!%ñ6
à×#Ñ# dÑ*ð6
ð Ÿ™ tÑ+ð6
ð ×&Ñ&¨Ñ-ð	6
ð
  ™ð6
ð ×(Ñ(¨4Ñ/ð6
ð ˜$‘;ð6
ð Ð+Ñ,ð6
ð 
!ò6
ó ó ó  ô6
r2   r‹  c                   óP  ‡ — e Zd ZU i ZddiZddgdgfiZeed<   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e   defd„«       «       Zˆ xZS )ÚInklingForCausalLMÚlm_headÚrowwise_split_inputr9   r7   r˜   c                 óè   •— t         ‰| �  |«       t        |«      | _        |j                  | _        t        j                  |j                  |j                  d¬«      | _        | j                  «        y ©NFr�   )
rB   rC   r‹  rl  r�  rD   r¬   rJ   r´  r˜  râ   s     €r3   rC   zInklingForCausalLM.__init__Ý  sU   ø€ Ü‰Ñ˜Ô Ü% fÓ-ˆŒ
Ø ×+Ñ+ˆŒÜ—y‘y ×!3Ñ!3°V×5FÑ5FÈUÔSˆŒð 	�‰Õr2   Nr™  r„   rš  r8   r›  Úlabelsrœ  Úlogits_to_keepr�   r@   c	           
      óþ  —  | j                   d||||||dœ|	¤Ž}
|
j                  | j                  j                  z  }t	        |t
        «      rt        | d«      n|}| j                  |dd…|dd…f   «      }| j                  j                  }|�||j                  d   k  r	|dd|…f   }d}|�# | j                  d|||j                  d   dœ|	¤Ž}t        |||
j                  |
j                  |
j                  ¬«      S )a„  
        Example:

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

        >>> model = InklingForCausalLM.from_pretrained("google/gemma-2-9b")
        >>> tokenizer = AutoTokenizer.from_pretrained("google/gemma-2-9b")

        >>> 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?"
        ```)r™  r„   rš  r8   r›  rœ  NrN   .©r7   r¸  r�  )r6   r7   r8   r9   r:   r1   )rl  r¥  r˜   Úlogits_mup_width_multiplierrs  rw   Úslicer´  Úunpadded_vocab_sizerZ   Úloss_functionr5   r8   r9   r:   )rI   r™  r„   rš  r8   r›  r¸  rœ  r¹  r�   Úoutputsr9   Úslice_indicesr7   r¾  r6   s                   r3   rX   zInklingForCausalLM.forwardæ  s&  € ð> �$—*‘*ð 
ØØ)Ø%Ø+Ø'Øñ
ð ñ
ˆð  ×1Ñ1°D·K±K×4[Ñ4[Ñ[ˆä8BÀ>ÔSVÔ8Wœ˜~˜o¨tÔ4Ð]kˆØ—‘˜mªA¨}ºaÐ,?Ñ@ÓAˆØ"Ÿk™k×=Ñ=ÐØÐ*Ð/BÀVÇ\Á\ÐRTÑEUÒ/UØ˜CÐ!5Ð"5Ð!5Ð5Ñ6ˆFàˆØÐØ%�4×%Ñ%Ðj¨V¸FÈvÏ|É|Ð\^ÑO_ÑjÐciÑjˆDä,ØØØ#×3Ñ3Ø!×/Ñ/Ø×)Ñ)ô
ð 	
r2   )NNNNNNNr   )r*   r+   r,   Ú_tied_weights_keysÚ_tp_planÚ_pp_planr#   r0   rC   r   r   r.   r°  r^   r   r/   r±  rw   r   r   r5   rX   r_   r`   s   @r3   r³  r³  Õ  s!  ø… ð ÐØÐ0Ð1€HØ˜_Ð-°¨zÐ:Ð;€HØÓðÐ0õ ð Øð .2Ø.2Ø04Ø(,Ø26Ø*.Ø!%Ø-.ñ9
à×#Ñ# dÑ*ð9
ð Ÿ™ tÑ+ð9
ð ×&Ñ&¨Ñ-ð	9
ð
  ™ð9
ð ×(Ñ(¨4Ñ/ð9
ð × Ñ  4Ñ'ð9
ð ˜$‘;ð9
ð ˜eŸl™lÑ*ð9
ð Ð+Ñ,ð9
ð 
'ò9
ó ó ô9
r2   r³  c                   ó$   ‡ — e Zd Zˆ fd„Zd„ Zˆ xZS )rx  c                 ó  •— t         ‰| �  «        t        j                  |j                  |j
                  z  |j                  «      | _        | j                  dt        j                  |j                  «      |j
                  z  d¬«       y )Nrz  F)Ú
persistent)rB   rC   rD   r�  Únum_codebooksÚcodebook_sizerJ   Úembed_audio_tokensÚregister_bufferr.   rÅ   râ   s     €r3   rC   z$InklingAudioModelEmbeddings.__init__%  sn   ø€ Ü‰ÑÔÜ"$§,¡,°×0DÑ0DÀv×G[ÑG[Ñ0[Ð^d×^pÑ^pÓ"qˆÔØ×ÑØ"¤E§L¡L°×1EÑ1EÓ$FÈ×I]ÑI]Ñ$]Ðjoð 	õ 	
r2   c                 óf   — | j                  || j                  z   «      }|j                  d¬«      }|S )Nrò   ró   )rÊ  rz  rù   )rI   r™  r›  s      r3   rX   z#InklingAudioModelEmbeddings.forward,  s6   € Ø×/Ñ/°	¸D×<UÑ<UÑ0UÓVˆØ%×)Ñ)¨bÐ)Ó1ˆØÐr2   r1  r`   s   @r3   rx  rx  $  s   ø„ ô
ör2   rx  c                   ó\   ‡ — e Zd Zdefˆ fd„Zdej                  dej                  fd„Zˆ xZS )ÚInklingAudioModelr˜   c                 ó|   •— t         ‰| �  |«       t        |«      | _        t	        |j
                  d¬«      | _        y )Nr\   r    )rB   rC   rx  rÊ  r>   Útext_hidden_sizer•  râ   s     €r3   rC   zInklingAudioModel.__init__3  s1   ø€ Ü‰Ñ˜Ô Ü"=¸fÓ"EˆÔÜ" 6×#:Ñ#:ÀÔEˆ�	r2   Úaudio_input_idsr@   c                 ó`   — | j                  |«      }| j                  |«      }t        ||¬«      S )N©r¥  Úpooler_output)rÊ  r•  r   )rI   rÑ  r9   s      r3   rX   zInklingAudioModel.forward8  s3   € Ø×/Ñ/°Ó@ˆØŸ	™	 -Ó0ˆÜ)Ø+Ø'ô
ð 	
r2   )	r*   r+   r,   r!   rC   r.   r^   rX   r_   r`   s   @r3   rÎ  rÎ  2  s-   ø„ ðFÐ1õ Fð

 u§|¡|ð 
¸¿¹÷ 
r2   rÎ  c            
       ó¤   ‡ — e Zd Zdedede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	ˆ xZ
S )ÚInklingVisionEncoderLayerÚ	input_dimÚ
output_dimÚt_foldÚhw_foldÚadd_normc                 óª   •— t         ‰| �  «        t        j                  ||d¬«      | _        |rt        |«      | _        || _        || _        || _	        y r·  )
rB   rC   rD   r¬   Ú
projectionr>   Ú
layer_normrÚ  rÙ  rÛ  )rI   r×  rØ  rÙ  rÚ  rÛ  rK   s         €r3   rC   z"InklingVisionEncoderLayer.__init__B  sF   ø€ Ü‰ÑÔÜŸ)™) I¨zÀÔFˆŒÙÜ,¨ZÓ8ˆDŒOØˆŒØˆŒØ ˆ�r2   r9   r@   c           
      ó˜  — |j                   \  }}}}}|| j                  z  }|| j                  z  }|| j                  z  }	|j                  ||| j                  || j                  |	| j                  |«      }|j	                  dddddddd«      }|j                  ||||	| j                  | j                  z  | j                  z  |z  «      }|S )	z€
        Convert a tensor of shape (B, T, H, W, C) to a tensor of shape (B, T // t, H // hw, W //  hw, C * (t * hw**2))
        r   r    r   é   rM   é   é   é   )rZ   rÙ  rÚ  rz   r÷   )
rI   r9   ÚBÚTÚHÚWÚCÚt_newÚh_newÚw_news
             r3   Úfold_timespace_to_depthz1InklingVisionEncoderLayer.fold_timespace_to_depthK  sÐ   € ð &×+Ñ+‰ˆˆ1ˆa��Aà�T—[‘[Ñ ˆØ�T—\‘\Ñ!ˆØ�T—\‘\Ñ!ˆà%×-Ñ-¨a°¸¿¹ÀUÈDÏLÉLÐZ_Ðae×amÑamÐopÓqˆà%×-Ñ-¨a°°A°q¸!¸QÀÀ1ÓEˆØ%×-Ñ-¨a°¸¸uÀdÇkÁkÐTX×T`ÑT`ÑF`Ðcg×coÑcoÑFoÐrsÑFsÓtˆØÐr2   c                 óê   — | j                   dkD  s| j                  dkD  r| j                  |«      }| j                  |«      }| j                  r&| j                  |«      }t        j                  |«      }|S r  )rÚ  rÙ  rì  rÝ  rÛ  rÞ  r  Úgelurä   s     r3   rX   z!InklingVisionEncoderLayer.forward[  s_   € Ø�<‰<˜!Ò˜tŸ{™{¨QšØ ×8Ñ8¸ÓGˆMàŸ™¨Ó6ˆØ�=Š=Ø ŸO™O¨MÓ:ˆMÜŸF™F =Ó1ˆMØÐr2   )r*   r+   r,   rw   r±  rC   r.   r^   rì  rX   r_   r`   s   @r3   rÖ  rÖ  A  sb   ø„ ð! #ð !°3ð !Àð !Ècð !Ð]aõ !ð°U·\±\ð ÀeÇlÁló ð  U§\¡\ð °e·l±l÷ r2   rÖ  Únumberc                 ó$  — g }| dz  dk(  r|j                  d«       | dz  } | dz  dk(  rŒt        dt        j                  | «      dz   d«      D ]*  }| |z  dk(  sŒ|j                  |«       | |z  } | |z  dk(  rŒŒ, | dkD  r|j                  | «       |S )NrM   r   r   r    )Úappendr“  ÚmathÚisqrt)rï  Úfactorsr‰   s      r3   Úprime_factorsrõ  f  s£   € Ø€Gà
�1‰*˜Š/Ø�‰�qÔØ�1‰ˆð �1‰*˜‹/ô �1”d—j‘j Ó(¨1Ñ,¨aÓ0ò ˆØ�q‰j˜A‹oØ�N‰N˜1ÔØ�q‰LˆFð �q‰j˜AŒoðð
 �‚zØ�‰�vÔØ€Nr2   Útemporal_patch_sizeÚ
patch_sizeÚn_layersÚ
n_channelsc           	      ó°  — t        j                  t        j                  t        |«      ddd…   |¬«      d¬«      }t        j                  t        j                  t        | «      ddd…   |¬«      d¬«      }t        j                  |dz  |z  dz  «      j                  «       dz  }t        j                  |d   dz  |z  |z  «      j                  «       dz  }t        j                  ddd|gg|¬«      }	t        j                  t        j                  |«      |||gd¬«      }
t        j                  |t        j                  ||d   «      t        j                  ||d   «      |gd¬«      }t        j                  |	|
|gd¬«      }t        j                  |dd…dd…f   d¬«      j                  «       }||z  | z  |z  }t        j                  dt        j                  t        j                  ||¬«      «      |dz   |¬«      }t        j                  |j                  d«      t        j                  |«      j                  d«      z
  «      }||j                   d   k\  rt        j"                  |d¬«      }nDdd	lm}  ||j)                  «       j+                  «       «      \  }}t        j                  ||¬«      }d|d<   |j                   d   dz
  |d<   ||   S )
a  
    Plan out the dimensions for each layer in the HMLP encoder.

    This function determines the progression of dimensions (temporal, height, width, channels)
    for a multi-layer perceptual model that processes image/video patches. It follows these
    principles:
    1. Start with small dimensions and increase to full size
    2. Expand spatial dimensions (height/width) first, then temporal
    3. Increase channel count to avoid information bottlenecks
    4. Round channel dimensions to multiples of 64 for hardware efficiency

    The function computes optimal assignments of scale configurations to layers using either:
    - For n_layers >= len(scales): Individual best matching scales for each layer (allowing duplicates)
    - For n_layers < len(scales): Global optimal assignment via linear_sum_assignment

    The first and last scales are always fixed to ensure the proper input and output dimensions.

    Args:
        temporal_patch_size: Temporal dimension of input patches
        patch_size: Spatial dimension (height/width) of input patches
        n_layers: Number of layers in the encoder
        n_channels: Number of input channels (default: 3 for RGB)

    Returns:
        torch.LongTensor of shape `(n_layers + 1, 4)` where the last dim holds values for (t, h, w, c) grids.
    NrN   r¾   r   ró   rM   é@   r    )Úlinear_sum_assignment)r.   ÚcumprodÚtensorrõ  Úceilrw   ÚstackÚ	ones_likeÚ	full_liker  Úprodr]   ÚlinspacerÈ   ÚabsrD  rZ   ÚargminÚscipy.optimizerü  ÚcpuÚnumpy)rö  r÷  rø  rù  r¿   ÚhÚtÚh_chÚt_chÚbaseÚspatialÚtemporalÚscalesÚsize_reductionÚtotal_elementsÚlog_ideal_scalesÚcost_matrixÚidxsrü  r9  Úidxs_nps                        r3   Úplan_out_scalesr  w  s]  € ô: 	�‰”e—l‘l¤=°Ó#<¹T¸r¸TÑ#BÈ6ÔRÐXYÔZ€AÜ�‰”e—l‘l¤=Ð1DÓ#EÁdÈÀdÑ#KÐTZÔ[ÐabÔc€Aä�:‰:�a˜‘d˜ZÑ'¨"Ñ,Ó-×1Ñ1Ó3°bÑ8€DÜ�:‰:�a˜‘e˜q‘j :Ñ-°Ñ1Ó2×6Ñ6Ó8¸2Ñ=€Dä�<‰<˜!˜Q  :Ð.Ð/¸Ô?€DÜ�k‰kœ5Ÿ?™?¨1Ó-¨q°!°TÐ:ÀÔB€GÜ�{‰{˜AœuŸ™¨q°!°B±%Ó8¼%¿/¹/È!ÈQÈrÉUÓ:SÐUYÐZÐ`aÔb€HÜ�Y‰Y˜˜g xÐ0°aÔ8€Fä—Z‘Z ¢q¨#¨2¨# v¡°AÔ6×<Ñ<Ó>€Nà *Ñ,Ð/BÑBÀZÑO€NÜ—~‘~Ø	Œ5�9‰9”U—\‘\ .¸Ô@ÓAÀ8ÈaÁ<ÐX^ôÐô —)‘)Ð,×6Ñ6°qÓ9¼E¿I¹IÀnÓ<U×<_Ñ<_Ð`aÓ<bÑbÓc€Kà�6—<‘< ‘?Ò"Ü�|‰|˜K¨QÔ/‰å8á*¨;¯?©?Ó+<×+BÑ+BÓ+DÓE‰
ˆˆ7Ü�|‰|˜G¨FÔ3ˆð €Dˆ�GØ�|‰|˜A‰ Ñ"€Dˆ�HØ�$‰<Ðr2   c                   óf   ‡ — e Zd Zdefˆ fd„Zdej                  dee   dej                  fd„Z	ˆ xZ
S )ÚInklingVisionModelr˜   c                 óÊ  •— t         ‰	| �  |«       t        |j                  |j                  |j
                  |j                  «      | _        t        j                  «       | _
        t        t        | j                  d d | j                  dd  «      «      D ]£  \  }\  }}|d   |d   z  |d   |d   z  z  |d   |d   z  z  }||j
                  dz
  k(  r|j                  n|d   }|d   |d   z  }|d   |d   z  }| j                  j                  t        |d   |z  |||||j
                  dz
  k7  ¬«      «       Œ¥ t!        |j                  «      | _        | j%                  «        y )NrN   r    r   rM   r   )r×  rØ  rÚ  rÙ  rÛ  )rB   rC   r  rö  r÷  r”  Únum_channelsr  rD   r’  Úencoder_layersr©  ÚziprÐ  rñ  rÖ  r>   Ú
final_normr˜  )
rI   r˜   r­  Ústart_scaleÚ	end_scaleÚshuffle_multrØ  rÚ  rÙ  rK   s
            €r3   rC   zInklingVisionModel.__init__¶  s{  ø€ Ü‰Ñ˜Ô Ü%Ø×&Ñ&Ø×ÑØ×$Ñ$Ø×Ñó	
ˆŒô !Ÿm™m›oˆÔÜ+4´S¸¿¹ÀSÀbÐ9IÈ4Ï;É;ÐWXÐWYÈ?Ó5[Ó+\ò 	Ñ'ˆAÑ'�˜Yà˜1‘ ¨Q¡Ñ/°I¸a±LÀKÐPQÁNÑ4RÑSÐW`ÐabÑWcÐgrÐstÑguÑWuÑvð ð 56¸×9QÑ9QÐTUÑ9UÒ4U˜×0Ò0Ð[dÐefÑ[gˆJØ ‘l k°!¡nÑ4ˆGØ˜q‘\ [°¡^Ñ3ˆFØ×Ñ×&Ñ&Ü)Ø)¨!™n¨|Ñ;Ø)Ø#Ø!Ø &×":Ñ":¸QÑ">Ñ>ôõð	ô" )¨×)@Ñ)@ÓAˆŒØ�‰Õr2   Úpixel_valuesr�   r@   c                 ó¸   — |j                   d   }|}| j                  D ]  } ||¬«      }Œ | j                  |«      }|j                  |d«      }t	        ||¬«      S )Nr   )r9   rN   rÓ  )rZ   r  r  rz   r   )rI   r#  r�   Únum_patchesr9   Úlayers         r3   rX   zInklingVisionModel.forwardÕ  sk   € Ø"×(Ñ(¨Ñ+ˆØ$ˆØ×(Ñ(ò 	?ˆEÙ!°Ô>‰Mð	?ð Ÿ™¨Ó6ˆØ%×-Ñ-¨k¸2Ó>ˆÜ)Ø+Ø'ô
ð 	
r2   )r*   r+   r,   r$   rC   r.   r^   r   r   rX   r_   r`   s   @r3   r  r  µ  s;   ø„ ðÐ2õ ð>
 E§L¡Lð 
¸FÐCUÑ<Vð 
Ð[`×[gÑ[g÷ 
r2   r  zz
    The Base Inkling model which consists of a vision backbone and a language model without language modeling head.,
    c                   óª  ‡ — e Zd ZdZdefˆ fd„Ze ed¬«      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z  fd„«       «       Zdej                  dej                  dej                  d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dz  dej                  dz  dej                  dz  dej                  dz  dedz  de
e   deez  fd„«       «       Zˆ xZS )ÚInklingModelFr˜   c                 ó  •— t         ‰| �  |«       |j                  j                  | _        t	        |j                  «      | _        t        |j                  «      | _        t        |j                  «      | _        | j                  «        y rf   )rB   rC   Útext_configr�  r‹  Úlanguage_modelrÎ  ro  Úaudio_towerr  Úvision_configÚvision_towerr˜  râ   s     €r3   rC   zInklingModel.__init__ì  sf   ø€ Ü‰Ñ˜Ô Ø ×,Ñ,×7Ñ7ˆŒÜ.¨v×/AÑ/AÓBˆÔÜ,¨V×-@Ñ-@ÓAˆÔÜ.¨v×/CÑ/CÓDˆÔØ�‰Õr2   zOProjects the last hidden state from the vision model into language model space.r%   r#  r�   r@   c                 ó*   —  | j                   dd|i|¤ŽS )Nr#  r1   )r.  ©rI   r#  r�   s      r3   Úget_image_featureszInklingModel.get_image_featuresô  s   € ð
 !ˆt× Ñ ÑE¨lÐE¸fÑEÐEr2   zCProjects discretized dMel bin tokens into the language model space.NrÑ  Úaudio_input_ids_maskc                 óŽ   — |�||j                  «          }n|j                  d|j                  d   «      }| j                  |«      S )aì  
        audio_input_ids (`torch.LongTensor` of shape `(num_audios, max_num_frames, n_mel_bins)`):
            Batch of (padded) dMel bin tokens produced by [`InklingProcessor`].
        audio_input_ids_mask (`torch.Tensor` of shape `(num_audios, max_num_frames)`, *optional*):
            Mask marking valid (non-padding) frames. When provided, only valid frames are encoded so that the
            number of returned audio embeddings matches the number of audio placeholder tokens.
        rN   )r±  rz   rZ   r,  )rI   rÑ  r2  s      r3   Úget_audio_featureszInklingModel.get_audio_featuresû  sM   € ð  Ð+Ø-Ð.B×.GÑ.GÓ.IÑJ‰Oà-×5Ñ5°b¸/×:OÑ:OÐPRÑ:SÓTˆOØ×Ñ Ó0Ð0r2   r™  r›  ÚfeaturesÚtoken_idc                 óÚ  — |€Y| | j                  «       t        j                  |t        j                  |j                  ¬«      «      k(  }|j                  d«      }n||k(  }|j                  «       }|j                  d«      j                  |«      j                  |j                  «      }t        ||   j                  «       |j                  «       k(  d|› d|j                  d   › �«       |S )zö
        Obtains a multimodal placeholder mask from `input_ids` or `inputs_embeds` for the given `token_id`, and checks
        that the placeholder token count matches the length of `features`. If the lengths differ, an error is raised.
        )rP   r¿   rN   zAMultimodal features and placeholder tokens do not match, tokens: z, features: r   )Úget_input_embeddingsr.   rþ  Úlongr¿   Úallrù   rD  Ú	expand_asrQ   r   ÚnumelrZ   )rI   r™  r›  r5  r6  Úspecial_maskÚn_tokenss          r3   Úget_placeholder_maskz!InklingModel.get_placeholder_mask  sä   € ð ÐØ(Ð,G¨D×,EÑ,EÓ,GÜ—‘˜X¬U¯Z©ZÀ×@TÑ@TÔUó-ñ ˆLð (×+Ñ+¨BÓ/‰Là$¨Ñ0ˆLà×#Ñ#Ó%ˆØ#×-Ñ-¨bÓ1×;Ñ;¸MÓJ×MÑMÈm×NbÑNbÓcˆÜØ˜,Ñ'×-Ñ-Ó/°8·>±>Ó3CÑCØOÐPXÈzÐYeÐfn×ftÑftÐuvÑfwÐexÐyô	
ð Ðr2   r„   rš  r8   Útoken_type_idsr¸  rœ  Ú	lm_kwargsc           	      óÞ  — |du |	duz  rt        d«      ‚|	€/| j                  j                   | j                  «       |«      «      }	|�{| j	                  |«      j
                  }|j                  |	j                  |	j                  «      }| j                  ||	|| j                  j                  «      }|	j                  ||«      }	d}|�|| j                  ||«      j                  }|j                  |	j                  |	j                  «      }| j                  ||	|| j                  j                  «      }|	j                  ||«      }	t!        |x}t"        «      sA| j                  j%                  «       |	|||dœ}t'        di |¤Žt)        di |¤Žt+        di |¤Ždœ} | j                  d||||	|dœ|¤Ž}t-        |j                  |j.                  |j0                  |j2                  |�¬«      S d¬«      S )a/  
        audio_input_ids (`torch.LongTensor` of shape `(num_audios, max_num_frames, n_mel_bins)`, *optional*):
            Batch of (padded) discretized dMel bin tokens produced by [`InklingProcessor`].
        audio_input_ids_mask (`torch.Tensor` of shape `(num_audios, max_num_frames)`, *optional*):
            Mask marking valid (non-padding) audio frames in `audio_input_ids`.
        labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
            Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,
            config.text_config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored
            (masked), the loss is only computed for the tokens with labels in `[0, ..., config.text_config.vocab_size]`.

        Example:

        ```python
        >>> from PIL import Image
        >>> import httpx
        >>> from io import BytesIO
        >>> from transformers import AutoProcessor, InklingForConditionalGeneration

        >>> model = InklingForConditionalGeneration.from_pretrained("google/inkling2-3b-mix-224")
        >>> processor = AutoProcessor.from_pretrained("google/inkling2-3b-mix-224")

        >>> prompt = "Where is the cat standing?"
        >>> url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"
        >>> with httpx.stream("GET", url) as response:
        ...     image = Image.open(BytesIO(response.read()))

        >>> inputs = processor(images=image, text=prompt,  return_tensors="pt")

        >>> # Generate
        >>> generate_ids = model.generate(**inputs,)
        >>> processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
        "Where is the cat standing?\nsnow"
        ```Nrž  rŸ  r   )r„   rš  r8   r›  rœ  )r¥  r8   r9   r:   r)   r1   )r¦  r+  r–  r8  r1  rÔ  rQ   r¿   rP   r?  r˜   Úimage_token_idÚmasked_scatterr4  r¥  Úaudio_token_idrs  r¨  rq  r   r   r   r(   r8   r9   r:   )rI   r™  r#  rÑ  r2  r„   rš  r8   r@  r›  r¸  rœ  rA  Úimage_featuresÚspecial_image_maskÚaudio_featuresÚspecial_audio_maskr«  r¬  rÀ  s                       r3   rX   zInklingModel.forward*  s!  € ðd ˜Ð -°tÐ";Ò<ÜÐYÓZÐZàÐ Ø ×/Ñ/×:Ñ:Ð;V¸4×;TÑ;TÓ;VÐW`Ó;aÓbˆMð Ð#Ø!×4Ñ4°\ÓB×PÑPˆNØ+×.Ñ.¨}×/CÑ/CÀ]×EXÑEXÓYˆNØ!%×!:Ñ!:Ø˜=¨.¸$¿+¹+×:TÑ:Tó"Ðð *×8Ñ8Ð9KÈ^Ó\ˆMð ˆØÐ&Ø!×4Ñ4°_ÐFZÓ[×mÑmˆNØ+×.Ñ.¨}×/CÑ/CÀ]×EXÑEXÓYˆNØ!%×!:Ñ!:Ø˜=¨.¸$¿+¹+×:TÑ:Tó"Ðð *×8Ñ8Ð9KÈ^Ó\ˆMô °Ð?Ð-ÄÔFàŸ+™+×5Ñ5Ó7Ø!.Ø"0Ø#2Ø ,ñˆKô #5Ñ"C°{Ñ"CÜ%FÑ%UÈÑ%UÜ$CÑ$RÀkÑ$Rñ#Ðð &�$×%Ñ%ð 
Ø.Ø%Ø+Ø'Øñ
ð ñ
ˆô *Ø%×7Ñ7Ø#×3Ñ3Ø!×/Ñ/Ø×)Ñ)Ø2>Ð2J ô
ð 	
ð
 QUô
ð 	
r2   rf   )NNNNNNNNNNN)r*   r+   r,   Úaccepts_loss_kwargsr"   rC   r   r   r.   r/   r   r   r;   r   r1  r°  r^   r4  rw   r?  r   r±  r(   rX   r_   r`   s   @r3   r(  r(  ã  s@  ø„ ð  Ðð˜}õ ð ÙÐ!rÔsðFØ!×-Ñ-ðFØ9?Ð@RÑ9SðFà	Ð+Ñ	+òFó tó ðFð
 ÙÐ!fÔgð 59ñ1à×)Ñ)ð1ð $Ÿl™l¨TÑ1ð1ð 
Ð+Ñ	+ò	1ó hó ð1ð$à×#Ñ#ðð ×(Ñ(ðð ×#Ñ#ð	ð
 óð6 Øð .2Ø15Ø37Ø48Ø.2Ø04Ø(,Ø26Ø26Ø*.Ø!%ñh
à×#Ñ# dÑ*ðh
ð ×'Ñ'¨$Ñ.ðh
ð ×)Ñ)¨DÑ0ð	h
ð
 $Ÿl™l¨TÑ1ðh
ð Ÿ™ tÑ+ðh
ð ×&Ñ&¨Ñ-ðh
ð  ™ðh
ð ×(Ñ(¨4Ñ/ðh
ð ×(Ñ(¨4Ñ/ðh
ð × Ñ  4Ñ'ðh
ð ˜$‘;ðh
ð Ð.Ñ/ðh
ð 
Ð+Ñ	+òh
ó ó ôh
r2   r(  c                   óô  ‡ — e Zd Zi ZddiZdZdefˆ fd„Zede	j                  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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e	j                   z  dee   deez  fd„«       «       Z	 	 	 	 	 	 	 	 	 	 	 dˆ fd„	Zˆ xZS )ÚInklingForConditionalGenerationr´  rµ  Fr˜   c                 óî   •— t         ‰| �  |«       t        |«      | _        t	        j
                  |j                  j                  |j                  j                  d¬«      | _	        | j                  «        y r·  )rB   rC   r(  rl  rD   r¬   r*  rJ   r�  r´  r˜  râ   s     €r3   rC   z(InklingForConditionalGeneration.__init__¤  sU   ø€ Ü‰Ñ˜Ô Ü! &Ó)ˆŒ
ô —y‘y ×!3Ñ!3×!?Ñ!?À×ASÑAS×A^ÑA^ÐejÔkˆŒØ�‰Õr2   r#  r�   c                 ó<   —  | j                   j                  |fi |¤ŽS rf   )rl  r1  r0  s      r3   r1  z2InklingForConditionalGeneration.get_image_features¬  s   € à,ˆt�z‰z×,Ñ,¨\ÑD¸VÑDÐDr2   Nr™  r„   rš  r8   rÑ  r2  r›  r¸  rœ  r¹  r@   c                 ó6  —  | j                   d|||||||||
|	dœ
|¤Ž}|d   | j                  j                  j                  z  }t	        |t
        «      rt        | d«      n|}| j                  |dd…|dd…f   «      }| j                  j                  j                  }|�||j                  d   k  r	|dd|…f   }d}|	�# | j                  d||	|j                  d   dœ|¤Ž}t        |||j                  |j                  |j                  |j                  ¬«      S )	a€	  
        audio_input_ids (`torch.LongTensor` of shape `(num_audios, max_num_frames, n_mel_bins)`, *optional*):
            Batch of (padded) discretized dMel bin tokens produced by [`InklingProcessor`].
        audio_input_ids_mask (`torch.Tensor` of shape `(num_audios, max_num_frames)`, *optional*):
            Mask marking valid (non-padding) audio frames in `audio_input_ids`.
        labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
            Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,
            config.text_config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored
            (masked), the loss is only computed for the tokens with labels in `[0, ..., config.text_config.vocab_size]`.

        Example:

        ```python
        >>> from PIL import Image
        >>> import httpx
        >>> from io import BytesIO
        >>> from transformers import AutoProcessor, InklingForConditionalGeneration

        >>> model = InklingForConditionalGeneration.from_pretrained("google/gemma-3-4b-it")
        >>> processor = AutoProcessor.from_pretrained("google/gemma-3-4b-it")

        >>> messages = [
        ...     {
        ...         "role": "system",
        ...         "content": [
        ...             {"type": "text", "text": "You are a helpful assistant."}
        ...         ]
        ...     },
        ...     {
        ...         "role": "user", "content": [
        ...             {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
        ...             {"type": "text", "text": "Where is the cat standing?"},
        ...         ]
        ...     },
        ... ]

        >>> inputs = processor.apply_chat_template(
        ...     messages,
        ...     tokenize=True,
        ...     return_dict=True,
        ...     return_tensors="pt",
        ...     add_generation_prompt=True
        ... )
        >>> # Generate
        >>> generate_ids = model.generate(**inputs)
        >>> processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
        "user\nYou are a helpful assistant.\n\n\n\n\n\nWhere is the cat standing?\nmodel\nBased on the image, the cat is standing in a snowy area, likely outdoors. It appears to"
        ```
        )
r™  r#  rÑ  r2  r„   rš  r8   r›  rœ  r¸  r   NrN   .r»  )r6   r7   r8   r9   r:   r)   r1   )rl  r˜   r*  r¼  rs  rw   r½  r´  r¾  rZ   r¿  r5   r8   r9   r:   r)   )rI   r™  r#  r„   rš  r8   rÑ  r2  r›  r¸  rœ  r¹  r�   rÀ  r9   rÁ  r7   r¾  r6   s                      r3   rX   z'InklingForConditionalGeneration.forward°  sF  € ðD �$—*‘*ð 
ØØ%Ø+Ø!5Ø)Ø%Ø+Ø'ØØñ
ð ñ
ˆð   ™
 T§[¡[×%<Ñ%<×%XÑ%XÑXˆä8BÀ>ÔSVÔ8Wœ˜~˜o¨tÔ4Ð]kˆØ—‘˜mªA¨}ºaÐ,?Ñ@ÓAˆØ"Ÿk™k×5Ñ5×IÑIÐØÐ*Ð/BÀVÇ\Á\ÐRTÑEUÒ/UØ˜CÐ!5Ð"5Ð!5Ð5Ñ6ˆFàˆØÐØ%�4×%Ñ%Ðj¨V¸FÈvÏ|É|Ð\^ÑO_ÑjÐciÑjˆDä,ØØØ#×3Ñ3Ø!×/Ñ/Ø×)Ñ)Ø '× ;Ñ ;ô
ð 	
r2   c                 ó^   •— t        ‰| �  |f|||||	|
|dœ|¤Ž}|s|	s||d<   ||d<   ||d<   |S )N)r8   r›  r„   rš  rœ  r¹  Úis_first_iterationr#  rÑ  r2  )rB   Úprepare_inputs_for_generation)rI   r™  r8   r›  rš  r#  r„   rÑ  r2  rœ  r¹  r¸  rQ  r�   Úmodel_inputsrK   s                  €r3   rR  z=InklingForConditionalGeneration.prepare_inputs_for_generation  sh   ø€ ô" ‘wÑ<Øð

à+Ø'Ø)Ø%ØØ)Ø1ñ

ð ñ

ˆñ ¡YØ+7ˆL˜Ñ(Ø.=ˆLÐ*Ñ+Ø3GˆLÐ/Ñ0àÐr2   )NNNNNNNNNNr   )NNNNNNNTNNF)r*   r+   r,   rÂ  rÃ  rJ  r"   rC   r   r.   r/   r   r   r1  r   r°  r^   r   r±  rw   r;   r5   rX   rR  r_   r`   s   @r3   rL  rL  —  sÉ  ø„ ð ÐØÐ0Ð1€Hð  Ðð˜}õ ð ðE¨u×/@Ñ/@ð EÈFÐSeÑLfò Eó ðEð Øð .2Ø15Ø.2Ø04Ø(,Ø37Ø48Ø26Ø*.Ø!%Ø-.ña
à×#Ñ# dÑ*ða
ð ×'Ñ'¨$Ñ.ða
ð Ÿ™ tÑ+ð	a
ð
 ×&Ñ&¨Ñ-ða
ð  ™ða
ð ×)Ñ)¨DÑ0ða
ð $Ÿl™l¨TÑ1ða
ð ×(Ñ(¨4Ñ/ða
ð × Ñ  4Ñ'ða
ð ˜$‘;ða
ð ˜eŸl™lÑ*ða
ð Ð+Ñ,ða
ð 
Ð.Ñ	.òa
ó ó ða
ðL ØØØØØØ!ØØØØ ÷"ñ "r2   rL  )rk  r‹  r³  rÎ  r  r(  rL  )rm   Nr×   )r  )^rò  Úcollections.abcr   Údataclassesr   r.   Útorch.nnrD   Útorch.nn.functionalr�   r  Ú r   rt  Úactivationsr   Úcache_utilsr   r	   Ú
generationr
   Úintegrationsr   r   r   r   Úintegrations.accelerater   Úmasking_utilsr   r   r   Úmodeling_layersr   Úmodeling_outputsr   r   Úmodeling_utilsr   r   Úprocessing_utilsr   Úutilsr   r   r   r   r   Úutils.genericr   Úutils.output_capturingr   Úconfiguration_inklingr!   r"   r#   r$   r(   r5   ÚModuler>   rb   r^   rw   r   r]   r•   r—   rÙ   ræ   r
  r)  r3  r;  rE   Ústrr<  rH  r²   r^  rk  r‹  r³  rx  rÎ  rÖ  Úlistrõ  r°  r  r  r(  rL  Ú__all__r1   r2   r3   ú<module>rk     sV  ðó, Ý $Ý !ã Ý ß Ð å &Ý !ß .Ý )÷ó õ >ß sÑ sÝ 9ß Sß FÝ &ß nÕ nÝ 7Ý 5ß lÓ lñ ðôð
 ô9Ð!8ó 9ó óð9ñ ðôð
 ô9 Kó 9ó óð9ñ0 ˜YÓ'ôJ�R—Y‘Yó Jó (ðJô(^˜BŸI™Iô ^ð4	U˜UŸ\™\ð 	U°#ð 	U¸%¿,¹,ó 	Uð& Ø)-ñ%Ø�I‰Ið%à�<‰<ð%ð 
�‰ð%ð �<‰<ð	%ð
 —L‘L 4Ñ'ð%ð ð%ð ð%ð —<‘< $Ñ&ó%ô8a)�r—y‘yô a)ôH1�—‘ô 1ð" ô$#�R—Y‘Yó $#ó ð$#ôN#H˜Ÿ	™	ô #HôL%˜2Ÿ9™9ô %ô8�—‘ô ò(	ñ Ð0Ó1ð
 !%Ø!ñ'Ø—<‘<ð'à—‘ð'ð �L‰Lð'ð �,‰,˜Ñ
ð	'ð
 �d‘
ò'ó 2ð'ñ& Ð,Ó-ð !%Ø!ñ	'Ø—<‘<ð'à�L‰Lð'ð �,‰,˜Ñ
ð'ð �d‘
ò	'ó .ð'ñ, Ð*Ð,<Ð=Ó>ô;˜bŸi™ió ;ó ?ð;ô|.Ð4ô .ðb ô.˜_ó .ó ð.ðb ôL
Ð-ó L
ó ðL
ð^ ôK
Ð/°ó K
ó ðK
ô\ "§)¡)ô ô
Ð.ô 
ô" §	¡	ô "ðJ˜#ð  $ s¡)ó ð$ W\ñ;Øð;Ø*-ð;Ø9<ð;ØJMð;à
×Ñó;ô|+
Ð/ô +
ñ\ ðôô
l
Ð)ó l
óð
l
ñ^ ðôô
[Ð&<¸oó [óð
[ò|�r2   