Ë
    ÛÓ^j-~  ã                   óä  — 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mZ dd	l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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%m&Z& ddl'm(Z( ddl)m*Z* ddl+m,Z,m-Z-  G d„ dej\                  «      Z/ G d„ dej\                  «      Z0d„ Z1 ed«      dBd„«       Z2dejf                  de4d ejf                  fd!„Z5	 dCd"ej\                  d#ejf                  d$ejf                  d%ejf                  d&ejf                  dz  d'e6d(e6d)ee!   fd*„Z7 ee2«       G d+„ d,ej\                  «      «       Z8 G d-„ d.ej\                  «      Z9 G d/„ d0ej\                  «      Z: G d1„ d2e«      Z;e" G d3„ d4e«      «       Z< e"d5¬6«      e G d7„ d8e«      «       «       Z= e"d9¬6«       G d:„ d;e<«      «       Z>e G d<„ d=e «      «       Z? e"d>¬6«       G d?„ d@e<e«      «       Z@g dA¢ZAy)Dé    )ÚCallable)Ú	dataclass)ÚOptionalN)Únné   )ÚACT2FN)ÚCompileConfigÚGenerationMixin)Úuse_kernel_func_from_hubÚuse_kernelized_func)Úcreate_bidirectional_mask)ÚGradientCheckpointingLayer)ÚBaseModelOutputWithPoolingÚCausalLMOutput)ÚROPE_INIT_FUNCTIONSÚdynamic_rope_update)ÚALL_ATTENTION_FUNCTIONSÚPreTrainedModel)ÚUnpack)ÚModelOutputÚTransformersKwargsÚauto_docstringÚcan_return_tuple)Úmaybe_autocastÚmerge_with_config_defaults)Úcapture_outputsé   )Ú	AutoModelé   )ÚLasrCTCConfigÚLasrEncoderConfigc                   ó\   ‡ — e Zd Zdefˆ fd„Zdej                  dej                  fd„Zˆ xZS )ÚLasrEncoderSubsamplingÚconfigc                 ó(  •— t         ‰| �  «        t        j                  |j                  |j
                  «      | _        t        j                  |j
                  |j
                  |j                  |j                  ¬«      | _
        t        j                  |j
                  |j                  |j                  |j                  ¬«      | _        t        j                  |j                  |j
                  «      | _        t        j                  «       | _        y )N)Úkernel_sizeÚstride)ÚsuperÚ__init__r   ÚLinearÚnum_mel_binsÚhidden_sizeÚdense_0ÚConv1dÚsubsampling_conv_kernel_sizeÚsubsampling_conv_strideÚconv_0Úsubsampling_conv_channelsÚconv_1Údense_1ÚReLUÚact_fn©Úselfr$   Ú	__class__s     €úq/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/transformers/models/lasr/modeling_lasr.pyr)   zLasrEncoderSubsampling.__init__-   sÃ   ø€ Ü‰ÑÔÜ—y‘y ×!4Ñ!4°f×6HÑ6HÓIˆŒÜ—i‘iØ×ÑØ×ÑØ×;Ñ;Ø×1Ñ1ô	
