+
    œ°³jºÆ  ã                   óf  € ^ RI t ^ RIHt ^ RIHt ^ RIt^ RIHt ^ RIH	t	 ^RI
Ht ^RIHt ^RIHt ^RIHtHt ^R	IHt ^R
IHt ^RIHtHt ^RIHtHt ^RIHt ^RI H!t!H"t"H#t#H$t$H%t% ^RI&H't' ^RI(H)t) ^RI*H+t+ ^RI,H-t- ]%! 4       '       d   ^ RI.t.^ RI/Hu H0t1 ]#] ! R R]!4      4       4       t2]#] ! R R]!4      4       4       t3]#] ! R R]!4      4       4       t4 ! R R]Pj                  4      t6R t7]! R4      RLR l4       t8R R lt9RMR  R! llt:]! ]84       ! R" R#]Pj                  4      4       t;]! R$4       ! R% R&]Pj                  4      4       t< ! R' R(]4      t= ! R) R*]Pj                  4      t>R+ t? ! R, R-]Pj                  4      t@ ! R. R/]Pj                  4      tA ! R0 R1]Pj                  4      tB ! R2 R3]Pj                  4      tC]# ! R4 R5]4      4       tD ! R6 R7]Pj                  4      tE ! R8 R9]Pj                  4      tF ! R: R;]Pj                  4      tG ! R< R=]Pj                  4      tH ! R> R?]Pj                  4      tI ! R@ RA]Pj                  4      tJ ! RB RC]Pj                  4      tK ! RD RE]Pj                  4      tL ! RF RG]Pj                  4      tM]#! RHRI7       ! RJ RK]D4      4       tNRKR5.tOR# )Né    N)ÚCallable)Ú	dataclass)Ú	Parameter)Úinitialization)ÚACT2FN)ÚCache)Úuse_kernel_forward_from_hubÚuse_kernelized_func)Úcreate_bidirectional_mask)ÚGradientCheckpointingLayer)ÚROPE_INIT_FUNCTIONSÚdynamic_rope_update)ÚALL_ATTENTION_FUNCTIONSÚPreTrainedModel)ÚUnpack)ÚModelOutputÚTransformersKwargsÚauto_docstringÚcan_return_tupleÚis_torch_available)Údeprecate_kwarg)Úmaybe_autocast)Ú	AutoModel©ÚNeuCodecConfigc                   ó@   a € ] tR t^2t o RtRtRtRtRtV 3R lt	Rt
V tR# )ÚNeuCodecOutputa!  
audio_values (`torch.FloatTensor` of shape `(batch_size, 1, sequence_length)`, *optional*):
    Decoded audio waveform values in the time domain, obtained using the decoder
    part of NeuCodec. These represent the reconstructed audio signal.
audio_codes (`torch.LongTensor` of shape `(batch_size, 1, codes_length)`, *optional*):
    Discrete code embeddings computed using `model.encode`. These are the quantized
    representations of the input audio used for further processing or generation.
latents (`torch.Tensor` of shape `(batch_size, dimension, time_steps)`):
    Quantized continuous representation of input's embedding.
audio_codes_mask (`torch.int32` of shape `(batch_size, 1, codes_length)`, *optional*):
    Downsampled `padding_mask` for indicating valid audio codes in `audio_codes`.
Nc                óÒ   <€ V ^8„  d   Qh/ S[ P                  R,          ;R&   S[ P                  R,          ;R&   S[ P                  R,          ;R&   S[ P                  R,          ;R&   # )é   NÚaudio_valuesÚaudio_codesÚlatentsÚaudio_codes_mask)ÚtorchÚFloatTensorÚ
LongTensorÚTensor)ÚformatÚ__classdict__s   "€Úo/home/luca/screen-checking/.venv/lib/python3.14/site-packages/transformers/models/neucodec/modeling_neucodec.pyÚ__annotate__ÚNeuCodecOutput.__annotate__2   sa   ø‡ ‚ ñ  ×#Ñ# dÕ*Ñ1ñ! ñ" ×!Ñ! DÕ(Ñ/ñ# ñ$ �\‰\˜DÕ Ñ'ñ% ñ& —l‘l TÕ)Ñ0ò' ó    © )Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__r    r!   r"   r#   Ú__annotate_func__Ú__static_attributes__Ú__classdictcell__©r)   s   @r*   r   r   2   s(   ø‡ € ñð .2€LØ+/€KØ#'€GØ,0Ð÷' ƒ r-   r   c                   ó<   a € ] tR t^Ht o RtRtRtRtV 3R ltRt	V t
R# )ÚNeuCodecEncoderOutputaP  
audio_codes (`torch.LongTensor` of shape `(batch_size, 1, codes_length)`, *optional*):
    Discrete code embeddings computed using `model.encode`. These represent
    the compressed, quantized form of the input audio signal that can be
    used for storage, transmission, or generation.
latents (`torch.Tensor` of shape `(batch_size, dimension, time_steps)`):
    Quantized continuous representation of input's embedding.
audio_codes_mask (`torch.int32` of shape `(batch_size, 1, codes_length)`, *optional*):
    Downsampled `padding_mask` for indicating valid audio codes in `audio_codes`.
Nc                ó¤   <€ V ^8„  d   Qh/ S[ P                  R,          ;R&   S[ P                  R,          ;R&   S[ P                  R,          ;R&   # )r   Nr!   r"   r#   )r$   r&   r'   )r(   r)   s   "€r*   r+   Ú"NeuCodecEncoderOutput.__annotate__H   sI   ø‡ ‚ ñ ×!Ñ! DÕ(Ñ/ñ ñ �\‰\˜DÕ Ñ'ñ ñ  —l‘l TÕ)Ñ0ò! r-   r.   )r/   r0   r1   r2   r3   r!   r"   r#   r4   r5   r6   r7   s   @r*   r9   r9   H   s#   ø‡ € ñ	ð ,0€KØ#'€GØ,0Ð÷! ƒ r-   r9   c                   ó4   a € ] tR t^[t o RtRtV 3R ltRtV tR# )ÚNeuCodecDecoderOutputa)  
audio_values (`torch.FloatTensor` of shape `(batch_size, 1, segment_length)`, *optional*):
    Decoded audio waveform values in the time domain, obtained by converting
    the discrete codes back into continuous audio signals. This represents
    the reconstructed audio that can be played back.
Nc                óH   <€ V ^8„  d   Qh/ S[ P                  R,          ;R&   # )r   Nr    )r$   r%   )r(   r)   s   "€r*   r+   Ú"NeuCodecDecoderOutput.__annotate__[   s   ø‡ ‚ ñ ×#Ñ# dÕ*Ñ1ò r-   r.   )	r/   r0   r1   r2   r3   r    r4   r5   r6   r7   s   @r*   r=   r=   [   s   ø‡ € ñð .2€L÷ ƒ r-   r=   c                   óP   a a€ ] tR t^ht oV3R lV 3R lltV3R lR ltRtVtV ;t# )ÚNeuCodecMLPc                ó    <€ V ^8„  d   QhRS[ /# ©r   Úconfigr   )r(   r)   s   "€r*   r+   ÚNeuCodecMLP.__annotate__i   s   ø€ ÷ Wñ W™~ñ Wr-   c                ó0  <€ \         SV `  4        Wn        \        VP                  ,          V n        \        P                  ! VP                  VP                  R R7      V n
        \        P                  ! VP                  VP                  R R7      V n        R# )F©ÚbiasN)ÚsuperÚ__init__rD   r   Ú
hidden_actÚactivation_fnÚnnÚLinearÚhidden_sizeÚintermediate_sizeÚfc1Úfc2©ÚselfrD   Ú	__class__s   &&€r*   rJ   ÚNeuCodecMLP.__init__i   sh   ø€ Ü‰ÑÔØŒÜ# F×$5Ñ$5Õ6ˆÔÜ—9’9˜V×/Ñ/°×1IÑ1IÐPUÔVˆŒÜ—9’9˜V×5Ñ5°v×7IÑ7IÐPUÔVˆŽr-   c                óN   <€ V ^8„  d   QhRS[ P                  RS[ P                  /# ©r   Úhidden_statesÚreturn©r$   r'   )r(   r)   s   "€r*   r+   rE   p   s#   ø€ ÷ ñ ¡U§\¡\ð ±e·l±lñ r-   c                ól   € V P                  V4      pV P                  V4      pV P                  V4      pV# ©N)rQ   rL   rR   ©rT   rY   s   &&r*   ÚforwardÚNeuCodecMLP.forwardp   s4   € ØŸ™ Ó/ˆØ×*Ñ*¨=Ó9ˆØŸ™ Ó/ˆØÐr-   )rL   rD   rQ   rR   ©	r/   r0   r1   r2   rJ   r_   r5   r6   Ú__classcell__©rU   r)   s   @@r*   rA   rA   h   s    ù‡ € ÷Wó W÷÷ ð r-   rA   c                óÌ   € V RRV P                   R,          ^,          13,          pV RV P                   R,          ^,          R13,          p\        P                  ! V) V3RR7      # )z*Rotates half the hidden dims of the input..N©Údiméÿÿÿÿ)Úshaper$   Úcat)ÚxÚx1Úx2s   &  r*   Úrotate_halfrm   w   sZ   € à	
ˆ3Ð"�!—'‘'˜"•+ Õ"Ð"Ð"Õ	#€BØ	
ˆ3�—‘˜•˜qÕ Ñ"Ð"Õ	#€BÜ�9Š9�r�c˜2�Y BÔ'Ð'r-   Úrotary_pos_embc                óÈ   € VP                  V4      pVP                  V4      pW,          \        V 4      V,          ,           pW,          \        V4      V,          ,           pWV3# )aI  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.
)Ú	unsqueezerm   )ÚqÚkÚcosÚsinÚunsqueeze_dimÚq_embedÚk_embeds   &&&&&  r*   Úapply_rotary_pos_embrx   ~   sS   € ð& �-‰-˜Ó
&€CØ
�-‰-˜Ó
&€CØ�wœ; q›>¨CÕ/Õ0€GØ�wœ; q›>¨CÕ/Õ0€GØÐÐr-   c                ód   € V ^8„  d   QhR\         P                  R\        R\         P                  /# )r   rY   Ún_reprZ   )r$   r'   Úint)r(   s   "r*   r+   r+   ˜   s.   € ÷ 	Uñ 	UœUŸ\™\ð 	U´#ð 	U¼%¿,¹,ñ 	Ur-   c                ó˜   € V P                   w  r#rEV^8X  d   V # V R,          P                  W#WV4      p V P                  W#V,          WE4      # )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)
)ºNNNr}   Nr}   r}   )rh   ÚexpandÚreshape)rY   rz   ÚbatchÚnum_key_value_headsÚslenÚhead_dims   &&    r*   Ú	repeat_kvr„   ˜   sU   € ð
 2?×1DÑ1DÑ.€E Ø�„zØÐØ!Ð"2Õ3×:Ñ:¸5ÐW\ÐdlÓm€MØ× Ñ  ¸eÕ(CÀTÓTÐTr-   c                ó   € V ^8„  d   QhR\         P                  R\        P                  R\        P                  R\        P                  R\        P                  R,          R\        R\        R	\
        \        ,          /# )
r   ÚmoduleÚqueryÚkeyÚvalueÚattention_maskNÚscalingÚdropoutÚkwargs)rM   ÚModuler$   r'   Úfloatr   r   )r(   s   "r*   r+   r+   ¤   sw   € ÷ %ñ %Ü�I‰Ið%ä�<‰<ð%ô 
�‰ð%ô �<‰<ð	%ô
 —L‘L 4Õ'ð%ô ð%ô ð%ô Ô'Õ(ñ%r-   c                 ó"  € \        W P                  4      p\        W0P                  4      p	\        P                  ! WP	                  ^^4      4      V,          p
Ve	   W¤,           p
\
        P                  P                  V
R\        P                  R7      P                  VP                  4      p
\
        P                  P                  W¦V P                  R7      p
\        P                  ! W©4      pVP	                  ^^4      P                  4       pWº3# )r   ©rf   Údtype©ÚpÚtrainingrg   )r„   Únum_key_value_groupsr$   ÚmatmulÚ	transposerM   Ú
functionalÚsoftmaxÚfloat32Útor’   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×$?Ñ$?Ó@€Lä—<’< ×';Ñ';¸A¸qÓ'AÓBÀWÕL€LØÒ!Ø#Õ4ˆä—=‘=×(Ñ(¨¸2ÄUÇ]Á]Ð(ÓS×VÑVÐW\×WbÑWbÓc€LÜ—=‘=×(Ñ(¨È6Ï?É?Ð(Ó[€LÜ—,’,˜|Ó:€KØ×'Ñ'¨¨1Ó-×8Ñ8Ó:€KàÐ$Ð$r-   c                   óX   a a€ ] tR t^½t oRtV3R lV 3R lltRV3R lR lltRtVtV ;t	# )ÚNeuCodecAttentionz=Multi-headed attention from 'Attention Is All You Need' paperc                ó&   <€ V ^8„  d   QhRS[ RS[/# ©r   rD   Ú	layer_idx©r   r{   )r(   r)   s   "€r*   r+   ÚNeuCodecAttention.__annotate__Á   s   ø€ ÷ 
ñ 
™~ð 
¹#ñ 
r-   c                ó¢  <€ \         SV `  4        Wn        W n        \	        VR VP
                  VP                  ,          4      V n        VP                  VP                  ,          V n	        V P                  R,          V n
        VP                  V n        RV n        \        P                  ! VP
                  VP                  V P                  ,          VP                  R7      V n        \        P                  ! VP
                  VP                  V P                  ,          VP                  R7      V n        \        P                  ! VP
                  VP                  V P                  ,          VP                  R7      V n        \        P                  ! VP                  V P                  ,          VP
                  VP                  R7      V n        R# )rƒ   FrG   Ng      à¿)rI   rJ   rD   r§   ÚgetattrrO   Únum_attention_headsrƒ   r�   r–   r‹   Úattention_dropoutÚ	is_causalrM   rN   Úattention_biasÚq_projÚk_projÚv_projÚo_proj©rT   rD   r§   rU   s   &&&€r*   rJ   ÚNeuCodecAttention.__init__Á   sI  ø€ Ü‰ÑÔØŒØ"ŒÜ ¨
°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-   c                ó  <€ V ^8„  d   QhRS[ P                  RS[S[ P                  S[ P                  3,          R,          RS[ P                  R,          RS[R,          RS[S[,          RS[S[ P                  S[ P                  3,          /# )r   rY   Úposition_embeddingsNrŠ   Úpast_key_valuesr�   rZ   )r$   r'   Útupler   r   r   )r(   r)   s   "€r*   r+   r©   Ø   s‡   ø€ ÷ ))ñ ))á—|‘|ð))ñ #¡5§<¡<±·±Ð#=Õ>ÀÕEð))ñ Ÿ™ tÕ+ð	))ñ
  �ð))ñ Ñ+Õ,ð))ñ 
‰u�|‰|™UŸ\™\Ð)Õ	*ñ))r-   c                ó  € VP                   R R p. VORNV P                  N5pV P                  V4      P                  V4      P	                  ^^4      pV P                  V4      P                  V4      P	                  ^^4      p	V P                  V4      P                  V4      P	                  ^^4      p
Vw  r¼\        W‰W¼^R7      w  r‰Ve   VP                  WšV P                  4      w  rš\        P                  ! V P                  P                  \        4      pT! V VV	V
V3RV P                  '       g   RMV P                   RV P"                  /VB w  rïVP$                  ! . VORN5!  P'                  4       pV P)                  V4      pWï3# )N)ru   rŒ   ç        r‹   rg   )rh   rƒ   r°   Úviewr˜   r±   r²   rx   Úupdater§   r   Úget_interfacerD   Ú_attn_implementationr¢   r•   r­   r‹   r   r�   r³   )rT   rY   r·   rŠ   r¸   r�   Úinput_shapeÚhidden_shapeÚquery_statesrž   rŸ   rs   rt   Úattention_interfacer¡   r    s   &&&&&,          r*   r_   ÚNeuCodecAttention.forwardØ   sŒ  € ð $×)Ñ)¨#¨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ˆà&‰ˆô $8¸ÐRUÐjkÔ#lÑ ˆàÒ&Ø'6×'=Ñ'=¸jÐX\×XfÑXfÓ'gÑ$ˆJä(?×(MÒ(MØ�K‰K×,Ñ,Ô.Eó)
Ðñ %8ØØØØØñ	%
ð  $Ÿ}Ÿ}˜}‘C°$×2HÑ2Hð	%
ð —L‘Lð	%
ð ñ	%
Ñ!ˆð "×)Ò)Ð;¨;Ð;¸Ó;×FÑFÓHˆØ—k‘k +Ó.ˆØÐ(Ð(r-   )r­   rD   rƒ   r®   r±   r§   r–   r³   r°   r‹   r²   ©NNN©
r/   r0   r1   r2   r3   rJ   r_   r5   r6   rb   rc   s   @@r*   r¤   r¤   ½   s!   ù‡ € áG÷
ó 
÷.))÷ ))ò ))r-   r¤   ÚRMSNormc                   óZ   a a€ ] tR tRt oRV3R lV 3R llltV3R lR ltR tRtVtV ;t	# )	ÚNeuCodecRMSNormi  c                ó$   <€ V ^8„  d   QhRS[ RR/# )r   ÚepsrZ   N)r�   )r(   r)   s   "€r*   r+   ÚNeuCodecRMSNorm.__annotate__  s   ø€ ÷ $ñ $©ð $¸$ñ $r-   c                óŽ   <€ \         SV `  4        \        P                  ! \        P
                  ! V4      4      V n        W n        R# )z.
NeuCodecRMSNorm is equivalent to T5LayerNorm
N)rI   rJ   rM   r   r$   ÚonesÚweightÚvariance_epsilon)rT   rO   rË   rU   s   &&&€r*   rJ   ÚNeuCodecRMSNorm.__init__  s/   ø€ ô 	‰ÑÔÜ—l’l¤5§:¢:¨kÓ#:Ó;ˆŒØ #Ör-   c                óN   <€ V ^8„  d   QhRS[ P                  RS[ P                  /# rX   r[   )r(   r)   s   "€r*   r+   rÌ     s#   ø€ ÷ ;ñ ;¡U§\¡\ð ;±e·l±lñ ;r-   c                ó:  € VP                   pVP                  \        P                  4      pVP	                  ^4      P                  RRR7      pV\        P                  ! W0P                  ,           4      ,          pV P                  VP                  V4      ,          # )r   T)Úkeepdimrg   )	r’   rœ   r$   r›   ÚpowÚmeanÚrsqrtrÐ   rÏ   )rT   rY   Úinput_dtypeÚvariances   &&  r*   r_   ÚNeuCodecRMSNorm.forward  sw   € Ø#×)Ñ)ˆØ%×(Ñ(¬¯©Ó7ˆØ ×$Ñ$ QÓ'×,Ñ,¨R¸Ð,Ó>ˆØ%¬¯ª°H×?TÑ?TÕ4TÓ(UÕUˆØ�{‰{˜]×-Ñ-¨kÓ:Õ:Ð:r-   c                ó^   € \        V P                  P                  4       R V P                   2# )z, eps=)r¹   rÏ   rh   rÐ   )rT   s   &r*   Ú
extra_reprÚNeuCodecRMSNorm.extra_repr  s*   € Ü˜Ÿ™×)Ñ)Ó*Ð+¨6°$×2GÑ2GÐ1HÐIÐIr-   )rÐ   rÏ   )ç�íµ ÷Æ°>)
r/   r0   r1   r2   rJ   r_   rÜ   r5   r6   rb   rc   s   @@r*   rÉ   rÉ     s%   ù‡ € ÷$õ $÷;ð ;÷Jò Jr-   rÉ   c                   óT   a a€ ] tR tRt oV3R lV 3R lltRV3R lR lltRtVtV ;t# )ÚNeuCodecDecoderLayeri  c                ó&   <€ V ^8„  d   QhRS[ RS[/# r¦   r¨   )r(   r)   s   "€r*   r+   Ú!NeuCodecDecoderLayer.__annotate__  s   ø€ ÷ eñ e™~ð e¹#ñ er-   c                ó   <€ \         SV `  4        VP                  V n        \        WR 7      V n        \        V4      V n        \        VP                  VP                  R7      V n	        \        VP                  VP                  R7      V n
        R# ))rD   r§   ©rË   N)rI   rJ   rO   r¤   Ú	self_attnrA   ÚmlprÉ   Úrms_norm_epsÚinput_layernormÚpost_attention_layernormr´   s   &&&€r*   rJ   ÚNeuCodecDecoderLayer.__init__  sk   ø€ Ü‰ÑÔØ!×-Ñ-ˆÔä*°&ÔNˆŒä˜vÓ&ˆŒÜ.¨v×/AÑ/AÀv×GZÑGZÔ[ˆÔÜ(7¸×8JÑ8JÐPV×PcÑPcÔ(dˆÖ%r-   c                ó.  <€ V ^8„  d   QhRS[ P                  RS[ P                  R,          RS[ P                  R,          RS[R,          RS[R,          RS[S[ P                  S[ P                  3,          R,          RS[S[,          R	S[ P                  /# )
r   rY   rŠ   NÚposition_idsr¸   Ú	use_cacher·   r�   rZ   )r$   r'   r&   r   Úboolr¹   r   r   )r(   r)   s   "€r*   r+   râ   $  sœ   ø€ ÷ ñ á—|‘|ðñ Ÿ™ tÕ+ðñ ×&Ñ&¨Õ-ð	ñ
  �ðñ ˜$•;ðñ #¡5§<¡<±·±Ð#=Õ>ÀÕEðñ Ñ+Õ,ðñ 
�‰ñr-   c                óÔ   € TpV P                  V4      pV P                  ! RR VRVRVRVRVRV/VB w  rW�,           pTpV P                  V4      pV P                  V4      pW�,           pV# )rY   rŠ   rì   r¸   rí   r·   r.   )rè   rå   ré   ræ   )
rT   rY   rŠ   rì   r¸   rí   r·   r�   ÚresidualÚ_s
   &&&&&&&,  r*   r_   ÚNeuCodecDecoderLayer.forward$  s©   € ð !ˆØ×,Ñ,¨]Ó;ˆàŸ>š>ñ 
Ø'ð
à)ð
ð &ð
ð ,ð	
ð
  ð