ˆŒô —i‘iØ×ÑØ×,Ñ,Ø×;Ñ;Ø×1Ñ1ô	
ˆŒô —y‘y ×!AÑ!AÀ6×CUÑCUÓVˆŒÜ—g‘g“iˆ�ó    Úinput_featuresÚreturnc                 ó,  — | j                  | j                  |«      «      }|j                  dd«      }| j                  | j                  |«      «      }| j                  | j	                  |«      «      }|j                  dd«      }| j                  |«      S )Nr   r   )r6   r-   Ú	transposer1   r3   r4   )r8   r<   Úhidden_statess      r:   ÚforwardzLasrEncoderSubsampling.forward?   sz   € ØŸ™ D§L¡L°Ó$@ÓAˆØ%×/Ñ/°°1Ó5ˆØŸ™ D§K¡K°Ó$>Ó?ˆØŸ™ D§K¡K°Ó$>Ó?ˆØ%×/Ñ/°°1Ó5ˆØ�|‰|˜MÓ*Ð*r;   )	Ú__name__Ú
__module__Ú__qualname__r!   r)   ÚtorchÚTensorrA   Ú__classcell__©r9   s   @r:   r#   r#   ,   s+   ø„ ð Ð0õ  ð$+ e§l¡lð +°u·|±|÷ +r;   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	ef   fd
„«       Z ej                  «       ed„ «       «       Zˆ xZS )ÚLasrEncoderRotaryEmbeddingÚinv_freqNr$   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ÚdefaultrK   F)Ú
persistentÚoriginal_inv_freq)r(   r)   Úmax_position_embeddingsÚmax_seq_len_cachedÚoriginal_max_seq_lenr$   Úrope_parametersrM   Úcompute_default_rope_parametersr   Úattention_scalingÚregister_bufferÚclone)r8   r$   ÚdeviceÚrope_init_fnrK   r9   s        €r:   r)   z#LasrEncoderRotaryEmbedding.__init__K   s¶   ø€ Ü‰ÑÔØ"(×"@Ñ"@ˆÔØ$*×$BÑ$BˆÔ!àˆŒàŸ™×4Ñ4°[ÑAˆŒØ!%×!EÑ!EˆØ�>‰>˜YÒ&Ü.¨t¯~©~Ñ>ˆLÙ+7¸¿¹ÀVÓ+LÑ(ˆ�$Ô(à×Ñ˜Z¨¸eÐÔDØ×ÑÐ0°(·.±.Ó2BÈuÐÕUr;   rY   ztorch.deviceÚseq_lenr=   ztorch.Tensorc                 ó  — | 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.
        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_thetaÚhead_dimNg      ð?r   r   ©Údtype)rY   r`   )	rT   Úgetattrr,   Únum_attention_headsrE   ÚarangeÚint64ÚtoÚfloat)r$   rY   r[   ÚbaseÚdimÚattention_factorrK   s          r:   rU   z:LasrEncoderRotaryEmbedding.compute_default_rope_parameters[   s�   € ð& ×%Ñ% lÑ3ˆÜ�f˜j¨$Ó/Òc°6×3EÑ3EÈ×IcÑIcÑ3cˆàÐð Ø”U—\‘\ ! S¨!´5·;±;Ô?×BÑBÈ&ÔX]×XcÑXcÐBÓdÐgjÑjÑkñ
ˆð Ð)Ð)Ð)r;   c                 óN  — | j                   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                  «       | j                  z  }|j                  «       | j                  z  }	d d d «       j	                  |j                   ¬
«      	j	                  |j                   ¬
«      fS # 1 sw Y   ŒAxY w)Nr   éÿÿÿÿr   ÚmpsÚcpuF)Údevice_typeÚenabledr   ©rh   r_   )rK   rf   ÚexpandÚshapere   rY   Ú
isinstanceÚtypeÚstrr   r?   rE   ÚcatÚcosrV   Úsinr`   )
r8   ÚxÚposition_idsÚinv_freq_expandedÚposition_ids_expandedrn   ÚfreqsÚembrw   rx   s
             r:   rA   z"LasrEncoderRotaryEmbedding.forwardy   sR  € ð !ŸM™M¨$²°4¨-Ñ8×>Ñ>Ó@×GÑGÈ×HZÑHZÐ[\ÑH]Ð_aÐcdÓe×hÑhÐij×iqÑiqÓrÐØ ,ªQ°²a¨ZÑ 8× >Ñ >Ó @Ðä'1°!·(±(·-±-ÄÔ'EÈ!Ï(É(Ï-É-Ð[`ÒJ`�a—h‘h—m’mÐfkˆÜ¨¸UÔCñ 	5Ø&×,Ñ,Ó.Ð1F×1LÑ1LÓ1NÑN×YÑYÐZ[Ð]^Ó_ˆEÜ—)‘)˜U E˜N°Ô3ˆCØ—'‘'“)˜d×4Ñ4Ñ4ˆCØ—'‘'“)˜d×4Ñ4Ñ4ˆC÷		5ð �v‰v˜AŸG™GˆvÓ$ c§f¡f°1·7±7 fÓ&;Ð;Ð;÷	5ð 	5ús   ÃBFÆF$©N)NNN)rB   rC   rD   rE   rF   Ú__annotations__r!   r)   Ústaticmethodr   ÚintÚtuplerf   rU   Úno_gradr   rA   rG   rH   s   @r:   rJ   rJ   H   s™   ø… Ø�l‰lÓñVÐ0õ Vð  à+/Ø+/Ø"ñ*Ø! DÑ(ð*à˜Ñ(ð*ð �t‘ð*ð 
ˆ~˜uÐ$Ñ	%ò	*ó ð*ð: €U‡]�]ƒ_Øñ<ó ó ô<r;   rJ   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..Nrk   r   rp   )rr   rE   rv   )ry   Úx1Úx2s      r:   Úrotate_halfrˆ   ‰   sZ   € à	
ˆ3Ð"�!—'‘'˜"‘+ Ñ"Ð"Ð"Ñ	#€BØ	
ˆ3�—‘˜‘˜qÑ Ñ"Ð"Ñ	#€BÜ�9‰9�r�c˜2�Y BÔ'Ð'r;   Úrotary_pos_embc                 óž   — |j                  |«      }|j                  |«      }| |z  t        | «      |z  z   }||z  t        |«      |z  z   }||fS )a…  Applies Rotary Position Embedding to the query and key tensors.

    Args:
        q (`torch.Tensor`): The query tensor.
        k (`torch.Tensor`): The key tensor.
        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.
    )Ú	unsqueezerˆ   )ÚqÚkrw   rx   Úunsqueeze_dimÚq_embedÚk_embeds          r:   Úapply_rotary_pos_embr‘   �   sY   € ð& �-‰-˜Ó
&€CØ
�-‰-˜Ó
&€CØ�3‰wœ; q›>¨CÑ/Ñ0€GØ�3‰wœ; q›>¨CÑ/Ñ0€GØ�GÐÐr;   r@   Ú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)rr   rq   Úreshape)r@   r’   ÚbatchÚnum_key_value_headsÚslenr^   s         r:   Ú	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ÐTr;   ÚmoduleÚqueryÚkeyÚvalueÚattention_maskÚscalingÚdropoutÚkwargsc                 ó  — t        || j                  «      }t        || j                  «      }	t        j                  ||j	                  dd«      «      |z  }
|�|
|z   }
t
        j                  j                  |
dt        j                  ¬«      j                  |j                  «      }
t
        j                  j                  |
|| j                  ¬«      }
t        j                  |
|	«      }|j	                  dd«      j                  «       }||
fS )Nr   r   rk   ©rh   r`   ©ÚpÚtrainingr   )r˜   Únum_key_value_groupsrE   Úmatmulr?   r   Ú
functionalÚsoftmaxÚfloat32re   r`   rŸ   r¥   Ú
contiguous)r™   rš   r›   rœ   r�   rž   rŸ   r    Ú
key_statesÚvalue_statesÚattn_weightsÚattn_outputs               r:   Úeager_attention_forwardr°   ¶   sà   € ô ˜3 × ;Ñ ;Ó<€JÜ˜U F×$?Ñ$?Ó@€Lä—<‘<  z×';Ñ';¸A¸qÓ'AÓBÀWÑL€LØÐ!Ø# nÑ4ˆä—=‘=×(Ñ(¨¸2ÄUÇ]Á]Ð(ÓS×VÑVÐW\×WbÑWbÓc€LÜ—=‘=×(Ñ(¨¸È6Ï?É?Ð(Ó[€LÜ—,‘,˜|¨\Ó:€KØ×'Ñ'¨¨1Ó-×8Ñ8Ó:€Kà˜Ð$Ð$r;   c                   óì   ‡ — e Zd ZdZdedefˆ fd„Z	 	 ddej                  de	ej                  ej                  f   dz  dej                  dz  d	e
e   d
e	ej                  ej                  f   f
d„Zˆ xZS )ÚLasrEncoderAttentionz=Multi-headed attention from 'Attention Is All You Need' paperr$   Ú	layer_idxc                 ód  •— t         ‰| �  «        || _        || _        t	        |d|j
                  |j                  z  «      | _        |j                  |j                  z  | _	        | j                  dz  | _
        |j                  | _        d| _        t        j                  |j
                  |j                  | j                  z  |j                  ¬«      | _        t        j                  |j
                  |j                  | j                  z  |j                  ¬«      | _        t        j                  |j
                  |j                  | j                  z  |j                  ¬«      | _        t        j                  |j                  | j                  z  |j
                  |j                  ¬«      | _        y )Nr^   g      à¿F©Úbias)r(   r)   r$   r³   ra   r,   rb   r^   r–   r¦   rž   Úattention_dropoutÚ	is_causalr   r*   Úattention_biasÚq_projÚk_projÚv_projÚo_proj©r8   r$   r³   r9   s      €r:   r)   zLasrEncoderAttention.__init__Ó   sM  ø€ Ü‰ÑÔØˆŒØ"ˆŒÜ ¨
°F×4FÑ4FÈ&×JdÑJdÑ4dÓeˆŒØ$*×$>Ñ$>À&×B\ÑB\Ñ$\ˆÔ!Ø—}‘} dÑ*ˆŒØ!'×!9Ñ!9ˆÔØˆŒä—i‘iØ×Ñ × :Ñ :¸T¿]¹]Ñ JÐQW×QfÑQfô
ˆŒô —i‘iØ×Ñ × :Ñ :¸T¿]¹]Ñ JÐQW×QfÑQfô
ˆŒô —i‘iØ×Ñ × :Ñ :¸T¿]¹]Ñ JÐQW×QfÑQfô
ˆŒô —i‘iØ×&Ñ&¨¯©Ñ6¸×8JÑ8JÐQW×QfÑQfô
ˆ�r;   Nr@   Úposition_embeddingsr�   r    r=   c                 óÆ  — |j                   d d }g |¢d‘| j                  ‘­}| j                  |«      j                  |«      j	                  dd«      }| j                  |«      j                  |«      j	                  dd«      }| j                  |«      j                  |«      j	                  dd«      }	|\  }
}t        |||
|«      \  }}t        j                  | j                  j                  t        «      } || |||	|f| j                  sdn| j                  | j                  dœ|¤Ž\  }} |j                   g |¢d‘­Ž j#                  «       }| j%                  |«      }||fS )Nrk   r   r   ç        )rŸ   rž   )rr   r^   rº   Úviewr?   r»   r¼   r‘   r   Úget_interfacer$   Ú_attn_implementationr°   r¥   r·   rž   r”   r«   r½   )r8   r@   r¿   r�   r    Úinput_shapeÚhidden_shapeÚquery_statesr¬   r­   rw   rx   Úattention_interfacer¯   r®   s                  r:   rA   zLasrEncoderAttention.forwardê   sk  € ð $×)Ñ)¨#¨2Ð.ˆØ8˜Ð8 bÐ8¨$¯-©-Ñ8ˆà—{‘{ =Ó1×6Ñ6°|ÓD×NÑNÈqÐRSÓTˆØ—[‘[ Ó/×4Ñ4°\ÓB×LÑLÈQÐPQÓRˆ
Ø—{‘{ =Ó1×6Ñ6°|ÓD×NÑNÈqÐRSÓTˆà&‰ˆˆSÜ#7¸ÀjÐRUÐWZÓ#[Ñ ˆ�jä(?×(MÑ(MØ�K‰K×,Ñ,Ô.Eó)
Ðñ %8ØØØØØð	%
ð  $Ÿ}š}‘C°$×2HÑ2HØ—L‘Lñ	%
ð ñ	%
Ñ!ˆ�\ð *�k×)Ñ)Ð;¨;Ð;¸Ò;×FÑFÓHˆØ—k‘k +Ó.ˆØ˜LÐ(Ð(r;   ©NN)rB   rC   rD   Ú__doc__r!   r‚   r)   rE   rF   rƒ   r   r   rA   rG   rH   s   @r:   r²   r²   Ï   s•   ø„ áGð
Ð0ð 
¸Sõ 
ð4 IMØ.2ñ	")à—|‘|ð")ð # 5§<¡<°·±Ð#=Ñ>ÀÑEð")ð Ÿ™ tÑ+ð	")ð
 Ð+Ñ,ð")ð 
ˆu�|‰|˜UŸ\™\Ð)Ñ	*÷")r;   r²   c                   ó.   ‡ — e Zd Zddefˆ fd„Zdd„Zˆ xZS )ÚLasrEncoderConvolutionModuler$   c           	      óV  •— t         ‰| �  «        |j                  }|€&|j                  }t        t        |dd«         | _        n#|d   }t        |j                  dd«         | _        d| _        t        j                  |d|z  ddd	|j                  ¬
«      | _        t        j                  |||d| j                  ||j                  ¬«      | _        t        j                  |j                  |j                  ¬«      | _        t        j                  ||ddd	|j                  ¬
«      | _        y)z·
        Args:
            config (LasrEncoderConfig): Configuration for the model.
            module_config (dict): Configuration for the module (e.g., encoder or decoder).
        NÚ