ð !4ð
ð ñ
Ñˆð !Õ0ˆð !ˆØ×5Ñ5°mÓDˆØŸ™ Ó/ˆØ Õ0ˆØÐr-   )rO   rè   ræ   ré   rå   )NNNFNra   rc   s   @@r*   rà   rà     s    ù‡ € ÷eó e÷÷ ò r-   rà   c                   ó@   a a€ ] tR tRt oRtRV 3R lltR tRtVtV ;t	# )ÚNeuCodecSnakeBetaiD  aä  
A modified Snake function which uses separate parameters for the magnitude of the periodic components
Shape:
    - Input: (B, C, T)
    - Output: (B, C, T), same shape as the input
Parameters:
    - alpha - trainable parameter that controls frequency
    - beta - trainable parameter that controls magnitude
References:
    - This activation function is a modified version based on this paper by Liu Ziyin, Tilman Hartwig, Masahito Ueda:
    https://huggingface.co/papers/2006.08195
c                óê   <€ \         SV `  4        Wn        \        \        P
                  ! V4      V,          4      V n        \        \        P
                  ! V4      V,          4      V n        R V n        R# )g•Ö&è.>N)	rI   rJ   Úin_featuresr   r$   ÚzerosÚalphaÚbetaÚno_div_by_zero)rT   rö   rø   rU   s   &&&€r*   rJ   ÚNeuCodecSnakeBeta.__init__R  sR   ø€ Ü‰ÑÔØ&Ôô œuŸ{š{¨;Ó7¸%Õ?Ó@ˆŒ
ÜœeŸkšk¨+Ó6¸Õ>Ó?ˆŒ	à)ˆÖr-   c                ó²  € V P                   P                  ^ 4      P                  R4      pV P                  P                  ^ 4      P                  R4      p\        P                  ! V4      p\        P                  ! V4      pVRW0P
                  ,           ,          \        P                  ! \        P                  ! W,          4      ^4      ,          ,           pV# )ur   
Forward pass of the function.
Applies the function to the input elementwise.
SnakeBeta âˆ¶= x + 1/b * sin^2 (xa)
ç      ð?rg   )rø   rp   rù   r$   Úexprú   rÕ   rt   )rT   rY   rø   rù   s   &&  r*   r_   ÚNeuCodecSnakeBeta.forward\  s¡   € ð —
‘
×$Ñ$ QÓ'×1Ñ1°"Ó5ˆØ�y‰y×"Ñ" 1Ó%×/Ñ/°Ó3ˆÜ—	’	˜%Ó ˆÜ�yŠy˜‹ˆØ%¨°×7JÑ7JÕ0JÕ)KÌuÏyÊyÜ�IŠI�mÕ+Ó,¨aóP
õ )
õ 
ˆð Ðr-   )rø   rù   rö   rú   )rý   rÆ   rc   s   @@r*   rô   rô   D  s   ù‡ € ñ÷*÷ò r-   rô   c                ó@  € V^,          ^ 8H  pV^,          p^V,          pRV^,
          ,          \         P                  ,          V,          R,           pVR8”  d   RVR,
          ,          pM6VR8¼  d.   RV^,
          R,          ,          R	VR,
          ,          ,           pMR
p\        P                  ! W'R\        P                  R7      pV'       d!   \        P
                  ! V) V4      R,           p	M\        P
                  ! V4      V,
          p	V ^ 8X  d*   \        P                  ! ^^V3\        P                  R7      # \        P                  ! ^V ,          V	,          4      p
^V ,          V,          V
,          pW»P                  4       ,          pVP                  ^^V4      # )a&  Generates a 1D Kaiser-windowed sinc filter.

Args:
    cutoff (float): Normalized cutoff frequency (0 to 0.5).
    half_width (float): Transition bandwidth.
    kernel_size (int): Number of filter taps.

Returns:
    torch.Tensor: A tensor of shape (1, 1, kernel_size) representing the filter.
gHáz®G@gÍÌÌÌÌÌ@g      I@gKê46¼?gffffff!@g      5@g¨WÊ2Ä±â?gš™™™™™Ù?gUjö@+0´?r»   F)rù   Úperiodicr’   ç      à?©r’   )
ÚmathÚpir$   Úkaiser_windowr›   Úaranger÷   ÚsincÚsumr¼   )ÚcutoffÚ
half_widthÚkernel_sizeÚis_evenÚ	half_sizeÚdelta_fÚattenuationrù   r  Útime_indicesÚsinc_filterÚnormalized_filters   &&&         r*   Úkaiser_sinc_filter1dr  m  sR  € ð ˜A�o Ñ"€GØ˜qÕ €Ið �*�n€GØ˜9 q�=Õ)¬D¯G©GÕ3°gÕ=ÀÕD€Kà�TÔØ˜ sÕ*Õ+‰Ø	˜Ô	Ø˜ rÕ)¨cÕ1Õ1°G¸{ÈTÕ?QÕ4RÕR‰àˆä×'Ò'¨ÈÔV[×VcÑVcÔd€M÷ Ü—|’| Y J°	Ó:¸SÕ@‰ä—|’| KÓ0°9Õ<ˆð �„{Ü�{Š{˜A˜q +Ð.´e·m±mÔDÐDä—*’*˜Q �Z¨,Õ6Ó7€KØ˜F�
 ]Õ2°[Õ@Ðð ×.Ñ.Ó0Õ0Ðà×!Ñ! ! Q¨Ó4Ð4r-   c                   ó<   a a€ ] tR tRt oRV 3R lltR tRtVtV ;t# )ÚNeuCodecDownSample1di›  c                ó   <€ \         SV `  4        R V,          pRV,          pW0n        W@n        W n        VR8  d   \        R4      hVR 8”  d   \        R4      hV^,          ^ 8H  V n        V^,          \        V P                  4      ,
          V n        V^,          V n	        Wn
        \        W4V4      p\        P                  ! VRR7      V n        R# )r  ç333333ã?r»   z(Minimum cutoff must be larger than zero.z'A cutoff above 0.5 does not make sense.F©Ú
persistentN)rI   rJ   r
  r  r  Ú
ValueErrorÚevenr{   Úpad_leftÚ	pad_rightÚstrider  rM   ÚBufferÚfilter)rT   Úratior  r
  r  r!  rU   s   &&&   €r*   rJ   ÚNeuCodecDownSample1d.__init__œ  s®   ø€ Ü‰ÑÔØ�u•ˆØ˜5•[ˆ
ØŒØ$ŒØ&Ôà�CŒ<ÜÐGÓHÐHØ�CŒ<ÜÐFÓGÐGà !•O qÑ(ˆŒ	Ø# qÕ(¬3¨t¯y©y«>Õ9ˆŒØ$¨Õ)ˆŒØŒÜ% f¸+ÓFˆÜ—i’i °5Ô9ˆŽr-   c                ó8  € VP                   ^,          p\        P                  ! WP                  V P                  3RR7      p\        P
                  ! VV P                  P                  VP                  4      P                  VRR4      V P                  VR7      pV# )é   Ú	replicate©Úmode©r  Úgroupsrg   )rh   ÚFÚpadr  r  Úconv1dr!  rœ   r’   r~   r  )rT   rY   ÚchannelsÚouts   &&  r*   r_   ÚNeuCodecDownSample1d.forward°  sw   € Ø ×&Ñ& qÕ)ˆÜŸš˜m¯m©m¸T¿^¹^Ð-LÐS^Ô_ˆÜ�hŠhØà�K‰K�N‰N˜=×.Ñ.Ó/×6Ñ6°xÀÀRÓHØ—;‘;Øô
ˆð ˆ
r-   )r
  r  r!  r  r  r  r  r  ©r   Nra   rc   s   @@r*   r  r  ›  s   ù‡ € ÷:÷(
ò 
r-   r  c                   ó<   a a€ ] tR tRt oRV 3R lltR tRtVtV ;t# )ÚNeuCodecUpSample1di½  c                ó�  <€ \         SV `  4        Wn        Vf!   \        ^V,          ^,          4      ^,          MTV n        Wn        V P                  V,          ^,
          V n        V P                  V P
                  ,          V P                  V P
                  ,
          ^,          ,           V n        V P                  V P
                  ,          V P                  V P
                  ,
          ^,           ^,          ,           V n        \        RV,          RV,          V P                  R7      p\        P                  ! VRR7      V n        R # )Nr  r  )r
  r  r  Fr  )rI   rJ   r"  r{   r  r  r,  r  r  r  rM   r   r!  )rT   r"  r  r!  rU   s   &&& €r*   rJ   ÚNeuCodecUpSample1d.__init__¾  sá   ø€ Ü‰ÑÔØŒ
Ø6AÒ6Iœ3˜q 5�y¨A�~Ó.°Ö2È{ˆÔØŒØ×#Ñ# uÕ,¨qÕ0ˆŒØŸ™ 4§;¡;Õ.°$×2BÑ2BÀTÇ[Á[Õ2PÐUVÕ1VÕVˆŒØŸ™ D§K¡KÕ/°4×3CÑ3CÀdÇkÁkÕ3QÐTUÕ3UÐZ[Õ2[Õ[ˆŒä%¨S°5­[ÀSÈ5Å[Ð^b×^nÑ^nÔoˆÜ—i’i °5Ô9ˆŽr-   c           	     óž  € VP                   ^,          p\        P                  ! WP                  V P                  3RR7      pV P                  \        P                  ! VV P
                  P                  VP                  4      P                  VRR4      V P                  VR7      ,          pVRV P                  V P                  ) 13,          pV# )r%  r&  r'  r)  .rg   )rh   r+  r,  r"  Úconv_transpose1dr!  rœ   r’   r~   r  r  r  )rT   rY   r.  s   && r*   r_   ÚNeuCodecUpSample1d.forwardÊ  s¢   € Ø ×&Ñ& qÕ)ˆÜŸš˜m¯h©h¸¿¹Ð-AÈÔTˆØŸ
™
¤Q×%7Ò%7Øà�K‰K�N‰N˜=×.Ñ.Ó/×6Ñ6°xÀÀRÓHØ—;‘;Øô&
õ 
ˆð & c¨4¯=©=¸D¿N¹N¸?Ð+JÐ&JÕKˆØÐr-   )r!  r  r,  r  r  r"  r  r1  ra   rc   s   @@r*   r3  r3  ½  s   ù‡ € ÷
:÷ò r-   r3  c                   ó†   a a€ ] tR tRt oRtV3R lV 3R lltRR ltV3R lR ltRV3R lR	 lltV3R
 lR lt	Rt
VtV ;t# )Ú NeuCodecFiniteScalarQuantizationiØ  a  
Finite Scalar Quantization (FSQ) module that quantizes continuous latent representations into discrete codes.
Original code: https://github.com/lucidrains/vector-quantize-pytorch/blob/353d46027888dfb140c3c65a67a7356f1492d71d/vector_quantize_pytorch/finite_scalar_quantization.py#L64