hidden_actÚsilur&   Ú
activationÚsamer   r   r   )r&   r'   Úpaddingr¶   )r'   rÒ   Úgroupsr¶   )Úmomentum)r(   r)   r,   Úconv_kernel_sizer   ra   rÐ   ÚgetrÒ   r   r.   Úconvolution_biasÚpointwise_conv1Údepthwise_convÚBatchNorm1dÚbatch_norm_momentumÚnormÚpointwise_conv2)r8   r$   Úmodule_configÚchannelsr&   r9   s        €r:   r)   z%LasrEncoderConvolutionModule.__init__  s	  ø€ ô 	‰ÑÔØ×%Ñ%ˆàÐ à ×1Ñ1ˆKÜ$¤W¨V°\À6Ó%JÑKˆD�Oà'¨Ñ6ˆKÜ$ ]×%6Ñ%6°|ÀVÓ%LÑMˆDŒOØˆŒÜ!Ÿy™yØ�a˜(‘l°¸!ÀQÈV×MdÑMdô 
ˆÔô !Ÿi™iØØØØØ—L‘LØØ×(Ñ(ô
ˆÔô —N‘N 6×#5Ñ#5À×@ZÑ@ZÔ[ˆŒ	Ü!Ÿy™yØ�h¨A°aÀÈ×I`ÑI`ô 
ˆÕr;   c                 ó   — |j                  dd«      }| j                  |«      }t        j                  j	                  |d¬«      }|�c|j
                  t        j                  k(  rt        j                  | d¬«      }nt        j                  |dk(   d¬«      }|j                  |d«      }| j                  |«      }| j                  |«      }| j                  |«      }| j                  |«      }|j                  dd«      S )aY  
        Compute convolution module.

        Args:
            hidden_states (`torch.Tensor` of shape `(batch, time, channels)`): Input tensor.
            attention_mask (`torch.Tensor` of shape `(batch, 1, time, time)`): Attention mask.

        Returns:
            `torch.Tensor`: Output tensor of shape `(batch, time, channels)`.

        r   r   rp   rÁ   )r?   rØ   r   r¨   Úglur`   rE   ÚboolÚallÚmasked_fillrÙ   rÜ   rÐ   rÝ   )r8   r@   r�   Úall_masked_rowss       r:   rA   z$LasrEncoderConvolutionModule.forward2  sè   € ð &×/Ñ/°°1Ó5ˆð ×,Ñ,¨]Ó;ˆäŸ™×)Ñ)¨-¸QÐ)Ó?ˆð Ð%Ø×#Ñ#¤u§z¡zÒ1Ü"'§)¡)¨^¨OÀÔ"C‘ä"'§)¡)¨nÀÑ.CÐ,DÈ!Ô"L�Ø)×5Ñ5°oÀsÓKˆMð ×+Ñ+¨MÓ:ˆØŸ	™	 -Ó0ˆØŸ™¨Ó6ˆØ×,Ñ,¨]Ó;ˆà×&Ñ& q¨!Ó,Ð,r;   r   ©rB   rC   rD   r!   r)   rA   rG   rH   s   @r:   rÌ   rÌ     s   ø„ ñ 
Ð0õ  
÷D"-r;   rÌ   c                   ó*   ‡ — e Zd Zdefˆ fd„Zd„ Zˆ xZS )ÚLasrEncoderFeedForwardr$   c                 ó`  •— t         ‰| �  «        t        j                  |j                  |j
                  |j                  ¬«      | _        t        |j                     | _
        t        j                  |j
                  |j                  |j                  ¬«      | _        |j                  | _        y )Nrµ   )r(   r)   r   r*   r,   Úintermediate_sizer¹   Úlinear1r   rÎ   rÐ   Úlinear2Úactivation_dropoutr7   s     €r:   r)   zLasrEncoderFeedForward.__init__X  s|   ø€ Ü‰ÑÔÜ—y‘y ×!3Ñ!3°V×5MÑ5MÐTZ×TiÑTiÔjˆŒÜ  ×!2Ñ!2Ñ3ˆŒÜ—y‘y ×!9Ñ!9¸6×;MÑ;MÐTZ×TiÑTiÔjˆŒØ"(×";Ñ";ˆÕr;   c                 óÔ   — | j                  | j                  |«      «      }t        j                  j	                  || j
                  | j                  ¬«      }| j                  |«      }|S )Nr£   )rÐ   rë   r   r¨   rŸ   rí   r¥   rì   )r8   r@   s     r:   rA   zLasrEncoderFeedForward.forward_  sU   € ØŸ™¨¯©°]Ó(CÓDˆÜŸ™×-Ñ-¨m¸t×?VÑ?VÐae×anÑanÐ-ÓoˆØŸ™ ]Ó3ˆØÐr;   ræ   rH   s   @r:   rè   rè   W  s   ø„ ð<Ð0õ <ör;   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e	   d	ej                  f
d
„Z
ˆ xZS )ÚLasrEncoderBlockr$   r³   c                 óà  •— t         ‰| �  «        d| _        t        |«      | _        t        ||«      | _        t        |«      | _        t        |«      | _	        t        j                  |j                  |j                  d¬«      | _        t        j                  |j                  |j                  d¬«      | _        t        j                  |j                  |j                  d¬«      | _        t        j                  |j                  |j                  d¬«      | _        t        j                  |j                  |j                  d¬«      | _        |j&                  | _        |j(                  | _        y )NFrµ   )r(   r)   Úgradient_checkpointingrè   Úfeed_forward1r²   Ú	self_attnrÌ   ÚconvÚfeed_forward2r   Ú	LayerNormr,   Úlayer_norm_epsÚnorm_feed_forward1Únorm_self_attÚ	norm_convÚnorm_feed_forward2Únorm_outÚfeed_forward_residual_weightsÚconv_residual_weightsr¾   s      €r:   r)   zLasrEncoderBlock.__init__g  s  ø€ Ü‰ÑÔØ&+ˆÔ#ä3°FÓ;ˆÔÜ-¨f°iÓ@ˆŒÜ0°Ó8ˆŒ	Ü3°FÓ;ˆÔä"$§,¡,¨v×/AÑ/AÀ6×CXÑCXÐ_dÔ"eˆÔÜŸ\™\¨&×*<Ñ*<¸f×>SÑ>SÐZ_Ô`ˆÔÜŸ™ f×&8Ñ&8¸&×:OÑ:OÐV[Ô\ˆŒÜ"$§,¡,¨v×/AÑ/AÀ6×CXÑCXÐ_dÔ"eˆÔÜŸ™ V×%7Ñ%7¸×9NÑ9NÐUZÔ[ˆŒà-3×-QÑ-QˆÔ*Ø%+×%AÑ%AˆÕ"r;   Nr@   r�   r¿   r    r=   c                 ó0  — |}| j                  | j                  |«      «      }| j                  d   |z  | j                  d   |z  z   }| j                  |«      } | j                  d|||dœ|¤Ž\  }}||z   }| j                  | j                  |«      |¬«      }	| j                  d   |z  | j                  d   |	z  z   }|}| j                  | j                  |«      «      }| j                  d   |z  | j                  d   |z  z   }| j                  |«      }|S )Nr   r   )r@   r�   r¿   )r�   © )ró   rù   rþ   rú   rô   rõ   rû   rÿ   rö   rü   rý   )
r8   r@   r�   r¿   r    ÚresidualÚnormalized_hidden_statesr¯   Ú_Úconv_outputs
             r:   rA   zLasrEncoderBlock.forwardy  sJ  € ð !ˆØ×*Ñ*¨4×+BÑ+BÀ=Ó+QÓRˆà×.Ñ.¨qÑ1°HÑ<¸t×?aÑ?aÐbcÑ?dÐgtÑ?tÑtð 	ð $(×#5Ñ#5°mÓ#DÐ Ø'˜Ÿ™ð 
Ø2Ø)Ø 3ñ
ð ñ	
‰ˆ�Qð &¨Ñ3ˆà—i‘i §¡¨}Ó =Èn�iÓ]ˆØ×2Ñ2°1Ñ5¸ÑEÈ×HbÑHbÐcdÑHeÐhsÑHsÑsˆà ˆØ×*Ñ*¨4×+BÑ+BÀ=Ó+QÓRˆà×.Ñ.¨qÑ1°HÑ<¸t×?aÑ?aÐbcÑ?dÐgtÑ?tÑtð 	ð Ÿ™ mÓ4ˆàÐr;   rÉ   )rB   rC   rD   r!   r‚   r)   rE   rF   r   r   rA   rG   rH   s   @r:   rð   rð   f  sw   ø„ ðBÐ0ð B¸Sõ Bð* /3Ø37ñ	!à—|‘|ð!ð Ÿ™ tÑ+ð!ð #Ÿ\™\¨DÑ0ð	!ð
 Ð+Ñ,ð!ð 
�‰÷!r;   rð   c                   óœ   — e Zd ZU eed<   dZdZdZdZdgZ	dZ
dZdZdZdZdZeedœZd	ej(                  fd
„Zddej(                  dedz  fd„Zy)ÚLasrPreTrainedModelr$   Úmodelr<   ÚaudioTrð   F)r@   Ú
attentionsÚinput_lengthsc                 óè   — t        | j                  t        «      r| j                  j                  n| j                  }|j                  }|j
                  }d}t        |«      D ]  }||z
  |z  dz   }Œ |S )Nr   r   )rs   r$   r    Úencoder_configr/   r0   Úrange)r8   r  r  r&   r'   Ú
num_layersr  s          r:   Ú_get_subsampling_output_lengthz2LasrPreTrainedModel._get_subsampling_output_length´  st   € Ü7AÀ$Ç+Á+Ì}Ô7]˜Ÿ™×3Ò3Ðcg×cnÑcnˆØ$×AÑAˆØ×7Ñ7ˆàˆ
Ü�zÓ"ò 	HˆAØ*¨[Ñ8¸VÑCÀaÑG‰Mð	Hð Ðr;   Nr�   Útarget_lengthc                 óÄ   — | j                  |j                  d«      «      }|�|n|j                  «       }t        j                  ||j
                  ¬«      |dd…df   k  }|S )zþ
        Convert the input attention mask to its subsampled form. `target_length` sets the desired output length, useful
        when the attention mask length differs from `sum(-1).max()` (i.e., when the longest sequence in the batch is padded)
        rk   N©rY   )r  ÚsumÚmaxrE   rc   rY   )r8   r�   r  Úoutput_lengthsÚ
max_lengths        r:   Ú_get_output_attention_maskz.LasrPreTrainedModel._get_output_attention_mask¿  sc   € ð
 ×<Ñ<¸^×=OÑ=OÐPRÓ=SÓTˆà&3Ð&?‘]À^×EWÑEWÓEYˆ