Original modeling uses `ResidualFSQ` with a single quantizer: https://huggingface.co/HKUSTAudio/neucodec/blob/main/vq/codec_decoder_vocos.py#L389
But we can directly use FSQ since a main feature of NeuCodec is that it uses a single codebook.
c                ó    <€ V ^8„  d   QhRS[ /# rC   r   )r(   r)   s   "€r*   r+   Ú-NeuCodecFiniteScalarQuantization.__annotate__á  s   ø€ ÷ >ñ >™~ñ >r-   c                ó,  <€ \         SV `  4        \        VP                  4      V n        V P	                  4       w  r#p\
        P                  ! VR R7      V n        \
        P                  ! VR R7      V n        \
        P                  ! VR R7      V n	        R# )Fr  N)
rI   rJ   ÚlistÚquantization_levelsÚ_compute_buffersrM   r   ÚlevelsÚbasisÚcodebook)rT   rD   rA  rB  rC  rU   s   &&   €r*   rJ   Ú)NeuCodecFiniteScalarQuantization.__init__á  sj   ø€ Ü‰ÑÔÜ#'¨×(BÑ(BÓ#CˆÔ Ø"&×"7Ñ"7Ó"9Ñˆ�xÜ—i’i °5Ô9ˆŒÜ—Y’Y˜u°Ô7ˆŒ
ÜŸ	š	 (°uÔ=ˆŽr-   c                óú  € \         P                  ! V P                  \         P                  VR7      p\         P                  ! \         P                  ! ^.V P                  RR ,           VR7      ^ \         P                  R7      p\         P
                  ! \        \        P                  ! V P                  4      4      VR7      P                  R4      pWC,          V,          pV^,          pWV,
          V,          pW#V3# )zFCompute the levels, basis, and codebook buffers for the FSQ quantizer.©r’   ÚdeviceN©rG  r‘   rg   )
r$   Útensorr?  Úint32Úcumprodr  r{   ÚnpÚprodrp   )rT   rG  rA  rB  ÚindicesÚlevel_indicesr  rC  s   &&      r*   r@  Ú1NeuCodecFiniteScalarQuantization._compute_buffersé  s»   € ä—’˜d×6Ñ6¼e¿k¹kÐRXÔYˆÜ—’Ü�LŠL˜!˜˜t×7Ñ7¸¸Ð<Õ<ÀVÔLÐRSÔ[`×[fÑ[fô
ˆô —,’,œs¤2§7¢7¨4×+CÑ+CÓ#DÓEÈfÔU×_Ñ_Ð`bÓcˆØ Õ)¨VÕ3ˆØ˜q•[ˆ
Ø!Õ.°*Õ<ˆØ˜hÐ&Ð&r-   c                óN   <€ V ^8„  d   QhRS[ P                  RS[ P                  /# ©r   rN  rZ   r[   )r(   r)   s   "€r*   r+   r<  õ  s#   ø€ ÷ ñ ©¯©ð ¹%¿,¹,ñ r-   c                ó²   € VP                  R4      pWP                  ,          V P                  ,          pV P                  ^,          pW#,
          V,          pV# )zP
Convert integer codebook indices to normalized per-dimension codes in [-1, 1].
rg   )rp   rB  rA  )rT   rN  rO  r  Úcodess   &&   r*   Ú_indices_to_codesÚ2NeuCodecFiniteScalarQuantization._indices_to_codesõ  sI   € ð ×#Ñ# BÓ'ˆØ §J¡JÕ.°$·+±+Õ=ˆØ—[‘[ AÕ%ˆ
ØÕ+¨zÕ9ˆØˆr-   c                óT   <€ V ^8„  d   QhRS[ P                  RS[RS[ P                  /# )r   rY   rË   rZ   )r$   r'   r�   )r(   r)   s   "€r*   r+   r<  ÿ  s/   ø€ ÷ Dñ D¡5§<¡<ð D±eð DÁuÇ|Á|ñ Dr-   c                ó  € V P                   ^,
          ^V,           ,          ^,          p\        P                  ! V P                   ^,          ^ 8H  RR4      pWC,          P                  4       pW,           P	                  4       V,          V,
          # )a�  
Constrain `hidden_states` to the valid quantization range for each dimension.

Uses a scaled tanh to soft-clip values into the interval
$[-(L-1)/2, (L-1)/2]$ (offset by 0.5 for even-level dimensions), where $L$ is
the number of quantization levels. The small `eps` margin prevents values from
saturating exactly at the boundary, which would zero out gradients.

Args:
    hidden_states (`torch.Tensor`): Continuous input to be bounded.
    eps (`float`, *optional*, defaults to `1e-3`):
        Small margin added to the level range to avoid gradient saturation at boundaries.

Returns:
    `torch.Tensor`: Bounded values in the valid quantization range.
r  r»   )rA  r$   ÚwhereÚatanhÚtanh)rT   rY   rË   Ú
half_rangeÚoffsetÚshifts   &&&   r*   ÚboundÚ&NeuCodecFiniteScalarQuantization.boundÿ  sk   € ð" —k‘k A•o¨!¨c­'Õ2°QÕ6ˆ
Ü—’˜TŸ[™[¨1�_°Ñ1°3¸Ó<ˆØÕ$×+Ñ+Ó-ˆØÕ%×+Ñ+Ó-°
Õ:¸VÕCÐCr-   c                óx   <€ V ^8„  d   QhRS[ P                  RS[S[ P                  S[ P                  3,          /# rX   ©r$   r'   r¹   )r(   r)   s   "€r*   r+   r<    s1   ø€ ÷ 1ñ 1¡U§\¡\ð 1±e¹E¿L¹LÉ%Ï,É,Ð<VÕ6Wñ 1r-   c                óÊ  € VP                   p\        VP                  P                  \        4      '       d2   VP                  P                  R 8w  d   VP                  P                  MRp\        VRR7      ;_uu_ 4        VP                  4       pV P                  ^,          pV P                  V4      pVP                  4       pWV,
          P                  4       ,           pWd,          pWd,          V,           pWpP                  ,          P                  RR7      P                  \        P                  4      pRRR4       XP                  V4      X3#   + '       g   i     L#; i)ÚmpsÚcpuF©Údevice_typeÚenabledre   Nrg   )r’   Ú
isinstancerG  ÚtypeÚstrr   r�   rA  r_  ÚroundÚdetachrB  r	  rœ   r$   rJ  )	rT   rY   Úoriginal_dtyperg  r  ÚroundedrT  Úcode_scaledrN  s	   &&       r*   r_   Ú(NeuCodecFiniteScalarQuantization.forward  s  € à&×,Ñ,ˆô ˜-×.Ñ.×3Ñ3´S×9Ò9¸m×>RÑ>R×>WÑ>WÐ[`Ô>`ð × Ñ ×%Ò%àð 	ô
 ¨¸U×CÖCØ)×/Ñ/Ó1ˆMØŸ™¨Õ)ˆJà ŸJ™J }Ó5ˆMØ#×)Ñ)Ó+ˆGØ!¨}Õ%<×$DÑ$DÓ$FÕFˆEØÕ&ˆEà Õ-°Õ;ˆKØ"§Z¡ZÕ/×4Ñ4¸Ð4Ó<×?Ñ?ÄÇÁÓLˆG÷ Dð �x‰x˜Ó'¨Ð0Ð0÷ D×Cús   Á?B8EÅE"	)rB  rC  rA  r?  r]   )gü©ñÒMbP?)r/   r0   r1   r2   r3   rJ   r@  rU  r_  r_   r5   r6   rb   rc   s   @@r*   r:  r:  Ø  s>   ù‡ € ñ÷>ó >ô
'÷ð ÷Dò D÷,1÷ 1ð 1r-   r:  c                   óT   a a€ ] tR tRt oRtV3R lV 3R lltV3R lR ltRtVtV ;t	# )ÚNeuCodecISTFTHeadi+  zé
Head for converting decoder outputs to waveform via STFT projection and ISTFT.

Uses custom "same" padding ISTFT from Vocos:
https://github.com/gemelo-ai/vocos/blob/c859e3b7b534f3776a357983029d34170ddd6fc3/vocos/spectral_ops.py#L47
c                ó    <€ V ^8„  d   QhRS[ /# rC   r   )r(   r)   s   "€r*   r+   ÚNeuCodecISTFTHead.__annotate__3  s   ø€ ÷ :ñ :™~ñ :r-   c                ó¢  <€ \         SV `  4        \        P                  ! VP                  VP
                  ^,           4      V n        VP
                  V n        VP                  V n        V P
                  V P                  ,
          ^,          V n        \        P                  ! VP
                  4      p\        P                  ! VRR7      V n        R# )r   Fr  N)rI   rJ   rM   rN   rO   Ún_fftÚlinearÚ
hop_lengthÚpaddingr$   Úhann_windowr   Úwindow)rT   rD   r|  rU   s   && €r*   rJ   ÚNeuCodecISTFTHead.__init__3  s†   ø€ Ü‰ÑÔÜ—i’i × 2Ñ 2°F·L±LÀ1Õ4DÓEˆŒØ—\‘\ˆŒ
Ø ×+Ñ+ˆŒØŸ
™
 T§_¡_Õ4¸Õ:ˆŒÜ×"Ò" 6§<¡<Ó0ˆÜ—i’i °5Ô9ˆŽr-   c                óN   <€ V ^8„  d   QhRS[ P                  RS[ P                  /# rX   r[   )r(   r)   s   "€r*   r+   ru  <  s#   ø€ ÷ ""ñ ""¡U§\¡\ð ""±e·l±lñ ""r-   c                óT  € V P                  V4      pVP                  ^R
R7      w  r4VP                  4       pVP                  4       p\        P                  ! V4      P                  RR7      p\        P                  ! W44      p\        P                  P                  WPP                  R
RR7      P                  ^^4      pW`P                  R,          ,          pVP                  ^,          pV^,
          V P                  ,          V P                  ,           p\        P                  ! V^V3^V P                  3^V P                  3R7      R^ ^ V P                   V P                   ) 13,          p	\        P                  ! V P                  P#                  4       P%                  ^VR
4      P                  ^^4      ^V3^V P                  3^V P                  3R7      P'                  4       V P                   V P                   )  p
V
P                  RR	7      p
Wš,          p	V	P)                  ^4      # )r   re   g      Y@)ÚmaxÚbackward)rf   Únormr}   )Úoutput_sizer  r  g•dyáý¥=)Úminrg   ©Nr}   N)rx  Úchunkr�   r$   rþ   ÚclampÚpolarÚfftÚirfftrw  r˜   r|  rh   ry  r+  Úfoldrz  Úsquarer~   Úsqueezerp   )rT   rY   Ú	stft_predÚ	magnitudeÚphaseÚspectrogram_complexÚtime_framesÚ
num_framesrƒ  ÚaudioÚwindow_envelopes   &&         r*   r_   ÚNeuCodecISTFTHead.forward<  sÇ  € Ø—K‘K Ó.ˆ	à$Ÿ?™?¨1°"˜?Ó5Ñˆ	à—O‘OÓ%ˆ	Ø—‘“ˆä—I’I˜iÓ(×.Ñ.°3Ð.Ó7ˆ	Ü#Ÿkšk¨)Ó;Ðô —i‘i—o‘oÐ&9¿:¹:È2ÐT^�oÓ_×iÑiÐjkÐmnÓoˆØ!§K¡K°Õ$>Õ>ˆØ(×.Ñ.¨qÕ1ˆ
Ø! A•~¨¯©Õ8¸4¿:¹:ÕEˆÜ—’ØØ˜KÐ(Ø˜DŸJ™J˜Ø�t—‘Ð'ô	
ð
 ˆQ��4—<‘< 4§<¡< -Ð/Ð
/õ1ˆô Ÿ&š&Ø�K‰K×ÑÓ ×'Ñ'¨¨:°rÓ:×DÑDÀQÈÓJØ˜KÐ(Ø˜DŸJ™J˜Ø�t—‘Ð'ô	
÷
 ‰'‹)�D—L‘L D§L¡L =ð2ˆð *×/Ñ/°EÐ/Ó:ˆØÕ'ˆØ�‰˜qÓ!Ð!r-   )ry  rx  rw  rz  r|  rÆ   rc   s   @@r*   rs  rs  +  s#   ù‡ € ñ÷:ó :÷""÷ ""ð ""r-   rs  c                   ó|   a a€ ] tR tRt oRtRtRtRtR.tRt	Rt
RtRtRtRtRtR]R]/tV 3R	 ltV3R
 ltRtVtV ;t# )ÚNeuCodecPreTrainedModelia  ÚneucodecTNr¸   Úinput_valuesrY   Ú
attentionsc                ó|  <€ \         SV `  V4       \        V\        4      '       dC   \        P
                  ! VP                  4       \        P
                  ! VP                  4       R# \        V\        4      '       dD   \        P                  ! VP                  4      p\        P                  ! VP                  V4       R# \        V\        4      '       d�   VP                  VP                   P"                  R 7      w  r4p\        P                  ! VP                   V4       \        P                  ! VP$                  V4       \        P                  ! VP&                  V4       R# \        V\(        4      '       d]   \+        RVP,                  ,          RVP,                  ,          VP.                  4      p\        P                  ! VP0                  V4       R# \        V\2        4      '       dO   \+        VP4                  VP6                  VP.                  4      p\        P                  ! VP0                  V4       R# R# )rH  r  r  N)rI   Ú_init_weightsri  rô   ÚinitÚzeros_rø   rù   rs  r$   r{  rw  Úcopy_r|  r:  r@  rA  rG  rB  rC  r3  r  r"  r  r!  r  r
  r  )rT   r†   r|  rA  rB  rC  Úfilter_tensorrU   s   &&     €r*   r�  Ú%NeuCodecPreTrainedModel._init_weightsu  sc  ø€ Ü‰Ñ˜fÔ%Ü�fÔ/×0Ò0Ü�KŠK˜Ÿ™Ô%Ü�KŠK˜Ÿ™Ö$Ü˜Ô 1×2Ò2Ü×&Ò& v§|¡|Ó4ˆFÜ�JŠJ�v—}‘} fÖ-Ü˜Ô @×AÒAØ&,×&=Ñ&=ÀVÇ]Á]×EYÑEYÐ&=Ó&ZÑ#ˆF˜8Ü�JŠJ�v—}‘} fÔ-Ü�JŠJ�v—|‘| UÔ+Ü�JŠJ�v—‘¨Ö1Ü˜Ô 2×3Ò3Ü0°°v·|±|Õ1CÀSÈ6Ï<É<ÕEWÐY_×YkÑYkÓlˆMÜ�JŠJ�v—}‘} mÖ4Ü˜Ô 4×5Ò5Ü0°·±À×@QÑ@QÐSY×SeÑSeÓfˆMÜ�JŠJ�v—}‘} mÖ4ñ 6r-   c                ó&   <€ V ^8„  d   Qh/ S[ ;R&   # rC   r   )r(   r)   s   "€r*   r+   Ú$NeuCodecPreTrainedModel.__annotate__a  s   ø‡ ‚ áÑò r-   r.   )r”  )r/   r0   r1   r2   Úbase_model_prefixÚinput_modalitiesÚsupports_gradient_checkpointingÚ_no_split_modulesÚ_skip_keys_device_placementÚ_supports_flash_attnÚ_supports_sdpaÚ_supports_flex_attnÚ_supports_cache_classÚ_supports_attention_backendÚ_can_compile_fullgraphÚmain_input_namerà   Ú_can_record_outputsr�  r4   r5   r6   rb   rc   s   @@r*   r˜  r˜  a  sp   ù‡ € ð #ÐØ!ÐØ&*Ð#ØÐØ#4Ð"5ÐØÐØ€NØÐØ ÐØ"&ÐØ!ÐØ$€OàÐ-ØÐ*ðÐõ
5÷) … r-   r˜  c                   óÎ   a a€ ] tR tRt o]! RRR7      RV3R lV 3R lll4       t]]! RRR7      RV3R lR ll4       4       t]P                  ! 4       ]
R	 4       4       tR
tVtV ;t# )ÚNeuCodecRotaryEmbeddingiŠ  rG  z5.18)Úversionc                ó    <€ V ^8„  d   QhRS[ /# rC   r   )r(   r)   s   "€r*   r+   Ú$NeuCodecRotaryEmbedding.__annotate__Œ  s   ø€ ÷ Oñ O™~ñ Or-   c                óä  <€ \         SV `  4        VP                  V n        VP                  V n        Wn        V P
                  P                  R ,          V n        V P                  pV P                  R8w  d   \        V P                  ,          pV! V P
                  V4      w  q@n
        \        P                  ! VRR7      V n        \        P                  ! VP                  4       RR7      V n        R# )Ú	rope_typeÚdefaultFr  N)rI   rJ   Úmax_position_embeddingsÚmax_seq_len_cachedÚoriginal_max_seq_lenrD   Úrope_parametersr¸  Úcompute_default_rope_parametersr   Úattention_scalingrM   r   Úinv_freqÚcloneÚoriginal_inv_freq)rT   rD   rG  Úrope_init_fnrÀ  rU   s   &&&  €r*   rJ   Ú NeuCodecRotaryEmbedding.__init__‹  s¬   ø€ ä‰ÑÔØ"(×"@Ñ"@ˆÔØ$*×$BÑ$BˆÔ!àŒàŸ™×4Ñ4°[ÕAˆŒØ!%×!EÑ!EˆØ�>‰>˜YÔ&Ü.¨t¯~©~Õ>ˆLÙ+7¸¿¹ÀVÓ+LÑ(ˆÔ(äŸ	š	 (°uÔ=ˆŒÜ!#§¢¨8¯>©>Ó+;ÈÔ!NˆÖr-   c                óP   <€ V ^8„  d   QhRS[ RS[S[P                  S[3,          /# )r   rD   rZ   )r   r¹   r$   r'   r�   )r(   r)   s   "€r*   r+   r¶  ž  s.   ø€ ÷ 5ñ 5±ð 5ÑZ_Ñ`e×`lÑ`lÑnsÐ`sÕZtñ 5r-   c           	     ó0  € V P                   R,          p\        V RR4      ;'       g    V P                  V P                  ,          pRpRV\        P
                  ! ^ V^\        P                  R7      V,          ,          ,          pVP                  V4      V3# )a~  