ÜŸ™ j¸×9NÑ9NÔOÐR`ÒabÐdhÐahÑRiÑiˆØÐr;   r   )rB   rC   rD   r    r€   Úbase_model_prefixÚmain_input_nameÚinput_modalitiesÚsupports_gradient_checkpointingÚ_no_split_modulesÚ_supports_flat_attention_maskÚ_supports_sdpaÚ_supports_flex_attnÚ_supports_flash_attnÚ_can_compile_fullgraphÚ_supports_attention_backendrð   r²   Ú_can_record_outputsrE   rF   r  r‚   r  r  r;   r:   r  r  �  s‰   … àÓØÐØ&€OØÐØ&*Ð#Ø+Ð,ÐØ$(Ð!Ø€NàÐð !Ðà!ÐØ"&Ðà)Ø*ñÐð
	¸E¿L¹Ló 	ñ	¸¿¹ð 	ÐVYÐ\`ÑV`ô 	r;   r  z¨
    Extends [~modeling_outputs.BaseModelOutputWithPooling] to include the output attention mask since sequence length
    is not preserved in the model's forward.
    )Úcustom_introc                   ó:   — e Zd ZU dZdZej                  dz  ed<   y)ÚLasrEncoderModelOutputa–  
    attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
        Mask to avoid performing attention on padding token indices after sequence compression. Returned because the
        sequence length may differ from the input sequence length. Mask values selected in `[0, 1]`:

        - 1 for tokens that are **not masked**,
        - 0 for tokens that are **masked**.
    Nr�   )rB   rC   rD   rÊ   r�   rE   rF   r€   r  r;   r:   r'  r'  Ë  s   … ñð +/€N�E—L‘L 4Ñ'Ô.r;   r'  zh
    The LasrEncoder model, based on the Conformer architecture](https://arxiv.org/abs/2005.08100).
    c                   ó¸   ‡ — e Zd ZU eed<   dZdefˆ fd„Zeee	e
	 	 ddej                  dej                  dz  dedz  dee   d	ef
d
„«       «       «       «       Zˆ xZS )ÚLasrEncoderr$   Úencoderc           	      óî  •— t         ‰| �  |«       d| _        |j                  | _        |j                  | _        |j
                  | _        t        |«      | _        t        |«      | _	        t        j                  t        |j                  «      D �cg c]  }t        ||«      ‘Œ c}«      | _        t        j                   |j"                  |j$                  d¬«      | _        | j)                  «        y c c}w )NF)Úepsr¶   )r(   r)   rò   rŸ   Údropout_positionsÚ	layerdropr#   Ú
subsamplerrJ   Ú
rotary_embr   Ú
ModuleListr  Únum_hidden_layersrð   Úlayersr÷   r,   rø   Úout_normÚ	post_initr¾   s      €r:   r)   zLasrEncoder.__init__è  sº   ø€ Ü‰Ñ˜Ô Ø&+ˆÔ#à—~‘~ˆŒØ!'×!9Ñ!9ˆÔØ×)Ñ)ˆŒä0°Ó8ˆŒÜ4°VÓ<ˆŒÜ—m‘mÜBGÈ×H`ÑH`ÓBaÖb°YÔ˜f iÕ0Òbó
ˆŒô Ÿ™ V×%7Ñ%7¸V×=RÑ=RÐY^Ô_ˆŒà�‰Õùò	 cs   ÂC2Nr<   r�   Úoutput_attention_maskr    r=   c                 óž  — | j                  |«      }| j                  |t        j                  |j                  d   |j
                  ¬«      j                  d«      «      \  }}t        j                  j                  || j                  | j                  ¬«      }t        j                  j                  || j                  | j                  ¬«      }t        j                  j                  || j                  | j                  ¬«      }d}|�"| j                  ||j                  d   ¬«      }|}t        | j                  ||¬«      }| j                  D ]G  }	d}
| j                  r&t        j                   g «      }|| j"                  k  rd	}
|
rŒ: |	|f|||fd
œ|¤Ž}ŒI | j%                  |«      }t'        ||r|�|j)                  «       ¬«      S d¬«      S )a;  
        output_attention_mask (`bool`, *optional*):
            Whether to return the output attention mask.

        Example:

        ```python
        >>> from transformers import AutoProcessor, LasrEncoder
        >>> from datasets import load_dataset, Audio

        >>> model_id = "google/medasr"
        >>> processor = AutoProcessor.from_pretrained(model_id)
        >>> encoder = ParakeetEncoder.from_pretrained(model_id)

        >>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
        >>> ds = ds.cast_column("audio", Audio(sampling_rate=processor.feature_extractor.sampling_rate))

        >>> inputs = processor(ds[0]["audio"]["array"])
        >>> encoder_outputs = encoder(**inputs)

        >>> print(encoder_outputs.last_hidden_state.shape)
        ```
        r   r  r   r£   N©r  )r$   Úinputs_embedsr�   FT)r�   r¿   )Úlast_hidden_stater�   )r/  r0  rE   rc   rr   rY   r‹   r   r¨   rŸ   r¥   r-  r  r   r$   r3  Úrandr.  r4  r'  r‚   )r8   r<   r�   r6  r    r@   rw   rx   Úoutput_maskÚencoder_layerÚto_dropÚdropout_probabilitys               r:   rA   zLasrEncoder.forwardù  s´  € ðF Ÿ™¨Ó7ˆØ—?‘?Øœ5Ÿ<™<¨×(;Ñ(;¸AÑ(>À}×G[ÑG[Ô\×fÑfÐghÓió
‰ˆˆSô Ÿ™×-Ñ-¨m¸t¿|¹|ÐVZ×VcÑVcÐ-ÓdˆÜ�m‰m×#Ñ# C¨4×+AÑ+AÈDÏMÉMÐ#ÓZˆÜ�m‰m×#Ñ# C¨4×+AÑ+AÈDÏMÉMÐ#ÓZˆàˆØÐ%Ø×9Ñ9¸.ÐXe×XkÑXkÐlmÑXnÐ9ÓoˆKØ(ˆNä2Ø—;‘;Ø'Ø)ô
ˆð "Ÿ[™[ò 	ˆMàˆGØ�}Š}Ü&+§j¡j°£nÐ#Ø&¨¯©Ò7Ø"�GâÙ -Ø!ð!à#1Ø),¨c¨
ñ!ð ñ	!‘ð	ð  Ÿ™ mÓ4ˆä%Ø+Ù0EÈ+ÐJa˜;Ÿ?™?Ó,ô
ð 	
àgkô
ð 	
r;   rÉ   )rB   rC   rD   r!   r€   r  r)   r   r   r   r   rE   rF   râ   r   r   r'  rA   rG   rH   s   @r:   r)  r)  ß  s    ø… ð ÓØ!ÐðÐ0õ ð" ØØØð /3Ø-1ñ	H
àŸ™ðH
ð Ÿ™ tÑ+ðH
ð  $ d™{ð	H
ð
 Ð+Ñ,ðH
ð 
 òH
ó ó ó  ó ôH
r;   r)  c                   óÆ   — e Zd ZU dZej
                  ed<   dZeej                     dz  ed<   dZ
eeej                        dz  ed<   dZeeej                        dz  ed<   y)ÚLasrCTCGenerateOutputav  
    Outputs of Lasr CTC model generation.

    Args:
        sequences (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
            The generated sequences. The second dimension (sequence_length) is either equal to `max_length` or shorter
            if all batches finished early due to the `eos_token_id`.
        logits (`tuple(torch.FloatTensor)` *optional*, returned when `output_logits=True`):
            Unprocessed prediction scores of the language modeling head (scores for each vocabulary token before SoftMax)
            at each generation step. Tuple of `torch.FloatTensor` with up to `max_new_tokens` elements (one element for
            each generated token), with each tensor of shape `(batch_size, config.vocab_size)`.
        attentions (`tuple(tuple(torch.FloatTensor))`, *optional*, returned when `output_attentions=True`):
            Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) of
            `torch.FloatTensor` of shape `(batch_size, num_heads, generated_length, sequence_length)`.
        hidden_states (`tuple(tuple(torch.FloatTensor))`, *optional*, returned when `output_hidden_states=True`):
            Tuple (one element for each generated token) of tuples (one element for each layer of the decoder) of
            `torch.FloatTensor` of shape `(batch_size, generated_length, hidden_size)`.
    Ú	sequencesNÚlogitsr
  r@   )rB   rC   rD   rÊ   rE   Ú
LongTensorr€   rC  rƒ   ÚFloatTensorr
  r@   r  r;   r:   rA  rA  H  sm   … ñð& ×ÑÓØ.2€FˆE�%×#Ñ#Ñ$ tÑ+Ó2Ø9=€J��e˜E×-Ñ-Ñ.Ñ/°$Ñ6Ó=Ø<@€M�5˜˜u×0Ñ0Ñ1Ñ2°TÑ9Ô@r;   rA  zO
    Lasr Encoder with a Connectionist Temporal Classification (CTC) head.
    c                   óX  ‡ — e Zd ZU eed<   defˆ fd„Zee	 	 ddej                  dej                  dz  dej                  dz  de
e   def
d	„«       «       Z ej                  «       	 	 	 ddej                  dej                  dz  d
ededz  de
e   deej$                  z  fd„«       Zˆ xZS )Ú
LasrForCTCr$   c                 ó  •— t         ‰| �  |«       t        j                  |j                  «      | _        t        j                  |j                  j                  |j                  d¬«      | _
        | j                  «        y )Nr   )r&   )r(   r)   r   Úfrom_configr  r*  r   r.   r,   Ú
vocab_sizeÚctc_headr5  r7   s     €r:   r)   zLasrForCTC.__init__k  sY   ø€ Ü‰Ñ˜Ô Ü ×,Ñ,¨V×-BÑ-BÓCˆŒäŸ	™	 &×"7Ñ"7×"CÑ"CÀV×EVÑEVÐdeÔfˆŒà�‰Õr;   Nr<   r�   Úlabelsr    r=   c           
      óŒ  — |�|j                  dd«        | j                  d||dœ|¤Ž}|j                  }| j                  |j	                  dd«      «      j	                  dd«      }d}|��+|j
                  j                  d«      }	|| j                  j                  k7  }
|
j                  d«      }|j                  |
«      }t        j                  j                  |dt        j                  ¬«      j	                  d	d«      }t        j                  j                   j#                  d
¬«      5  t        j                  j%                  |||	|| j                  j                  | j                  j&                  | j                  j(                  ¬«      }ddd«       t+        |||j,                  |j.                  ¬«      S # 1 sw Y   Œ,xY w)a²  
        Example:

        ```python
        >>> from transformers import AutoProcessor, LasrForCTC
        >>> from datasets import load_dataset, Audio

        >>> model_id = "nvidia/lasr-ctc-1.1b"
        >>> processor = AutoProcessor.from_pretrained(model_id)
        >>> model = LasrForCTC.from_pretrained(model_id)

        >>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
        >>> ds = ds.cast_column("audio", Audio(sampling_rate=processor.feature_extractor.sampling_rate))

        >>> inputs = processor(ds[0]["audio"]["array"], text=ds[0]["text"])
        >>> outputs = model(**inputs)

        >>> print(outputs.loss)
        ```Nr6  T©r<   r�   r   r   rk   r¢   r   F)ro   )ÚblankÚ	reductionÚzero_infinity)ÚlossrC  r@   r
  r  )Ú
setdefaultr*  r:  rK  r?   r�   r  r$   Úpad_token_idÚmasked_selectr   r¨   Úlog_softmaxrE   rª   ÚbackendsÚcudnnÚflagsÚctc_lossÚctc_loss_reductionÚctc_zero_infinityr   r@   r
  )r8   r<   r�   rL  r    Úencoder_outputsr@   rC  rR  Úencoder_lengthsÚlabels_maskÚtarget_lengthsÚflattened_targetsÚ	log_probss                 r:   rA   zLasrForCTC.forwards  sž  € ð: ÐØ×ÑÐ5°tÔ<Ø&˜$Ÿ,™,ð 