Computes the inverse frequencies according to the original RoPE implementation
Args:
    config ([`~transformers.PreTrainedConfig`]):
        The model configuration.
Returns:
    Tuple of (`torch.Tensor`, `float`), containing the inverse frequencies for the RoPE embeddings and the
    post-processing scaling factor applied to the computed cos/sin (unused in this type of RoPE).
Ú
rope_thetarƒ   Nrý   r  )r½  r«   rO   r¬   r$   r  r�   rœ   )rD   rG  r�   Úbaserf   Úattention_factorrÀ  s   &&,    r*   r¾  Ú7NeuCodecRotaryEmbedding.compute_default_rope_parametersœ  s~   € ð ×%Ñ% lÕ3ˆÜ�f˜j¨$Ó/×cÐc°6×3EÑ3EÈ×IcÑIcÕ3cˆàÐà˜$¤5§<¢<°°3¸ÄÇÁÔ#MÐPSÕ#SÕTÕUˆØ�{‰{˜6Ó"Ð$4Ð4Ð4r-   c                ó^  € V P                   R,          P                  VP                  ^ ,          R	^4      P                  \        P
                  VP                  R7      pVR
,          P                  4       p\        VP                  P                  \        4      '       d2   VP                  P                  R8w  d   VP                  P                  MRp\        VRR7      ;_uu_ 4        W4,          P                  ^^4      p\        P                  ! Wf3R	R7      pVP                  4       V P                  ,          pVP                  4       V P                  ,          p	R R R 4       XP                  VP                   R7      X	P                  VP                   R7      3#   + '       g   i     LH; i)NrF  rd  re  Frf  re   r  r…  rg   )r}   Nr}   )rÀ  r~   rh   rœ   r$   r�   rG  ri  rj  rk  r   r˜   ri   rs   r¿  rt   r’   )
rT   rj   rì   Úinv_freq_expandedÚposition_ids_expandedrg  ÚfreqsÚembrs   rt   s
   &&&       r*   r_   ÚNeuCodecRotaryEmbedding.forward°  s2  € ð �M‰M˜-Õ(×/Ñ/°×0BÑ0BÀ1Õ0EÀrÈ1ÓM×PÑPÔW\×WbÑWbÐkl×ksÑksÐPÓtð 	ð !-¨ZÕ 8× >Ñ >Ó @Ðä'1°!·(±(·-±-Ä×'EÒ'EÈ!Ï(É(Ï-É-Ð[`ÔJ`�a—h‘h—m’mÐfkˆä¨¸U×CÖCØ&Õ>×IÑIÈ!ÈQÓOˆEÜ—)’)˜U˜N°Ô3ˆCØ—'‘'“)˜d×4Ñ4Õ4ˆCØ—'‘'“)˜d×4Ñ4Õ4ˆC÷	 Dð �v‰v˜AŸG™GˆvÓ$ c§f¡f°1·7±7 fÓ&;Ð;Ð;÷ D×Cús   Ã(A4FÆF,	)r¿  rD   rÀ  r»  rÂ  r¼  r¸  r]   )r/   r0   r1   r2   r   rJ   Ústaticmethodr¾  r$   Úno_gradr   r_   r5   r6   rb   rc   s   @@r*   r³  r³  Š  su   ù‡ € Ù�X vÔ.÷Oô Oó /ðOð  Ù�X vÔ.÷5ñ 5ó /ó ð5ð$ ‡]‚]ƒ_Øñ<ó ó ÷<ð <r-   r³  c                   óH   a a€ ] tR tRt oRV3R lV 3R llltR tRtVtV ;t# )ÚNeuCodecAntiAliasedActivation1diÃ  c                ó2   <€ V ^8„  d   QhRS[ RS[ RS[ RS[ /# )r   Úup_ratioÚ
down_ratioÚup_kernel_sizeÚdown_kernel_size)r{   )r(   r)   s   "€r*   r+   Ú,NeuCodecAntiAliasedActivation1d.__annotate__Ä  s;   ø€ ÷ Mñ Mñ ðMñ ð	Mñ
 ðMñ ñMr-   c                ó¨   <€ \         SV `  4        \        V4      '       g   \        R 4      hWn        \        W$4      V n        \        W54      V n        R# )z$Activation function must be callableN)	rI   rJ   ÚcallableÚ	TypeErrorÚactr3  Úupsampler  Ú
downsample)rT   Ú
activationrÖ  r×  rØ  rÙ  rU   s   &&&&&&€r*   rJ   Ú(NeuCodecAntiAliasedActivation1d.__init__Ä  sD   ø€ ô 	‰ÑÔÜ˜
×#Ò#ÜÐBÓCÐCØŒÜ*¨8ÓDˆŒÜ.¨zÓLˆŽr-   c                ól   € V P                  V4      pV P                  V4      pV P                  V4      pV# r]   )rß  rÞ  rà  r^   s   &&r*   r_   Ú'NeuCodecAntiAliasedActivation1d.forwardÓ  s2   € ØŸ™ mÓ4ˆØŸ™ Ó/ˆØŸ™¨Ó6ˆàÐr-   )rÞ  rà  rß  )r   r   é   rå  ra   rc   s   @@r*   rÔ  rÔ  Ã  s   ù‡ € ÷Mõ M÷ò r-   rÔ  c                   ó<   a a€ ] tR tRt oRtV 3R ltR tRtVtV ;t	# )ÚNeuCodecResidualUnitiÛ  zY
A residual unit composed of Snake1d and weight-normalized Conv1d layers with dilations.
c                ó"  <€ \         SV `  4        ^V,          ^,          p\        \        V4      R7      V n        \
        P                  ! W^W#R7      V n        \        \        V4      R7      V n        \
        P                  ! W^R7      V n	        R# )é   ©rá  )r  Údilationrz  )r  N)