Ø)Ø)ñ
ð ñ
ˆð (×9Ñ9ˆØ—‘˜}×6Ñ6°q¸!Ó<Ó=×GÑGÈÈ1ÓMˆàˆØÑØ-×<Ñ<×@Ñ@ÀÓDˆOð ! D§K¡K×$<Ñ$<Ñ<ˆKØ(Ÿ_™_¨RÓ0ˆNØ &× 4Ñ 4°[Ó AÐô Ÿ™×1Ñ1°&¸bÌÏÉÐ1ÓV×`Ñ`ÐabÐdeÓfˆIä—‘×%Ñ%×+Ñ+°EÐ+Ó:ñ 	Ü—}‘}×-Ñ-ØØ%Ø#Ø"ØŸ+™+×2Ñ2Ø"Ÿk™k×<Ñ<Ø"&§+¡+×"?Ñ"?ð .ó �÷	ô ØØØ)×7Ñ7Ø&×1Ñ1ô	
ð 	
÷	ð 	ús   Ä,A#F:Æ:GÚreturn_dict_in_generateÚcompile_configc                 ór  — |�| j                  |«      n| j                  }d|d<    |d	||dœ|¤Ž}|j                  j                  d¬«      }|�:| j	                  ||j
                  d   ¬«      }| j                  j                  || <   |r-t        ||j                  |j                  |j                  ¬«      S |S )
a   
        Example:

        ```python
        >>> from transformers import AutoProcessor, LasrForCTC
        >>> from datasets import load_dataset, Audio

        >>> model_id = "google/medasr"
        >>> processor = AutoProcessor.from_pretrained(model_id)
        >>> model = LasrForCTC.from_pretrained(model_id)

        >>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
        >>> ds = ds.cast_column("audio", Audio(sampling_rate=processor.feature_extractor.sampling_rate))

        >>> inputs = processor(ds[0]["audio"]["array"], text=ds[0]["text"])
        >>> predicted_ids = model.generate(**inputs)
        >>> transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)

        >>> print(transcription)
        ```
        TÚreturn_dictrN  rk   rp   r   r8  )rB  rC  r
  r@   r  )Úget_compiled_callÚ__call__rC  Úargmaxr  rr   r$   rT  rA  r
  r@   )	r8   r<   r�   rc  rd  r    Úmodel_forwardÚoutputsrB  s	            r:   ÚgeneratezLasrForCTC.generate¹  sÚ   € ð< CQÐB\˜×.Ñ.¨~Ô>Ðbf×boÑboˆà $ˆˆ}ÑÙ"/ð #
Ø)Ø)ñ#
ð ñ#
ˆð —N‘N×)Ñ)¨bÐ)Ó1ˆ	ð Ð%Ø!×<Ñ<¸^Ð[d×[jÑ[jÐklÑ[mÐ<ÓnˆNØ)-¯©×)AÑ)AˆI�~�oÑ&á"Ü(Ø#Ø—~‘~Ø"×-Ñ-Ø%×3Ñ3ô	ð ð Ðr;   rÉ   )NFN)rB   rC   rD   r    r€   r)   r   r   rE   rF   r   r   r   rA   r„   râ   r	   rA  rD  rl  rG   rH   s   @r:   rG  rG  c  s  ø… ð Óð˜}õ ð Øð /3Ø&*ñ	B
àŸ™ðB
ð Ÿ™ tÑ+ðB
ð —‘˜tÑ#ð	B
ð
 Ð+Ñ,ðB
ð 
òB
ó ó ðB
ðH €U‡]�]ƒ_ð /3Ø(-Ø/3ñ6àŸ™ð6ð Ÿ™ tÑ+ð6ð "&ð	6ð
 &¨Ñ,ð6ð Ð+Ñ,ð6ð 
 ×!1Ñ!1Ñ	1ò6ó ô6r;   rG  )rG  r)  r  )r   )rÁ   )BÚcollections.abcr   Údataclassesr   Útypingr   rE   r   Úactivationsr   Ú
generationr	   r
   Úintegrationsr   r   Úmasking_utilsr   Úmodeling_layersr   Úmodeling_outputsr   r   Úmodeling_rope_utilsr   r   Úmodeling_utilsr   r   Úprocessing_utilsr   Úutilsr   r   r   r   Úutils.genericr   r   Úutils.output_capturingr   Úautor   Úconfiguration_lasrr    r!   ÚModuler#   rJ   rˆ   r‘   rF   r‚   r˜   rf   r°   r²   rÌ   rè   rð   r  r'  r)  rA  rG  Ú__all__r  r;   r:   ú<module>r€     s<  ðõ* %Ý !Ý ã Ý å !ß 8ß IÝ 6Ý 9ß Jß Kß FÝ &ß VÓ Vß GÝ 5Ý ß @ô+˜RŸY™Yô +ô8>< §¡ô ><òB(ñ Ð*Ó+òó ,ðð2	U˜UŸ\™\ð 	U°#ð 	U¸%¿,¹,ó 	Uð& ñ%Ø�I‰Ið%à�<‰<ð%ð 
�‰ð%ð �<‰<ð	%ð
 —L‘L 4Ñ'ð%ð ð%ð ð%ð Ð'Ñ(ó%ñ2 Ð)Ó*ô<)˜2Ÿ9™9ó <)ó +ð<)ô~E- 2§9¡9ô E-ôP˜RŸY™Yô ô4Ð1ô 4ðn ô*˜/ó *ó ð*ñZ ðôð ô
/Ð7ó 
/ó óð
/ñ ðôô
a
Ð%ó a
óð
a
ðH ôA˜Kó Aó ðAñ4 ðôô
HÐ$ oó Hóð
HòV ?�r;   