rI   rJ   rÔ  rô   Úsnake1rM   ÚConv1dÚconv1Úsnake2Úconv2)rT   Ú	dimensionrë  r,  rU   s   &&& €r*   rJ   ÚNeuCodecResidualUnit.__init__à  si   ø€ Ü‰ÑÔØ˜Õ! aÕ'ˆÜ5ÔARÐS\ÓA]Ô^ˆŒÜ—Y’Y˜yÀÈXÔcˆŒ
Ü5ÔARÐS\ÓA]Ô^ˆŒÜ—Y’Y˜yÀÔCˆŽ
r-   c                ó&  € TpV P                  V P                  V4      4      pV P                  V P                  V4      4      pVP                  R,          VP                  R,          ,
          ^,          pV^ 8”  d   VRW3) 13,          pW,           pV# )a2  
Forward pass through the residual unit.

Args:
    hidden_state (`torch.Tensor` of shape `(batch_size, channels, time_steps)`):
        Input tensor .

Returns:
    output_tensor (`torch.Tensor` of shape `(batch_size, channels, time_steps)`):
        Input tensor after passing through the residual unit.
.rg   )rî  rì  rð  rï  rh   )rT   Úhidden_stateÚoutput_tensorrz  s   &&  r*   r_   ÚNeuCodecResidualUnit.forwardè  s…   € ð %ˆØŸ
™
 4§;¡;¨}Ó#=Ó>ˆØŸ
™
 4§;¡;¨}Ó#=Ó>ˆà×%Ñ% bÕ)¨M×,?Ñ,?ÀÕ,CÕCÈÕIˆØ�QŒ;Ø'¨¨W°XÐ-=Ð(=Õ>ˆLØ$Õ4ˆØÐr-   )rî  rð  rì  rï  rÆ   rc   s   @@r*   rç  rç  Û  s   ù‡ € ñõD÷ò r-   rç  c                   óL   a a€ ] tR tRt oRtRV3R lV 3R llltR tRtVtV ;t	# )ÚNeuCodecEncoderBlockiÿ  z'Encoder block used in NEUCODEC encoder.c                ó,   <€ V ^8„  d   QhRS[ RS[RS[/# )r   rD   r  Ústride_indexr¨   )r(   r)   s   "€r*   r+   Ú!NeuCodecEncoderBlock.__annotate__  s"   ø€ ÷ 	
ñ 	
™~ð 	
±sð 	
Écñ 	
r-   c           
     óÂ  <€ \         SV `  4        VP                  ^V,          ,          p\        V^,          ^R7      V n        \        V^,          ^R7      V n        \        V^,          ^	R7      V n        \        \        V^,          4      R7      V n	        \        P                  ! V^,          V^V,          V\        P                  ! V^,          4      R7      V n        R# )r   )rë  rê  ©r  r  rz  N)rI   rJ   Úencoder_hidden_sizerç  Ú	res_unit1Ú	res_unit2Ú	res_unit3rÔ  rô   rì  rM   rí  r  Úceilrî  )rT   rD   r  rú  rñ  rU   s   &&&& €r*   rJ   ÚNeuCodecEncoderBlock.__init__  s§   ø€ Ü‰ÑÔØ×.Ñ.°°LµÕ@ˆ	Ü-¨i¸1­nÀqÔIˆŒÜ-¨i¸1­nÀqÔIˆŒÜ-¨i¸1­nÀqÔIˆŒÜ5ÔARÐS\Ð`aÕSaÓAbÔcˆŒÜ—Y’YØ˜�N˜I°1°vµ:ÀfÔVZ×V_ÒV_Ð`fÐijÕ`jÓVkô
ˆŽ
r-   c                ó¬   € V P                  V4      pV P                  V4      pV P                  V P                  V4      4      pV P	                  V4      pV# r]   )rÿ  r   rì  r  rî  )rT   rô  s   &&r*   r_   ÚNeuCodecEncoderBlock.forward  sI   € Ø—~‘~ lÓ3ˆØ—~‘~ lÓ3ˆØ—{‘{ 4§>¡>°,Ó#?Ó@ˆØ—z‘z ,Ó/ˆàÐr-   )rî  rÿ  r   r  rì  )r%  r%  rÆ   rc   s   @@r*   rø  rø  ÿ  s   ù‡ € Ù1÷	
õ 	
÷ò r-   rø  c                   óH   a a€ ] tR tRt oRtV3R lV 3R lltR tRtVtV ;t	# )ÚNeuCodecEncoderi  zNEUCODEC Encoderc                ó    <€ V ^8„  d   QhRS[ /# rC   r   )r(   r)   s   "€r*   r+   ÚNeuCodecEncoder.__annotate__  s   ø€ ÷ Vñ V™~ñ Vr-   c           	     óD  <€ \         SV `  4        \        P                  ! ^VP                  ^^R7      V n        . V n        \        VP                  4       F3  w  r#V^,           pV ;P                  \        WVR7      .,          un        K5  	  \        P                  ! V P                  4      V n        VP                  ^\        VP                  4      ,          ,          p\        \        V4      R7      V n        \        P                  ! WAP                  ^^R7      V n        R# )r%  ©r  rz  )r  rú  rê  N)rI   rJ   rM   rí  rþ  rî  ÚblockÚ	enumerateÚdownsampling_ratiosrø  Ú
ModuleListÚlenrÔ  rô   rì  rO   rð  )rT   rD   rú  r  Úd_modelrU   s   &&   €r*   rJ   ÚNeuCodecEncoder.__init__  sÕ   ø€ Ü‰ÑÔô —Y’Y˜q &×"<Ñ"<È!ÐUVÔWˆŒ
àˆŒ
ä$-¨f×.HÑ.HÖ$IÑ ˆLØ'¨!Õ+ˆLØ�JŠJÔ/°ÐT`ÔaÐbÕb�Jñ %Jô —]’] 4§:¡:Ó.ˆŒ
Ø×,Ñ,¨q´C¸×8RÑ8RÓ4SÕ/SÕSˆÜ5ÔARÐSZÓA[Ô\ˆŒÜ—Y’Y˜w×(:Ñ(:ÈÐSTÔUˆŽ
r-   c                ó¢   € V P                  V4      pV P                   F  pV! V4      pK  	  V P                  V4      pV P                  V4      pV# r]   )rî  r  rì  rð  )rT   rô  r†   s   && r*   r_   ÚNeuCodecEncoder.forward*  sL   € Ø—z‘z ,Ó/ˆà—j”jˆFÙ! ,Ó/ŠLñ !ð —{‘{ <Ó0ˆØ—z‘z ,Ó/ˆàÐr-   )r  rî  rð  rì  rÆ   rc   s   @@r*   r  r    s   ù‡ € Ù÷Vó V÷"	ò 	r-   r  c                   óP   a a€ ] tR tRt oV3R lV 3R lltV3R lR ltRtVtV ;t# )ÚNeuCodecResNetBlocki6  c                ó    <€ V ^8„  d   QhRS[ /# rC   r   )r(   r)   s   "€r*   r+   Ú NeuCodecResNetBlock.__annotate__7  s   ø€ ÷ kñ k™~ñ kr-   c                ó"  <€ \         SV `  4        \        P                  ! ^ VP                  RRR7      V n        \        P                  ! 4       V n        \        P                  ! VP                  VP                  ^^^R7      V n	        \        P                  ! ^ VP                  RRR7      V n
        \        P                  ! 4       V n        VP                  V n        \        P                  ! VP                  VP                  ^^^R7      V n        R# )é    rÞ   T)Ú
num_groupsÚnum_channelsrË   Úaffinerý  N)rI   rJ   rM   Ú	GroupNormrO   Únorm1ÚSiLUÚactivation1rí  rî  Únorm2Úactivation2Úactivation_dropoutrð  rS   s   &&€r*   rJ   ÚNeuCodecResNetBlock.__init__7  sÂ   ø€ Ü‰ÑÔÜ—\’\¨R¸f×>PÑ>PÐVZÐcgÔhˆŒ
ÜŸ7š7›9ˆÔÜ—Y’Y˜v×1Ñ1°6×3EÑ3EÐSTÐ]^ÐhiÔjˆŒ
Ü—\’\¨R¸f×>PÑ>PÐVZÐcgÔhˆŒ
ÜŸ7š7›9ˆÔØ"(×";Ñ";ˆÔÜ—Y’Y˜v×1Ñ1°6×3EÑ3EÐSTÐ]^ÐhiÔjˆŽ
r-   c                óN   <€ V ^8„  d   QhRS[ P                  RS[ P                  /# rX   r[   )r(   r)   s   "€r*   r+   r  A  s#   ø€ ÷ 
:ñ 
:¡U§\¡\ð 
:±e·l±lñ 
:r-   c                ó�  € VP                  ^^4      pTpV P                  V4      pV P                  V4      pV P                  V4      pV P	                  V4      pV P                  V4      p\        P                  P                  WP                  V P                  R7      pV P                  V4      pW,           P                  ^^4      # )r%  r“   )r˜   r  r!  rî  r"  r#  rM   r™   rŒ   r$  r•   rð  ©rT   rY   rð   s   && r*   r_   ÚNeuCodecResNetBlock.forwardA  s­   € Ø%×/Ñ/°°1Ó5ˆØ ˆØŸ
™
 =Ó1ˆØ×(Ñ(¨Ó7ˆØŸ
™
 =Ó1ˆØŸ
™
 =Ó1ˆØ×(Ñ(¨Ó7ˆÜŸ™×-Ñ-¨m×?VÑ?VÐae×anÑanÐ-ÓoˆØŸ
™
 =Ó1ˆØÕ(×3Ñ3°A°qÓ9Ð9r-   )r!  r#  r$  rî  rð  r  r"  ra   rc   s   @@r*   r  r  6  s    ù‡ € ÷kó k÷
:÷ 
:ð 
:r-   r  c                   ób   a a€ ] tR tRt oV3R lV 3R lltV3R lR ltV3R lR ltRtVtV ;t	# )	ÚNeuCodecQuantizeriN  c                ó    <€ V ^8„  d   QhRS[ /# rC   r   )r(   r)   s   "€r*   r+   ÚNeuCodecQuantizer.__annotate__O  s   ø€ ÷ _ñ _™~ñ _r-   c                ó(  <€ \         SV `  4        \        V4      V n        \        P
                  ! VP                  \        VP                  4      4      V n	        \        P
                  ! \        VP                  4      VP                  4      V n
        R # r]   )rI   rJ   r:  Ú	quantizerrM   rN   Úquantization_dimr  r?  Ú
project_inÚproject_outrS   s   &&€r*   rJ   ÚNeuCodecQuantizer.__init__O  sa   ø€ Ü‰ÑÔÜ9¸&ÓAˆŒÜŸ)š) F×$;Ñ$;¼SÀ×A[ÑA[Ó=\Ó]ˆŒÜŸ9š9¤S¨×)CÑ)CÓ%DÀf×F]ÑF]Ó^ˆÖr-   c                óN   <€ V ^8„  d   QhRS[ P                  RS[ P                  /# rR  r[   )r(   r)   s   "€r*   r+   r-  U  s#   ø€ ÷ 'ñ '¡%§,¡,ð '±5·<±<ñ 'r-   c                ó€   € VP                  R4      pV P                  P                  V,          pV P                  V4      # ©r%  rg   )r�  r/  rC  r2  )rT   rN  rT  s   && r*   Ú
from_codesÚNeuCodecQuantizer.from_codesU  s5   € Ø—/‘/ "Ó%ˆØ—‘×'Ñ'¨Õ0ˆØ×Ñ Ó&Ð&r-   c                óx   <€ V ^8„  d   QhRS[ P                  RS[S[ P                  S[ P                  3,          /# rX   rb  )r(   r)   s   "€r*   r+   r-  Z  s1   ø€ ÷ &ñ &¡U§\¡\ð &±e¹E¿L¹LÉ%Ï,É,Ð<VÕ6Wñ &r-   c                ó   € V P                  V4      pVP                  pV P                  P                  V4      pV P                  V4      w  r4V P	                  VP                  V4      4      pVP                  R4      pW43# r6  )r1  r’   r/  r_  r2  rœ   rp   )rT   rY   rn  Úquantized_outrN  s   &&   r*   r_   ÚNeuCodecQuantizer.forwardZ  st   € ØŸ™¨Ó6ˆØ&×,Ñ,ˆØŸ™×,Ñ,¨]Ó;ˆØ!%§¡°Ó!>ÑˆØ×(Ñ(¨×)9Ñ)9¸.Ó)IÓJˆØ×#Ñ# BÓ'ˆØÐ%Ð%r-   )r1  r2  r/  )
r/   r0   r1   r2   rJ   r7  r_   r5   r6   rb   rc   s   @@r*   r+  r+  N  s*   ù‡ € ÷_ó _÷'ð '÷
&÷ &ð &r-   r+  c                   óT   a a€ ] tR tRt oRtV3R lV 3R lltV3R lR ltRtVtV ;t	# )ÚNeuCodecDecoderid  zVVocos-based decoder with ResNet, Transformer, and ISTFT head for audio reconstruction.c                ó    <€ V ^8„  d   QhRS[ /# rC   r   )r(   r)   s   "€r*   r+   ÚNeuCodecDecoder.__annotate__g  s   ø€ ÷ .ñ .™~ñ .r-   c           	     ó&  <€ \         SV `  4        \        P                  ! VP                  VP
                  P                  ,           VP                  4      V n        \        P                  ! VP                  VP                  ^^R7      V n        \        P                  ! \        V4      \        V4      .4      V n        VP                  V n        \        VR7      V n        \        P                  ! \        VP                   4       Uu. uF  p\#        W4      NK  	  up4      V n        \        P                  ! \        V4      \        V4      .4      V n        \        P(                  ! VP                  RR7      V n        \-        V4      V n        R# u upi )ré  r  )rD   rÞ   rä   N)rI   rJ   rM   rN   rO   Úsemantic_model_configÚfcrí  Úembedr  r  Ú	prior_netr¬   r³  Ú
rotary_embÚrangeÚnum_hidden_layersrà   ÚlayersÚpost_netÚ	LayerNormr‚  rs  Úheadr´   s   && €r*   rJ   ÚNeuCodecDecoder.__init__g  s!  ø€ Ü‰ÑÔÜ—)’)˜F×.Ñ.°×1MÑ1M×1YÑ1YÕYÐ[a×[mÑ[mÓnˆŒÜ—Y’Y˜v×1Ñ1°6×3EÑ3EÐSTÐ^_Ô`ˆŒ
ÜŸšÔ(;¸FÓ(CÔEXÐY_ÓE`Ð'aÓbˆŒØ#)×#=Ñ#=ˆÔ Ü1¸Ô@ˆŒÜ—m’mÜFKÈF×LdÑLdÔFeÓfÑFe¸Ô! &Ö4ÑFeÑfó
ˆŒô ŸšÔ':¸6Ó'BÔDWÐX^ÓD_Ð&`ÓaˆŒÜ—L’L ×!3Ñ!3¸Ô>ˆŒ	Ü% fÓ-ˆŽ	ùò	 gs   ÄFc                óN   <€ V ^8„  d   QhRS[ P                  RS[ P                  /# rX   r[   )r(   r)   s   "€r*   r+   r@  u  s#   ø€ ÷ 3ñ 3¡U§\¡\ð 3ÁÇÁñ 3r-   c                ó  € V P                  V4      pVP                  ^^4      pV P                  V4      pVP                  ^^4      pV P                   F  pV! V4      pK  	  \        P
                  ! V P                  VP                  R7      P                  ^ 4      pV P                  W4      pV P                   F  pV! V3RV/VB pK  	  V P                   F  pV! V4      pK  	  V P                  V P                  V4      4      # )r%  rH  r·   )rC  r˜   rD  rE  r$   r  r¬   rG  rp   rF  rI  rJ  rL  r‚  )rT   rY   r�   Úlayerrì   r·   s   &&,   r*   r_   ÚNeuCodecDecoder.forwardu  sí   € ØŸ™ Ó.ˆØ%×/Ñ/°°1Ó5ˆØŸ
™
 =Ó1ˆØ%×/Ñ/°°1Ó5ˆð —^”^ˆEÙ! -Ó0ŠMñ $ô —|’| D×$<Ñ$<À]×EYÑEYÔZ×dÑdÐefÓgˆØ"Ÿo™o¨mÓJÐØ—[”[ˆEÙ! -ÑcÐEXÐcÐ\bÑcŠMñ !ð —]”]ˆEÙ! -Ó0ŠMñ #ð �y‰y˜Ÿ™ =Ó1Ó2Ð2r-   )	rD  rC  rL  rI  r‚  r¬   rJ  rE  rF  rÆ   rc   s   @@r*   r>  r>  d  s!   ù‡ € Ù`÷.ó .÷3÷ 3ð 3r-   r>  c                   óP   a a€ ] tR tRt oV3R lV 3R lltV3R lR ltRtVtV ;t# )ÚNeuCodecSemanticAdapteri�  c                ó    <€ V ^8„  d   QhRS[ /# rC   r   )r(   r)   s   "€r*   r+   Ú$NeuCodecSemanticAdapter.__annotate__‘  s   ø€ ÷ 
ñ 
™~ñ 
r-   c                óÌ  <€ \         SV `  4        \        P                  ! VP                  P
                  VP                  P
                  ^^RR7      V n        \        P                  ! 4       V n        \        P                  ! VP                  P
                  VP                  P
                  ^^RR7      V n	        \        P                  ! 4       V n
        \        P                  ! VP                  P
                  VP                  P
                  ^^RR7      V n        \        P                  ! VP                  P
                  VP                  P
                  ^^RR7      V n        R# )é   F)Úin_channelsÚout_channelsr  rz  rH   T)r  rz  rH   N)rI   rJ   rM   rí  rB  rO   rî  ÚReLUÚact1rð  Úact2Úconv3Úconv4rS   s   &&€r*   rJ   Ú NeuCodecSemanticAdapter.__init__‘  s
  ø€ Ü‰ÑÔÜ—Y’YØ×4Ñ4×@Ñ@Ø×5Ñ5×AÑAØØØô
ˆŒ
ô —G’G“IˆŒ	Ü—Y’YØ×(Ñ(×4Ñ4Ø×(Ñ(×4Ñ4ØØØô
ˆŒ
ô —G’G“IˆŒ	Ü—Y’YØ×(Ñ(×4Ñ4Ø×(Ñ(×4Ñ4ØØØô
ˆŒ
ô —Y’YØ×4Ñ4×@Ñ@Ø×5Ñ5×AÑAØØØô
ˆŽ
r-   c                óN   <€ V ^8„  d   QhRS[ P                  RS[ P                  /# rX   r[   )r(   r)   s   "€r*   r+   rU  ²  s#   ø€ ÷ 	ñ 	¡U§\¡\ð 	±e·l±lñ 	r-   c                óæ   € V P                  V4      pV P                  V4      pTpV P                  V4      pV P                  V4      pV P	                  V4      pW,           pV P                  V4      pV# r]   )rî  r[  rð  r\  r]  r^  r(  s   && r*   r_   ÚNeuCodecSemanticAdapter.forward²  si   € ØŸ
™
 =Ó1ˆØŸ	™	 -Ó0ˆØ ˆØŸ
™
 =Ó1ˆØŸ	™	 -Ó0ˆØŸ
™
 =Ó1ˆØ%Õ0ˆØŸ
™
 =Ó1ˆØÐr-   )r[  r\  rî  rð  r]  r^  ra   rc   s   @@r*   rS  rS  �  s   ù‡ € ÷
ó 
÷B	÷ 	ð 	r-   rS  z"NeuCodec neural audio codec model.)Úcustom_introc                   óÀ   a a€ ] tR tRt o]tV3R lV 3R llt]]RV3R lR ll4       4       t	]]RV3R lR ll4       4       t
]]RV3R lR	 ll4       4       tR
tVtV ;t# )ÚNeuCodecModeli¾  c                ó    <€ V ^8„  d   QhRS[ /# rC   r   )r(   r)   s   "€r*   r+   ÚNeuCodecModel.__annotate__Â  s   ø€ ÷ ñ ™~ñ r-   c                óB  <€ \         SV `  V4       VP                  V n        \        P
                  ! VP                  4      V n        \        V4      V n	        \        V4      V n        \        P                  ! VP                  VP                  P                  ,           VP                  VP                  P                  ,           4      V n        \!        V4      V n        \%        V4      V n        VP(                  VP*                  ,          V n        V P/                  4        R # r]   )rI   rJ   Úencoder_hop_lengthry  r   Úfrom_configrB  Úsemantic_encoderrS  Úsemantic_adapterr  Úacoustic_encoderrM   rN   rO   Ú
fc_encoderr+  r/  r>  Úacoustic_decoderÚoutput_sampling_rateÚinput_sampling_rateÚsample_rate_conversion_factorÚ	post_initrS   s   &&€r*   rJ   ÚNeuCodecModel.__init__Â  sÔ   ø€ Ü‰Ñ˜Ô ð !×3Ñ3ˆŒÜ )× 5Ò 5°f×6RÑ6RÓ SˆÔÜ 7¸Ó ?ˆÔÜ /°Ó 7ˆÔÜŸ)š)Ø×Ñ ×!=Ñ!=×!IÑ!IÕIØ×Ñ ×!=Ñ!=×!IÑ!IÕIó
ˆŒô +¨6Ó2ˆŒÜ /°Ó 7ˆÔØ-3×-HÑ-HÈ6×KeÑKeÕ-eˆÔ*à�‰Ör-   c                óÐ   <€ V ^8„  d   QhRS[ P                  RS[ P                  RS[ P                  R,          RS[ P                  R,          RS[RS[S[,          RS[S[,          /# ©	r   rš  Úinput_featuresÚpadding_maskNÚinput_features_maskÚoutput_latentsr�   rZ   )r$   r'   rî   r   r   r¹   r9   )r(   r)   s   "€r*   r+   rg  ×  sw   ø€ ÷ :
ñ :
á—l‘lð:
ñ Ÿ™ð:
ñ —l‘l TÕ)ð	:
ñ
 #Ÿ\™\¨DÕ0ð:
ñ ð:
ñ Ñ+Õ,ð:
ñ 
Ñ&Õ	&ñ:
r-   c                ó   € \         P                  ! 4       ;_uu_ 4        V P                  W$R7      pRRR4       XP                  P	                  ^^4      pV P                  V4      pV P                  V4      p	\        V	P                  R	,          VP                  R	,          4      p
V	RRV
13,          p	VRRV
13,          p\         P                  ! W‰.^R7      pV P                  VP	                  ^^4      4      pV P                  V4      w  rÍVP	                  ^^4      pVP	                  ^^4      pRpVe™   VP                  R	RR7      pWðP                  ,          pWðP                  ,          p\         P                  ! VP                  R	,          VP                   R7      P#                  ^R	4      pVV8  P%                  VP&                  4      p\)        TV'       d	   VVR7      # RVR7      #   + '       g   i     ELÄ; i)
a°  
input_values (`torch.Tensor` of shape `(batch_size, 1, sequence_length)`):
    Input audio waveform.
input_features (`torch.Tensor` of shape `(batch_size, mel_bins, time_steps)`):
    Input audio mel spectrogram for semantic encoding.
padding_mask (`torch.Tensor` of shape `(batch_size, 1, sequence_length)`):
    Padding mask used to pad `input_values`.
input_features_mask (`torch.Tensor` of shape `(batch_size, time_steps)`, *optional*):
    Attention mask for the spectrogram input to the semantic encoder. `1` for valid frames, `0` for padding.
output_latents (`bool`, *optional*, defaults to `False`):
    Whether to return the continuous latent representation from the quantizer.
)rŠ   N.re   T)rf   rÔ   rH  )r!   r"   r#   rg   )r$   rÒ  rk  Úlast_hidden_stater˜   rl  rm  r„  rh   ri   rn  r/  r	  rr  ry  r  rG  r¼   rœ   r’   r9   )rT   rš  rw  rx  ry  rz  r�   Úsemantic_outputÚsemantic_hidden_statesÚacoustic_hidden_statesÚ
min_lengthrY   r"   r!   r#   Úaudio_lengthÚtoken_lengthÚidxs   &&&&&&,           r*   ÚencodeÚNeuCodecModel.encodeÕ  s×  € ô2 �]Š]�_�_Ø"×3Ñ3°NÐ3ÓgˆO÷ à!0×!BÑ!B×!LÑ!LÈQÐPQÓ!RÐØ!%×!6Ñ!6Ð7MÓ!NÐð "&×!6Ñ!6°|Ó!DÐô Ð/×5Ñ5°bÕ9Ð;Q×;WÑ;WÐXZÕ;[Ó\ˆ
Ø!7¸¸[¸j¸[Ð8HÕ!IÐØ!7¸¸[¸j¸[Ð8HÕ!IÐäŸ	š	Ð#9Ð"RÐXYÔZˆØŸ™¨×(?Ñ(?ÀÀ1Ó(EÓFˆð  $Ÿ~™~¨mÓ<ÑˆØ×#Ñ# A qÓ)ˆØ!×+Ñ+¨A¨qÓ1ˆð  ÐØÒ#Ø'×+Ñ+°¸DÐ+ÓAˆLØ'×*LÑ*LÕLˆLØ'¯?©?Õ:ˆLÜ—,’,˜{×0Ñ0°Õ4¸\×=PÑ=PÔQ×VÑVÐWXÐZ\Ó]ˆCØ # lÑ 2×6Ñ6°|×7IÑ7IÓJÐä$Ø#ß-�GØ-ô
ð 	
à37Ø-ô
ð 	
÷? �_ˆ_ús   žG,Ç,G=	c                ó¾   <€ V ^8„  d   QhRS[ P                  R,          RS[ P                  R,          RS[ P                  R,          RS[S[,          RS[S[,          /# )r   r!   Nr"   r#   r�   rZ   )r$   r'   r   r   r¹   r=   )r(   r)   s   "€r*   r+   rg    sd   ø€ ÷  ?ñ  ?á—\‘\ DÕ(ð ?ñ —‘ Õ$ð ?ñ  Ÿ,™,¨Õ-ð	 ?ñ
 Ñ+Õ,ð ?ñ 
Ñ&Õ	&ñ ?r-   c                ó  € Vf   Vf   \        R4      hVe-   V P                  P                  VP                  ^^4      4      pMVP                  ^^4      p\	        V P
                  VVR7      pV P                  ! V3RV/VB p\        VR7      # )añ  
audio_codes (`torch.LongTensor`  of shape `(batch_size, 1, codes_length)`):
    Discrete code indices computed using `model.encode`.
latents (torch.Tensor of shape `(batch_size, dimension, time_steps)`, *optional*):
    Quantized continuous representation of input.
audio_codes_mask (`torch.Tensor` of shape `(batch_size, codes_length)`, *optional*):
    Mask marking valid (non-padding) positions, as returned by `model.encode`. Needed for correct
    batched decoding of variable-length audio.
z3Either `latents` or `audio_codes` must be provided.)rD   Úinputs_embedsrŠ   rŠ   )r    )r  r/  r7  r˜   r   rD   ro  r=   )rT   r!   r"   r#   r�   rŠ   Úrecon_audios   &&&&,  r*   ÚdecodeÚNeuCodecModel.decode  s”   € ð$ Š?˜{Ò2ÜÐRÓSÐSàÒ"Ø—n‘n×/Ñ/°×0EÑ0EÀaÈÓ0KÓL‰Gà×'Ñ'¨¨1Ó-ˆGô 3Ø—;‘;Ø!Ø+ô
ˆð ×+Ò+¨GÑ]ÀNÐ]ÐV\Ñ]ˆÜ$°+Ô>Ð>r-   c                óÐ   <€ V ^8„  d   QhRS[ P                  RS[ P                  RS[ P                  R,          RS[ P                  R,          RS[RS[S[,          RS[S[,          /# rv  )r$   r'   rî   r   r   r¹   r   )r(   r)   s   "€r*   r+   rg  9  s   ø€ ÷ @
ñ @
á—l‘lð@
ñ Ÿ™ð@
ñ —l‘l TÕ)ð	@
ñ
 #Ÿ\™\¨DÕ0ð@
ñ ð@
ñ Ñ+Õ,ð@
ñ 
‘Õ	ñ@
r-   c           	     óv  € VP                   R	,          p\        WpP                  ,          4      pV P                  VVVVRRR7      p	V P                  ! R
RV	P
                  RV	P                  RR/VB ^ ,          RRV13,          p
\        T
V	P                  V'       d   V	P
                  MRV	P                  R7      # )aƒ  
input_values (`torch.Tensor` of shape `(batch_size, 1, sequence_length)`):
    Input audio waveform, sampled at `config.input_sampling_rate`.
input_features (`torch.Tensor` of shape `(batch_size, mel_bins, time_steps)`):
    Input audio mel spectrogram for semantic encoding.
padding_mask (`torch.Tensor` of shape `(batch_size, 1, sequence_length)`):
    Padding mask used to pad `input_values`.
input_features_mask (`torch.Tensor` of shape `(batch_size, time_steps)`, *optional*):
    Attention mask for the spectrogram input to the semantic encoder. `1` for valid frames, `0` for padding.
output_latents (`bool`, *optional*, defaults to `False`):
    Whether to return the continuous latent representation from the quantizer.

Examples:

```python
>>> from datasets import load_dataset
>>> from transformers import AutoFeatureExtractor, NeuCodecModel

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> audio = dataset["train"]["audio"][0]["array"]

>>> model_id = "neuphonic/neucodec"
>>> model = NeuCodecModel.from_pretrained(model_id)
>>> feature_extractor = AutoFeatureExtractor.from_pretrained(model_id)

>>> inputs = feature_extractor(audio=audio, sampling_rate=feature_extractor.sampling_rate, return_tensors="pt")

>>> outputs = model(**inputs)
>>> audio_codes = outputs.audio_codes
>>> audio_values = outputs.audio_values  # sampled at 24kHz
```T)rw  rx  ry  rz  Úreturn_dictr"   r#   rŽ  .N)r    r!   r"   r#   rg   r.   )	rh   r{   rr  r„  rŠ  r"   r#   r   r!   )rT   rš  rw  rx  ry  rz  r�   Úinput_lengthÚoutput_lengthÚencoder_outputsr    s   &&&&&&,    r*   r_   ÚNeuCodecModel.forward7  sÛ   € ðV $×)Ñ)¨"Õ-ˆÜ˜L×+MÑ+MÕMÓNˆàŸ+™+ØØ)Ø%Ø 3ØØð &ó 
ˆð —{’{ñ 
Ø#×+Ñ+ð
à,×=Ñ=ð
ð ð
ð ñ	
ð
 õð
 �.�=�.Ð õ"ˆô Ø%Ø'×3Ñ3ß/=�O×+Ò+À4Ø,×=Ñ=ô	
ð 	
r-   )ro  rm  rn  ry  r/  rr  rl  rk  )NNFrÅ   )r/   r0   r1   r2   r   Úconfig_classrJ   r   r   r„  rŠ  r_   r5   r6   rb   rc   s   @@r*   re  re  ¾  s‚   ù‡ € à!€L÷ó ð& Ø÷:
ñ :
ó ó ð:
ðx Ø÷ ?ñ  ?ó ó ð ?ðD Ø÷@
ñ @
ó ó ÷@
ð @
r-   re  )r%  )r»   )Pr  Úcollections.abcr   Údataclassesr   ÚnumpyrL  Útorch.nnrM   r   Ú r   rž  Úactivationsr   Úcache_utilsr   Úintegrationsr	   r
   Úmasking_utilsr   Úmodeling_layersr   Úmodeling_rope_utilsr   r   Úmodeling_utilsr   r   Úprocessing_utilsr   Úutilsr   r   r   r   r   Úutils.deprecationr   Úutils.genericr   Úautor   Úconfiguration_neucodecr   r$   Útorch.nn.functionalr™   r+  r   r9   r=   rŽ   rA   rm   rx   r„   r¢   r¤   rÉ   rà   rô   r  r  r3  r:  rs  r˜  r³  rÔ  rç  rø  r  r  r+  r>  rS  re  Ú__all__r.   r-   r*   Ú<module>r¨     sœ  ðó* Ý $Ý !ã Ý Ý å &Ý !Ý  ß LÝ 6Ý 9ß Kß FÝ &ß jÕ jÝ 0Ý +Ý Ý 2ñ ×ÒÛß#Ð#ð Ø
ô1�[ó 1ó ó ð1ð( Ø
ô1˜Kó 1ó ó ð1ð" Ø
ô2˜Kó 2ó ó ð2ô�"—)‘)ô ò(ñ Ð-Ó.óó /ðõ2	U÷%ñ2 Ð)Ó*ôC)˜Ÿ	™	ó C)ó +ðC)ñL ˜YÓ'ôJ�b—i‘ió Jó (ðJô((Ð5ô (ôV&˜Ÿ	™	ô &òR+5ô\˜2Ÿ9™9ô ôD˜Ÿ™ô ô6P1 r§y¡yô P1ôf3"˜Ÿ	™	ô 3"ðl ô%5˜oó %5ó ð%5ôP6<˜bŸi™iô 6<ôr b§i¡iô ô0!˜2Ÿ9™9ô !ôH˜2Ÿ9™9ô ô.�b—i‘iô ô@:˜"Ÿ)™)ô :ô0&˜Ÿ	™	ô &ô,)3�b—i‘iô )3ôX+˜bŸi™iô +ñ\ ÐAÔBôz
Ð+ó z
ó Cðz
ðz Ð5Ð
6‚r-   