Ë
    ÜÓ^jš¿  ã                   óø  — d dl Z d dlmZ d dlmZ d dlmZ d dlZd dl	Z	d dl
mZ d dlmc mZ d dl
mZ ddlmZ ddlmZ dd	lmZ dd
lmZmZmZ ddlmZ ddlmZmZ ddl m!Z!m"Z" ddl#m$Z$ ddl%m&Z&m'Z'm(Z(m)Z) ddl*m+Z+ ddl,m-Z- ddl.m/Z/ e(e G d„ de&«      «       «       Z0e(e G d„ de&«      «       «       Z1e(e G d„ de&«      «       «       Z2 G d„ dejf                  «      Z4 G d„ dejf                  «      Z5d„ Z6 ed «      dWd!„«       Z7d"e	jp                  d#e9d$e	jp                  fd%„Z:	 dXd&ejf                  d'e	jp                  d(e	jp                  d)e	jp                  d*e	jp                  dz  d+e;d,e;d-e$e'   fd.„Z< ee7«       G d/„ d0ejf                  «      «       Z= ed1«       G d2„ d3ejf                  «      «       Z> G d4„ d5e«      Z? G d6„ d7ejf                  «      Z@d8„ ZA G d9„ d:ejf                  «      ZB G d;„ d<ejf                  «      ZC G d=„ d>ejf                  «      ZD G d?„ d@ejf                  «      ZE G dA„ dBejf                  «      ZF G dC„ dDejf                  «      ZG G dE„ dFejf                  «      ZH G dG„ dHejf                  «      ZI G dI„ dJejf                  «      ZJ G dK„ dLejf                  «      ZK G dM„ dNejf                  «      ZL G dO„ dPejf                  «      ZMe( G dQ„ dRe"«      «       ZN e(dS¬T«       G dU„ dVeN«      «       ZOdVdRgZPy)Yé    N)ÚCallable)Ú	dataclass)ÚOptional)Ú	Parameteré   )Úinitialization)ÚACT2FN)ÚCache)Úuse_kernel_forward_from_hubÚuse_kernel_func_from_hubÚuse_kernelized_func)ÚGradientCheckpointingLayer)ÚROPE_INIT_FUNCTIONSÚdynamic_rope_update)ÚALL_ATTENTION_FUNCTIONSÚPreTrainedModel)ÚUnpack)ÚModelOutputÚTransformersKwargsÚauto_docstringÚcan_return_tuple)Úmaybe_autocasté   )Ú	AutoModelé   )ÚXcodec2Configc                   ó²   — e Zd ZU dZdZej                  dz  ed<   dZej                  dz  ed<   dZ
ej                  dz  ed<   dZej                  dz  ed<   y)ÚXcodec2OutputaL  
    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 Xcodec2. 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`.
    NÚaudio_valuesÚaudio_codesÚlatentsÚaudio_codes_mask)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r   ÚtorchÚFloatTensorÚ__annotations__r    Ú
LongTensorr!   ÚTensorr"   © ó    úw/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/transformers/models/xcodec2/modeling_xcodec2.pyr   r   -   sZ   … ñð .2€L�%×#Ñ# dÑ*Ó1Ø+/€K�×!Ñ! DÑ(Ó/Ø#'€GˆU�\‰\˜DÑ Ó'Ø,0Ð�e—l‘l TÑ)Ô0r-   r   c                   óŠ   — e Zd ZU dZdZej                  dz  ed<   dZej                  dz  ed<   dZ
ej                  dz  ed<   y)ÚXcodec2EncoderOutputat  
    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`.
    Nr    r!   r"   )r#   r$   r%   r&   r    r'   r*   r)   r!   r+   r"   r,   r-   r.   r0   r0   C   sE   … ñ	ð ,0€K�×!Ñ! DÑ(Ó/Ø#'€GˆU�\‰\˜DÑ Ó'Ø,0Ð�e—l‘l TÑ)Ô0r-   r0   c                   ó:   — e Zd ZU dZdZej                  dz  ed<   y)ÚXcodec2DecoderOutputa=  
    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.
    Nr   )r#   r$   r%   r&   r   r'   r(   r)   r,   r-   r.   r2   r2   V   s   … ñð .2€L�%×#Ñ# dÑ*Ô1r-   r2   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 )ÚXcodec2RotaryEmbeddingÚinv_freqNÚconfigc                 ó®  •— 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Údefaultr5   F©Ú
persistentÚoriginal_inv_freq)ÚsuperÚ__init__Úmax_position_embeddingsÚmax_seq_len_cachedÚoriginal_max_seq_lenr6   Úrope_parametersr8   Úcompute_default_rope_parametersr   Úattention_scalingÚregister_bufferÚclone)Úselfr6   ÚdeviceÚrope_init_fnr5   Ú	__class__s        €r.   r>   zXcodec2RotaryEmbedding.__init__f   s¶   ø€ Ü‰ÑÔØ"(×"@Ñ"@ˆÔØ$*×$BÑ$BˆÔ!àˆŒàŸ™×4Ñ4°[ÑAˆŒØ!%×!EÑ!EˆØ�>‰>˜YÒ&Ü.¨t¯~©~Ñ>ˆLÙ+7¸¿¹ÀVÓ+LÑ(ˆ�$Ô(à×Ñ˜Z¨¸eÐÔDØ×ÑÐ0°(·.±.Ó2BÈuÐÕUr-   rH   ztorch.deviceÚseq_lenÚreturnz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_dimNç      ð?r   r   ©Údtype)rH   rR   )	rB   ÚgetattrÚhidden_sizeÚnum_attention_headsr'   ÚarangeÚint64ÚtoÚfloat)r6   rH   rK   ÚbaseÚdimÚattention_factorr5   s          r.   rC   z6Xcodec2RotaryEmbedding.compute_default_rope_parametersv   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   ©r[   rQ   )r5   rY   ÚexpandÚshaperX   rH   Ú
isinstanceÚtypeÚstrr   Ú	transposer'   ÚcatÚcosrD   ÚsinrR   )
rG   ÚxÚposition_idsÚinv_freq_expandedÚposition_ids_expandedrb   ÚfreqsÚembrl   rm   s
             r.   ÚforwardzXcodec2RotaryEmbedding.forward”   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)r#   r$   r%   r'   r+   r)   r   r>   Ústaticmethodr   ÚintÚtuplerY   rC   Úno_gradr   rt   Ú__classcell__©rJ   s   @r.   r4   r4   c   s˜   ø… Ø�l‰lÓñV˜}õ Vð  à'+Ø+/Ø"ñ*Ø Ñ$ð*à˜Ñ(ð*ð �t‘ð*ð 
ˆ~˜uÐ$Ñ	%ò	*ó ð*ð: €U‡]�]ƒ_Øñ<ó ó ô<r-   r4   c                   ó\   ‡ — e Zd Zdefˆ fd„Zdej                  dej                  fd„Zˆ xZS )Ú
Xcodec2MLPr6   c                 ó$  •— t         ‰| �  «        || _        t        |j                     | _        t        j                  |j                  |j                  d¬«      | _
        t        j                  |j                  |j                  d¬«      | _        y )NF©Úbias)r=   r>   r6   r	   Ú
hidden_actÚactivation_fnÚnnÚLinearrT   Úintermediate_sizeÚfc1Úfc2©rG   r6   rJ   s     €r.   r>   zXcodec2MLP.__init__¥   sj   ø€ Ü‰ÑÔØˆŒÜ# F×$5Ñ$5Ñ6ˆÔÜ—9‘9˜V×/Ñ/°×1IÑ1IÐPUÔVˆŒÜ—9‘9˜V×5Ñ5°v×7IÑ7IÐPUÔVˆ�r-   Úhidden_statesrL   c                 ól   — | j                  |«      }| j                  |«      }| j                  |«      }|S ru   )r‡   rƒ   rˆ   ©rG   rŠ   s     r.   rt   zXcodec2MLP.forward¬   s4   € ØŸ™ Ó/ˆØ×*Ñ*¨=Ó9ˆØŸ™ Ó/ˆØÐr-   ©	r#   r$   r%   r   r>   r'   r+   rt   r{   r|   s   @r.   r~   r~   ¤   s,   ø„ ðW˜}õ Wð U§\¡\ð °e·l±l÷ r-   r~   c                 óš   — | dd| j                   d   dz  …f   }| d| j                   d   dz  d…f   }t        j                  | |fd¬«      S )z*Rotates half the hidden dims of the input..Nr^   r   rd   )rf   r'   rk   )rn   Ú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Úkrl   rm   Ú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_reprL   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)rf   re   Úreshape)rŠ   r›   ÚbatchÚnum_key_value_headsÚslenrO   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   r^   ©r[   rR   ©ÚpÚtrainingr   )r¡   Únum_key_value_groupsr'   Úmatmulrj   r„   Ú
functionalÚsoftmaxÚfloat32rX   rR   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
dz  d
ee   de	ej                  ej                  f   fd„Zˆ xZS )ÚXcodec2Attentionz=Multi-headed attention from 'Attention Is All You Need' paperr6   Ú	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 )NrO   g      à¿Fr€   )r=   r>   r6   r¼   rS   rT   rU   rO   rŸ   r¯   r§   Úattention_dropoutÚ	is_causalr„   r…   Úattention_biasÚq_projÚk_projÚv_projÚo_proj©rG   r6   r¼   rJ   s      €r.   r>   zXcodec2Attention.__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¦   Úpast_key_valuesr©   rL   c                 ó  — |j                   d d }g |¢d‘| j                  ‘­}| j                  |«      j                  |«      j	                  dd«      }| j                  |«      j                  |«      j	                  dd«      }	| j                  |«      j                  |«      j	                  dd«      }
|\  }}t        ||	||d¬«      \  }}	|� |j                  |	|
| j                  «      \  }	}
t        j                  | j                  j                  t        «      } || ||	|
|f| j                  sdn| j                   | j"                  dœ|¤Ž\  }} |j$                  g |¢d‘­Ž j'                  «       }| j)                  |«      }||fS )Nr^   r   r   )r—   ç        )r¨   r§   )rf   rO   rÁ   Úviewrj   rÂ   rÃ   rš   Úupdater¼   r   Úget_interfacer6   Ú_attn_implementationr¹   r®   r¾   r§   r�   r´   rÄ   )rG   rŠ   rÆ   r¦   rÇ   r©   Úinput_shapeÚhidden_shapeÚquery_statesrµ   r¶   rl   rm   Úattention_interfacer¸   r·   s                   r.   rt   zXcodec2Attention.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ˆà&‰ˆˆSô $8¸ÀjÐRUÐWZÐjkÔ#lÑ ˆ�jàÐ&Ø'6×'=Ñ'=¸jÈ,ÐX\×XfÑXfÓ'gÑ$ˆJ˜ä(?×(MÑ(MØ�K‰K×,Ñ,Ô.Eó)
Ðñ %8ØØØØØð	%
ð  $Ÿ}š}‘C°$×2HÑ2HØ—L‘Lñ	%
ð ñ	%
Ñ!ˆ�\ð *�k×)Ñ)Ð;¨;Ð;¸Ò;×FÑFÓHˆØ—k‘k +Ó.ˆØ˜LÐ(Ð(r-   rv   )r#   r$   r%   r&   r   rx   r>   r'   r+   ry   r
   r   r   rt   r{   r|   s   @r.   r»   r»   ù   s¥   ø„ áGð
˜}ð 
¸õ 
ð4 IMØ.2Ø(,ñ))à—|‘|ð))ð # 5§<¡<°·±Ð#=Ñ>ÀÑEð))ð Ÿ™ tÑ+ð	))ð
  ™ð))ð Ð+Ñ,ð))ð 
ˆu�|‰|˜UŸ\™\Ð)Ñ	*÷))r-   r»   ÚRMSNormc                   óh   ‡ — e Zd Zddeddfˆ fd„Zdej                  dej                  fd„Zd„ Zˆ xZ	S )	ÚXcodec2RMSNormÚepsrL   Nc                 óŠ   •— t         ‰| �  «        t        j                  t	        j
                  |«      «      | _        || _        y)z=
        Xcodec2RMSNorm is equivalent to T5LayerNorm
        N)r=   r>   r„   r   r'   ÚonesÚweightÚvariance_epsilon)rG   rT   rÕ   rJ   s      €r.   r>   zXcodec2RMSNorm.__init__B  s1   ø€ ô 	‰ÑÔÜ—l‘l¤5§:¡:¨kÓ#:Ó;ˆŒØ #ˆÕr-   rŠ   c                 ó"  — |j                   }|j                  t        j                  «      }|j	                  d«      j                  dd¬«      }|t        j                  || j                  z   «      z  }| j                  |j                  |«      z  S )Nr   r^   T)Úkeepdim)	rR   rX   r'   r³   ÚpowÚmeanÚrsqrtrÙ   rØ   )rG   rŠ   Úinput_dtypeÚvariances       r.   rt   zXcodec2RMSNorm.forwardJ  sy   € Ø#×)Ñ)ˆØ%×(Ñ(¬¯©Ó7ˆØ ×$Ñ$ QÓ'×,Ñ,¨R¸Ð,Ó>ˆØ%¬¯©°H¸t×?TÑ?TÑ4TÓ(UÑUˆØ�{‰{˜]×-Ñ-¨kÓ:Ñ:Ð:r-   c                 ó^   — t        | j                  j                  «      › d| j                  › �S )Nz, eps=)ry   rØ   rf   rÙ   )rG   s    r.   Ú
extra_reprzXcodec2RMSNorm.extra_reprQ  s*   € Ü˜Ÿ™×)Ñ)Ó*Ð+¨6°$×2GÑ2GÐ1HÐIÐIr-   )ç�íµ ÷Æ°>)
r#   r$   r%   rY   r>   r'   r+   rt   râ   r{   r|   s   @r.   rÔ   rÔ   @  s7   ø„ ñ$¨ð $¸$õ $ð; U§\¡\ð ;°e·l±ló ;öJ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	dz  d	e
dz  d
eej                  ej                  f   dz  dee   dej                  fd„Zˆ xZS )ÚXcodec2DecoderLayerr6   r¼   c                 ó   •— t         ‰| �  «        |j                  | _        t        ||¬«      | _        t        |«      | _        t        |j                  |j                  ¬«      | _	        t        |j                  |j                  ¬«      | _
        y )N)r6   r¼   ©rÕ   )r=   r>   rT   r»   Ú	self_attnr~   ÚmlprÔ   Úrms_norm_epsÚinput_layernormÚpost_attention_layernormrÅ   s      €r.   r>   zXcodec2DecoderLayer.__init__V  sl   ø€ Ü‰ÑÔØ!×-Ñ-ˆÔä)°À9ÔMˆŒä˜fÓ%ˆŒÜ-¨f×.@Ñ.@Àf×FYÑFYÔZˆÔÜ(6°v×7IÑ7IÈv×ObÑObÔ(cˆÕ%r-   NrŠ   r¦   ro   rÇ   Ú	use_cacherÆ   r©   rL   c           
      óÀ   — |}| j                  |«      } | j                  d||||||dœ|¤Ž\  }}	||z   }|}| j                  |«      }| j                  |«      }||z   }|S )N)rŠ   r¦   ro   rÇ   rí   rÆ   r,   )rë   rè   rì   ré   )
rG   rŠ   r¦   ro   rÇ   rí   rÆ   r©   ÚresidualÚ_s
             r.   rt   zXcodec2DecoderLayer.forward`  s�   € ð !ˆØ×,Ñ,¨]Ó;ˆà)˜4Ÿ>™>ð 
Ø'Ø)Ø%Ø+ØØ 3ñ
ð ñ
Ñˆ�qð ! =Ñ0ˆð !ˆØ×5Ñ5°mÓDˆØŸ™ Ó/ˆØ  =Ñ0ˆØÐr-   )NNNFN)r#   r$   r%   r   rx   r>   r'   r+   r*   r
   Úboolry   r   r   rt   r{   r|   s   @r.   rå   rå   U  s¾   ø„ ðd˜}ð d¸õ dð /3Ø04Ø(,Ø!&ØHLñà—|‘|ðð Ÿ™ tÑ+ðð ×&Ñ&¨Ñ-ð	ð
  ™ðð ˜$‘;ðð # 5§<¡<°·±Ð#=Ñ>ÀÑEðð Ð+Ñ,ðð 
�‰÷r-   rå   c                   ó*   ‡ — e Zd ZdZdˆ fd„	Zd„ Zˆ xZS )ÚXcodec2SnakeBetaa  
    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                 óÖ   •— t         ‰| �  «        || _        t        t	        j
                  |«      |z  «      | _        t        t	        j
                  |«      |z  «      | _        d| _        y )Ng•Ö&è.>)	r=   r>   Úin_featuresr   r'   ÚzerosÚalphaÚbetaÚno_div_by_zero)rG   rõ   r÷   rJ   s      €r.   r>   zXcodec2SnakeBeta.__init__Ž  sT   ø€ Ü‰ÑÔØ&ˆÔô œuŸ{™{¨;Ó7¸%Ñ?Ó@ˆŒ
ÜœeŸk™k¨+Ó6¸Ñ>Ó?ˆŒ	à)ˆÕr-   c                 ó†  — | j                   j                  d«      j                  d«      }| j                  j                  d«      j                  d«      }t        j                  |«      }t        j                  |«      }|d|| j
                  z   z  t        j                  t        j                  ||z  «      d«      z  z   }|S )u’   
        Forward pass of the function.
        Applies the function to the input elementwise.
        SnakeBeta âˆ¶= x + 1/b * sin^2 (xa)
        r   r^   rP   r   )r÷   r”   rø   r'   Úexprù   rÜ   rm   )rG   rŠ   r÷   rø   s       r.   rt   zXcodec2SnakeBeta.forward˜  s¥   € ð —
‘
×$Ñ$ QÓ'×1Ñ1°"Ó5ˆØ�y‰y×"Ñ" 1Ó%×/Ñ/°Ó3ˆÜ—	‘	˜%Ó ˆÜ�y‰y˜‹ˆØ%¨°°t×7JÑ7JÑ0JÑ)KÌuÏyÉyÜ�I‰I�m eÑ+Ó,¨aóP
ñ )
ñ 
ˆð Ðr-   )rP   ©r#   r$   r%   r&   r>   rt   r{   r|   s   @r.   ró   ró   €  s   ø„ ñõ*ör-   ró   c                 ób  — |dz  dk(  }|dz  }d|z  }d|dz
  z  t         j                  z  |z  dz   }|dkD  r	d|d	z
  z  }n|d
k\  rd|dz
  dz  z  d|d
z
  z  z   }nd}t        j                  ||dt        j                  ¬«      }|rt        j
                  | |«      dz   }	nt        j
                  |«      |z
  }	| dk(  r(t        j                  dd|ft        j                  ¬«      S t        j                  d| z  |	z  «      }
d| z  |z  |
z  }||j                  «       z  }|j                  dd|«      S )aB  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.
    r   r   é   gHáz®G@r   gÍÌÌÌÌÌ@g      I@gKê46¼?gffffff!@g      5@g¨WÊ2Ä±â?é   gš™™™™™Ù?gUjö@+0´?rÉ   F)rø   ÚperiodicrR   ç      à?rQ   )
ÚmathÚpir'   Úkaiser_windowr³   rV   rö   Ú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  ©  sW  € ð ˜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                   ó&   ‡ — e Zd Zdˆ fd„	Zd„ Zˆ xZS )ÚXcodec2DownSample1dc                 ó^  •— t         ‰| �  «        d|z  }d|z  }|| _        || _        || _        |dk  rt        d«      ‚|dkD  rt        d«      ‚|dz  dk(  | _        |dz  t        | j                  «      z
  | _        |dz  | _	        || _
        t        |||«      }| j                  d|d	¬
«       y )Nr  ç333333ã?rÉ   z(Minimum cutoff must be larger than zero.z'A cutoff above 0.5 does not make sense.r   r   ÚfilterFr:   )r=   r>   r  r  r	  Ú
ValueErrorÚevenrx   Úpad_leftÚ	pad_rightÚstrider  rE   )rG   Úratior	  r  r  r  rJ   s         €r.   r>   zXcodec2DownSample1d.__init__Ø  s»   ø€ Ü‰ÑÔØ�u‘ˆØ˜5‘[ˆ
ØˆŒØ$ˆŒØ&ˆÔà�CŠ<ÜÐGÓHÐHØ�CŠ<ÜÐFÓGÐGà !‘O qÑ(ˆŒ	Ø# qÑ(¬3¨t¯y©y«>Ñ9ˆŒØ$¨Ñ)ˆŒØˆŒÜ% f¨j¸+ÓFˆØ×Ñ˜X v¸%ÐÕ@r-   c                 ó.  — |j                   d   }t        j                  || j                  | j                  fd¬«      }t        j
                  || j                  j                  |j                  «      j                  |dd«      | j                  |¬«      }|S )Nr   Ú	replicate©Úmoder^   ©r  Úgroups)rf   ÚFÚpadr  r  Úconv1dr  rX   rR   re   r  )rG   rŠ   ÚchannelsÚouts       r.   rt   zXcodec2DownSample1d.forwardì  sy   € Ø ×&Ñ& qÑ)ˆÜŸ™˜m¨d¯m©m¸T¿^¹^Ð-LÐS^Ô_ˆÜ�h‰hØà�K‰K�N‰N˜=×.Ñ.Ó/×6Ñ6°xÀÀRÓHØ—;‘;Øô
ˆð ˆ
r-   ©r   N©r#   r$   r%   r>   rt   r{   r|   s   @r.   r  r  ×  s   ø„ õAö(
r-   r  c                   ó&   ‡ — e Zd Zdˆ fd„	Zd„ Zˆ xZS )ÚXcodec2UpSample1dc                 óü  •— t         ‰| �  «        || _        |€t        d|z  dz  «      dz  n|| _        || _        | j                  |z  dz
  | _        | j                  | j
                  z  | j                  | j
                  z
  dz  z   | _        | j                  | j
                  z  | j                  | j
                  z
  dz   dz  z   | _        t        d|z  d|z  | j                  ¬«      }| j                  d|d¬	«       y )
Né   r   r   r  r  )r  r  r	  r  Fr:   )r=   r>   r  rx   r	  r  r$  r  r  r  rE   )rG   r  r	  r  rJ   s       €r.   r>   zXcodec2UpSample1d.__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ˆØ×Ñ˜X v¸%ÐÕ@r-   c           	      ó„  — |j                   d   }t        j                  || j                  | j                  fd¬«      }| j                  t        j                  || j
                  j                  |j                  «      j                  |dd«      | j                  |¬«      z  }|d| j                  | j                   …f   }|S )Nr   r  r  r^   r!  .)rf   r#  r$  r  Úconv_transpose1dr  rX   rR   re   r  r  r  )rG   rŠ   r&  s      r.   rt   zXcodec2UpSample1d.forward  s¤   € Ø ×&Ñ& qÑ)ˆÜŸ™˜m¨d¯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|   s   @r.   r+  r+  ù  s   ø„ õ
Aör-   r+  c            	       ó@   ‡ — e Zd Z	 	 	 	 ddedededefˆ fd„Zd„ Zˆ xZS )ÚXcodec2AntiAliasedActivation1dÚup_ratioÚ
down_ratioÚup_kernel_sizeÚdown_kernel_sizec                 ó    •— t         ‰| �  «        t        |«      st        d«      ‚|| _        t        ||«      | _        t        ||«      | _        y )Nz$Activation function must be callable)	r=   r>   ÚcallableÚ	TypeErrorÚactr+  Úupsampler  Ú
downsample)rG   Ú
activationr2  r3  r4  r5  rJ   s         €r.   r>   z'Xcodec2AntiAliasedActivation1d.__init__  sH   ø€ ô 	‰ÑÔÜ˜
Ô#ÜÐBÓCÐCØˆŒÜ)¨(°NÓCˆŒÜ-¨jÐ:JÓKˆ�r-   c                 ól   — | j                  |«      }| j                  |«      }| j                  |«      }|S ru   )r:  r9  r;  rŒ   s     r.   rt   z&Xcodec2AntiAliasedActivation1d.forward$  s2   € ØŸ™ mÓ4ˆØŸ™ Ó/ˆØŸ™¨Ó6ˆàÐr-   )r   r   é   r>  )r#   r$   r%   rx   r>   rt   r{   r|   s   @r.   r1  r1    sH   ø„ ð ØØ Ø "ñLð ðLð ð	Lð
 ðLð õLör-   r1  c                   ó(   ‡ — e Zd ZdZˆ fd„Zd„ Zˆ xZS )ÚXcodec2ResidualUnitza
    A residual unit composed of Snake1d and weight-normalized Conv1d layers with dilations.
    c                 ó  •— t         ‰| �  «        d|z  dz  }t        t        |«      ¬«      | _        t        j                  ||d||¬«      | _        t        t        |«      ¬«      | _        t        j                  ||d¬«      | _	        y )Nr-  r   ©r<  é   )r	  ÚdilationÚpaddingr   )r	  )
r=   r>   r1  ró   Úsnake1r„   ÚConv1dÚconv1Úsnake2Úconv2)rG   Ú	dimensionrD  r$  rJ   s       €r.   r>   zXcodec2ResidualUnit.__init__1  sp   ø€ Ü‰ÑÔØ˜Ñ! aÑ'ˆÜ4Ô@PÐQZÓ@[Ô\ˆŒÜ—Y‘Y˜y¨)ÀÈXÐ_bÔcˆŒ
Ü4Ô@PÐQZÓ@[Ô\ˆŒÜ—Y‘Y˜y¨)ÀÔCˆ�
r-   c                 óö   — |}| j                  | j                  |«      «      }| j                  | j                  |«      «      }|j                  d   |j                  d   z
  dz  }|dkD  r
|d|| …f   }||z   }|S )ar  
        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.
        r^   r   r   .)rH  rF  rJ  rI  rf   )rG   Úhidden_stateÚoutput_tensorrE  s       r.   rt   zXcodec2ResidualUnit.forward9  s‰   € ð %ˆØŸ
™
 4§;¡;¨}Ó#=Ó>ˆØŸ
™
 4§;¡;¨}Ó#=Ó>ˆà×%Ñ% bÑ)¨M×,?Ñ,?ÀÑ,CÑCÈÑIˆØ�QŠ;Ø'¨¨W°g°XÐ-=Ð(=Ñ>ˆLØ$ }Ñ4ˆØÐr-   rü   r|   s   @r.   r@  r@  ,  s   ø„ ñôDör-   r@  c                   ó8   ‡ — e Zd ZdZddededefˆ fd„Zd„ Zˆ xZS )ÚXcodec2EncoderBlockz&Encoder block used in XCODEC2 encoder.r6   r  Ústride_indexc           
      ót  •— t         ‰| �  «        |j                  d|z  z  }t        |dz  d¬«      | _        t        |dz  d¬«      | _        t        |dz  d¬«      | _        t        t        |dz  «      ¬«      | _	        t        j                  |dz  |d|z  |t        j                  |dz  «      ¬«      | _        y )Nr   r   )rD  r   é	   rB  ©r	  r  rE  )r=   r>   Úencoder_hidden_sizer@  Ú	res_unit1Ú	res_unit2Ú	res_unit3r1  ró   rF  r„   rG  r  ÚceilrH  )rG   r6   r  rQ  rK  rJ   s        €r.   r>   zXcodec2EncoderBlock.__init__S  s§   ø€ Ü‰ÑÔØ×.Ñ.°°L±Ñ@ˆ	Ü,¨Y¸!©^ÀaÔHˆŒÜ,¨Y¸!©^ÀaÔHˆŒÜ,¨Y¸!©^ÀaÔHˆŒÜ4Ô@PÐQZÐ^_ÑQ_Ó@`ÔaˆŒÜ—Y‘YØ˜‰N˜I°1°v±:ÀfÔVZ×V_ÑV_Ð`fÐijÑ`jÓVkô
ˆ�
r-   c                 ó¬   — | j                  |«      }| j                  |«      }| j                  | j                  |«      «      }| j	                  |«      }|S ru   )rV  rW  rF  rX  rH  )rG   rM  s     r.   rt   zXcodec2EncoderBlock.forward^  sI   € Ø—~‘~ lÓ3ˆØ—~‘~ lÓ3ˆØ—{‘{ 4§>¡>°,Ó#?Ó@ˆØ—z‘z ,Ó/ˆàÐr-   )r   r   )	r#   r$   r%   r&   r   rx   r>   rt   r{   r|   s   @r.   rP  rP  P  s%   ø„ Ù0ñ	
˜}ð 	
°cð 	
ÈSõ 	
ör-   rP  c                   ó.   ‡ — e Zd ZdZdefˆ fd„Zd„ Zˆ xZS )ÚXcodec2EncoderzXCODEC2 Encoderr6   c                 ó  •— t         ‰| �  «        t        j                  d|j                  dd¬«      | _        g | _        t        |j                  «      D ],  \  }}|dz   }| xj                  t        |||¬«      gz  c_        Œ. t        j                  | j                  «      | _        |j                  dt        |j                  «      z  z  }t        t        |«      ¬«      | _        t        j                  ||j                  dd¬«      | _        y )Nr   rC  r   ©r	  rE  )r  rQ  r   rB  )r=   r>   r„   rG  rU  rH  ÚblockÚ	enumerateÚdownsampling_ratiosrP  Ú
ModuleListÚlenr1  ró   rF  rT   rJ  )rG   r6   rQ  r  Úd_modelrJ   s        €r.   r>   zXcodec2Encoder.__init__j  sá   ø€ Ü‰ÑÔô —Y‘Y˜q &×"<Ñ"<È!ÐUVÔWˆŒ
àˆŒ
ä$-¨f×.HÑ.HÓ$Iò 	bÑ ˆL˜&Ø'¨!Ñ+ˆLØ�JŠJÔ.¨v¸fÐS_Ô`ÐaÑaŽJð	bô —]‘] 4§:¡:Ó.ˆŒ
Ø×,Ñ,¨q´C¸×8RÑ8RÓ4SÑ/SÑSˆÜ4Ô@PÐQXÓ@YÔZˆŒÜ—Y‘Y˜w¨×(:Ñ(:ÈÐSTÔUˆ�
r-   c                 óž   — | j                  |«      }| j                  D ]
  } ||«      }Œ | j                  |«      }| j                  |«      }|S ru   )rH  r_  rF  rJ  )rG   rM  r¢   s      r.   rt   zXcodec2Encoder.forward{  sQ   € Ø—z‘z ,Ó/ˆà—j‘jò 	0ˆFÙ! ,Ó/‰Lð	0ð —{‘{ <Ó0ˆØ—z‘z ,Ó/ˆàÐr-   )r#   r$   r%   r&   r   r>   rt   r{   r|   s   @r.   r\  r\  g  s   ø„ ÙðV˜}õ Vö"	r-   r\  c                   ó\   ‡ — e Zd Zdefˆ fd„Zdej                  dej                  fd„Zˆ xZS )ÚXcodec2ResNetBlockr6   c                 ó  •— t         ‰| �  «        t        j                  d|j                  dd¬«      | _        t        j                  «       | _        t        j                  |j                  |j                  ddd¬«      | _	        t        j                  d|j                  dd¬«      | _
        t        j                  «       | _        |j                  | _        t        j                  |j                  |j                  ddd¬«      | _        y )Né    rã   T)Ú
num_groupsÚnum_channelsrÕ   Úaffiner   r   rT  )r=   r>   r„   Ú	GroupNormrT   Únorm1ÚSiLUÚactivation1rG  rH  Únorm2Úactivation2Úactivation_dropoutrJ  r‰   s     €r.   r>   zXcodec2ResNetBlock.__init__ˆ  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-   rŠ   rL   c                 óŒ  — |j                  dd«      }|}| j                  |«      }| j                  |«      }| j                  |«      }| j	                  |«      }| j                  |«      }t        j                  j                  || j                  | j                  ¬«      }| j                  |«      }||z   j                  dd«      S )Nr   r   r¬   )rj   rn  rp  rH  rq  rr  r„   r±   r¨   rs  r®   rJ  ©rG   rŠ   rï   s      r.   rt   zXcodec2ResNetBlock.forward’  s±   € Ø%×/Ñ/°°1Ó5ˆØ ˆØŸ
™
 =Ó1ˆØ×(Ñ(¨Ó7ˆØŸ
™
 =Ó1ˆØŸ
™
 =Ó1ˆØ×(Ñ(¨Ó7ˆÜŸ™×-Ñ-¨m¸t×?VÑ?VÐae×anÑanÐ-ÓoˆØŸ
™
 =Ó1ˆØ Ñ(×3Ñ3°A°qÓ9Ð9r-   r�   r|   s   @r.   rg  rg  ‡  s,   ø„ ðk˜}õ kð
: U§\¡\ð 
:°e·l±l÷ 
:r-   rg  c                   óü   ‡ — e Zd ZdZdefˆ fd„Zdd„Zdej                  dej                  fd„Z	ddej                  d	e
dej                  fd
„Zdej                  deej                  ej                  f   fd„Zˆ xZS )ÚXcodec2FiniteScalarQuantizationa!  
    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/xcodec2/blob/main/vq/codec_decoder_vocos.py#L389
    But we can directly use FSQ since a main feature of Xcodec2 is that it uses a single codebook.
    r6   c                 óö   •— t         ‰| �  «        t        |j                  «      | _        | j	                  «       \  }}}| j                  d|d¬«       | j                  d|d¬«       | j                  d|d¬«       y )NÚlevelsFr:   ÚbasisÚcodebook)r=   r>   ÚlistÚquantization_levelsÚ_compute_buffersrE   )rG   r6   ry  rz  r{  rJ   s        €r.   r>   z(Xcodec2FiniteScalarQuantization.__init__¨  su   ø€ Ü‰ÑÔÜ#'¨×(BÑ(BÓ#CˆÔ Ø"&×"7Ñ"7Ó"9Ñˆ��xØ×Ñ˜X v¸%ÐÔ@Ø×Ñ˜W e¸ÐÔ>Ø×Ñ˜Z¨¸eÐÕDr-   c                 óÆ  — t        j                  | j                  t         j                  |¬«      }t        j                  t        j                  dg| j                  dd z   |¬«      dt         j                  ¬«      }t        j
                  t        t        j                  | j                  «      «      |¬«      j                  d«      }||z  |z  }|dz  }||z
  |z  }|||fS )	zFCompute the levels, basis, and codebook buffers for the FSQ quantizer.)rR   rH   r   Nr^   ©rH   r   r«   r   )
r'   Útensorr}  Úint32ÚcumprodrV   rx   ÚnpÚprodr”   )rG   rH   ry  rz  ÚindicesÚlevel_indicesr  r{  s           r.   r~  z0Xcodec2FiniteScalarQuantization._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ˆØ  EÑ)¨VÑ3ˆØ˜q‘[ˆ
Ø! JÑ.°*Ñ<ˆØ�u˜hÐ&Ð&r-   r†  rL   c                 óŽ   — |j                  d«      }|| j                  z  | j                  z  }| j                  dz  }||z
  |z  }|S )z`
        Convert integer codebook indices to normalized per-dimension codes in [-1, 1].
        r^   r   )r”   rz  ry  )rG   r†  r‡  r  Úcodess        r.   Ú_indices_to_codesz1Xcodec2FiniteScalarQuantization._indices_to_codes¼  sM   € ð ×#Ñ# BÓ'ˆØ  D§J¡JÑ.°$·+±+Ñ=ˆØ—[‘[ AÑ%ˆ
Ø Ñ+¨zÑ9ˆØˆr-   rŠ   rÕ   c                 óØ   — | j                   dz
  d|z   z  dz  }t        j                  | j                   dz  dk(  dd«      }||z  j                  «       }||z   j	                  «       |z  |z
  S )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   r   r  rÉ   )ry  r'   ÚwhereÚatanhÚtanh)rG   rŠ   rÕ   Ú
half_rangeÚoffsetÚshifts         r.   Úboundz%Xcodec2FiniteScalarQuantization.boundÆ  so   € ð" —k‘k A‘o¨!¨c©'Ñ2°QÑ6ˆ
Ü—‘˜TŸ[™[¨1™_°Ñ1°3¸Ó<ˆØ˜*Ñ$×+Ñ+Ó-ˆØ Ñ%×+Ñ+Ó-°
Ñ:¸VÑCÐCr-   c                 ól  — |j                   }t        |j                  j                  t        «      r/|j                  j                  dk7  r|j                  j                  nd}t        |d¬«      5  |j                  «       }| j                  dz  }| j                  |«      }|j                  «       }|||z
  j                  «       z   }||z  }||z  |z   }|| j                  z  j                  d¬«      j                  t        j                  «      }d d d «       j                  |«      fS # 1 sw Y   ŒxY w)Nr_   r`   Fra   r   r^   rd   )rR   rg   rH   rh   ri   r   rY   ry  r’  ÚroundÚdetachrz  r  rX   r'   r‚  )	rG   rŠ   Úoriginal_dtyperb   r  Úroundedr‰  Úcode_scaledr†  s	            r.   rt   z'Xcodec2FiniteScalarQuantization.forwardÜ  s!  € à&×,Ñ,ˆô ˜-×.Ñ.×3Ñ3´SÔ9¸m×>RÑ>R×>WÑ>WÐ[`Ò>`ð × Ñ ×%Ò%àð 	ô
 ¨¸UÔCñ 
	MØ)×/Ñ/Ó1ˆMØŸ™¨Ñ)ˆJà ŸJ™J }Ó5ˆMØ#×)Ñ)Ó+ˆGØ! W¨}Ñ%<×$DÑ$DÓ$FÑFˆEØ˜JÑ&ˆEà  :Ñ-°Ñ;ˆKØ" T§Z¡ZÑ/×4Ñ4¸Ð4Ó<×?Ñ?ÄÇÁÓLˆG÷
	Mð �x‰x˜Ó'¨Ð0Ð0÷
	Mð 
	Mús   Á/B D*Ä*D3ru   )gü©ñÒMbP?)r#   r$   r%   r&   r   r>   r~  r'   r+   rŠ  rY   r’  ry   rt   r{   r|   s   @r.   rw  rw  Ÿ  s…   ø„ ñðE˜}õ Eó
'ð¨¯©ð ¸%¿,¹,ó ñD 5§<¡<ð D°eð DÀuÇ|Á|ó Dð,1 U§\¡\ð 1°e¸E¿L¹LÈ%Ï,É,Ð<VÑ6W÷ 1r-   rw  c                   ó`   ‡ — e Zd ZdZdefˆ fd„Zdej                  dej                  fd„Zˆ xZ	S )ÚXcodec2ISTFTHeadzù
    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
    r6   c                 ór  •— t         ‰| �  «        t        j                  |j                  |j
                  dz   «      | _        |j
                  | _        |j                  | _        | j
                  | j                  z
  dz  | _        t        j                  |j
                  «      }| j                  d|d¬«       y )Nr   ÚwindowFr:   )r=   r>   r„   r…   rT   Ún_fftÚlinearÚ
hop_lengthrE  r'   Úhann_windowrE   )rG   r6   rœ  rJ   s      €r.   r>   zXcodec2ISTFTHead.__init__ú  s‰   ø€ Ü‰ÑÔÜ—i‘i × 2Ñ 2°F·L±LÀ1Ñ4DÓEˆŒØ—\‘\ˆŒ
Ø ×+Ñ+ˆŒØŸ
™
 T§_¡_Ñ4¸Ñ:ˆŒÜ×"Ñ" 6§<¡<Ó0ˆØ×Ñ˜X v¸%ÐÕ@r-   rŠ   rL   c                 ó.  — | j                  |«      j                  dd«      }|j                  dd¬«      \  }}|j                  «       }|j                  «       }t	        j
                  |«      j                  d¬«      }|t	        j
                  d|z  «      z  }t        j                  j                  || j                  dd¬«      }|| j                  d d d …d f   z  }|j                  d	   }|dz
  | j                  z  | j                  z   }t        j                  |d|fd| j                  fd| j                  f¬
«      d d …dd| j                  | j                   …f   }	t        j                  | j                  j!                  «       j#                  d|d	«      j                  dd«      d|fd| j                  fd| j                  f¬
«      j%                  «       | j                  | j                    }
|
j                  d¬«      }
|	|
z  }	|	j'                  d«      S )Nr   r   rd   g      Y@)Úmaxy              ð?Úbackward)r[   Únormr^   )Úoutput_sizer	  r  r   g•dyáý¥=)Úmin)rž  rj   ÚchunkrY   r'   rû   ÚclampÚfftÚirfftr�  rœ  rf   rŸ  r#  ÚfoldrE  Úsquarere   Úsqueezer”   )rG   rŠ   Ú	stft_predÚ	magnitudeÚphaseÚspectrogram_complexÚtime_framesÚ
num_framesr¥  ÚaudioÚwindow_envelopes              r.   rt   zXcodec2ISTFTHead.forward  sÜ  € Ø—K‘K Ó.×8Ñ8¸¸AÓ>ˆ	Ø$Ÿ?™?¨1°!˜?Ó4Ñˆ	�5à—O‘OÓ%ˆ	Ø—‘“ˆä—I‘I˜iÓ(×.Ñ.°3Ð.Ó7ˆ	Ø'¬%¯)©)°B¸±JÓ*?Ñ?Ðô —i‘i—o‘oÐ&9¸4¿:¹:È1ÐS]�oÓ^ˆØ! D§K¡K°²a¸°Ñ$>Ñ>ˆØ(×.Ñ.¨rÑ2ˆ
Ø! 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-   ©
r#   r$   r%   r&   r   r>   r'   r+   rt   r{   r|   s   @r.   rš  rš  ò  s1   ø„ ñðA˜}õ Að!" U§\¡\ð !"°e·l±l÷ !"r-   rš  c                   ó²   ‡ — e Zd Zdefˆ fd„Zdej                  dej                  fd„Zdej                  deej                  ej                  f   fd„Z	ˆ xZ
S )ÚXcodec2Quantizerr6   c                 ó"  •— t         ‰| �  «        t        |«      | _        t	        j
                  |j                  t        |j                  «      «      | _	        t	        j
                  t        |j                  «      |j                  «      | _
        y ru   )r=   r>   rw  Ú	quantizerr„   r…   Úquantization_dimrc  r}  Ú
project_inÚproject_outr‰   s     €r.   r>   zXcodec2Quantizer.__init__(  sa   ø€ Ü‰ÑÔÜ8¸Ó@ˆŒÜŸ)™) F×$;Ñ$;¼SÀ×A[ÑA[Ó=\Ó]ˆŒÜŸ9™9¤S¨×)CÑ)CÓ%DÀf×F]ÑF]Ó^ˆÕr-   r†  rL   c                 óx   — |j                  d«      }| j                  j                  |   }| j                  |«      S ©Nr^   )r­  rº  r{  r½  )rG   r†  r‰  s      r.   Ú
from_codeszXcodec2Quantizer.from_codes.  s5   € Ø—/‘/ "Ó%ˆØ—‘×'Ñ'¨Ñ0ˆØ×Ñ Ó&Ð&r-   rŠ   c                 ó  — | j                  |«      }|j                  }| j                  j                  |«      }| j                  |«      \  }}| j	                  |j                  |«      «      }|j                  d«      }||fS r¿  )r¼  rR   rº  r’  r½  rX   r”   )rG   rŠ   r–  Úquantized_outr†  s        r.   rt   zXcodec2Quantizer.forward3  sx   € ØŸ™¨Ó6ˆØ&×,Ñ,ˆØŸ™×,Ñ,¨]Ó;ˆØ!%§¡°Ó!>Ñˆ�wØ×(Ñ(¨×)9Ñ)9¸.Ó)IÓJˆØ×#Ñ# BÓ'ˆØ˜gÐ%Ð%r-   )r#   r$   r%   r   r>   r'   r+   rÀ  ry   rt   r{   r|   s   @r.   r¸  r¸  '  sU   ø„ ð_˜}õ _ð' %§,¡,ð '°5·<±<ó 'ð
& U§\¡\ð &°e¸E¿L¹LÈ%Ï,É,Ð<VÑ6W÷ &r-   r¸  c                   ó`   ‡ — e Zd ZdZdefˆ fd„Zdej                  dej                  fd„Zˆ xZ	S )ÚXcodec2DecoderzVVocos-based decoder with ResNet, Transformer, and ISTFT head for audio reconstruction.r6   c           	      ó  •— t         ‰| �  «        t        j                  |j                  |j
                  j                  z   |j                  «      | _        t        j                  |j                  |j                  dd¬«      | _        t        j                  t        |«      t        |«      g«      | _        |j                  | _        t        |¬«      | _        t        j                  t        |j                   «      D �cg c]  }t#        ||«      ‘Œ c}«      | _        t        j                  t        |«      t        |«      g«      | _        t        j(                  |j                  d¬«      | _        t-        |«      | _        y c c}w )NrC  r   r^  )r6   rã   rç   )r=   r>   r„   r…   rT   Úsemantic_model_configÚfcrG  Úembedrb  rg  Ú	prior_netrU   r4   Ú
rotary_embÚrangeÚnum_hidden_layersrå   ÚlayersÚpost_netÚ	LayerNormr¤  rš  ÚheadrÅ   s      €r.   r>   zXcodec2Decoder.__init__@  s  ø€ Ü‰ÑÔÜ—)‘)˜F×.Ñ.°×1MÑ1M×1YÑ1YÑYÐ[a×[mÑ[mÓnˆŒÜ—Y‘Y˜v×1Ñ1°6×3EÑ3EÐSTÐ^_Ô`ˆŒ
ÜŸ™Ô(:¸6Ó(BÔDVÐW]ÓD^Ð'_Ó`ˆŒØ#)×#=Ñ#=ˆÔ Ü0¸Ô?ˆŒÜ—m‘mÜEJÈ6×KcÑKcÓEdÖe¸	Ô  ¨Õ3Òeó
ˆŒô Ÿ™Ô'9¸&Ó'AÔCUÐV\ÓC]Ð&^Ó_ˆŒÜ—L‘L ×!3Ñ!3¸Ô>ˆŒ	Ü$ VÓ,ˆ�	ùò	 fs   Ã>FrŠ   rL   c                 ó  — | j                  |«      }|j                  dd«      }| j                  |«      }|j                  dd«      }| j                  D ]
  } ||«      }Œ t	        j
                  | j                  |j                  ¬«      j                  d«      }| j                  ||«      }| j                  D ]  } ||fd|i|¤Ž}Œ | j                  D ]
  } ||«      }Œ | j                  | j                  |«      «      S )Nr   r   r€  r   rÆ   )rÇ  rj   rÈ  rÉ  r'   rV   rU   rH   r”   rÊ  rÍ  rÎ  rÐ  r¤  )rG   rŠ   r©   Úlayerro   rÆ   s         r.   rt   zXcodec2Decoder.forwardN  s   € ØŸ™ Ó.ˆØ%×/Ñ/°°1Ó5ˆØŸ
™
 =Ó1ˆØ%×/Ñ/°°1Ó5ˆð —^‘^ò 	1ˆEÙ! -Ó0‰Mð	1ô —|‘| D×$<Ñ$<À]×EYÑEYÔZ×dÑdÐefÓgˆØ"Ÿo™o¨m¸\ÓJÐØ—[‘[ò 	dˆEÙ! -ÑcÐEXÐcÐ\bÑc‰Mð	dð —]‘]ò 	1ˆEÙ! -Ó0‰Mð	1ð �y‰y˜Ÿ™ =Ó1Ó2Ð2r-   r¶  r|   s   @r.   rÄ  rÄ  =  s-   ø„ Ù`ð-˜}õ -ð3 U§\¡\ð 3ÀÇÁ÷ 3r-   rÄ  c                   ó\   ‡ — e Zd Zdefˆ fd„Zdej                  dej                  fd„Zˆ xZS )ÚXcodec2SemanticAdapterr6   c                 ó¾  •— t         ‰| �  «        t        j                  |j                  j
                  |j                  j
                  ddd¬«      | _        t        j                  «       | _        t        j                  |j                  j
                  |j                  j
                  ddd¬«      | _	        t        j                  «       | _
        t        j                  |j                  j
                  |j                  j
                  ddd¬«      | _        t        j                  |j                  j
                  |j                  j
                  ddd¬«      | _        y )Nr   r   F)Úin_channelsÚout_channelsr	  rE  r�   T)r	  rE  r�   )r=   r>   r„   rG  rÆ  rT   rH  ÚReLUÚact1rJ  Úact2Úconv3Úconv4r‰   s     €r.   r>   zXcodec2SemanticAdapter.__init__j  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-   rŠ   rL   c                 óà   — | j                  |«      }| j                  |«      }|}| j                  |«      }| j                  |«      }| j	                  |«      }||z   }| j                  |«      }|S ru   )rH  rÙ  rJ  rÚ  rÛ  rÜ  ru  s      r.   rt   zXcodec2SemanticAdapter.forward‹  sk   € ØŸ
™
 =Ó1ˆØŸ	™	 -Ó0ˆØ ˆØŸ
™
 =Ó1ˆØŸ	™	 -Ó0ˆØŸ
™
 =Ó1ˆØ%¨Ñ0ˆØŸ
™
 =Ó1ˆØÐr-   r�   r|   s   @r.   rÔ  rÔ  i  s+   ø„ ð
˜}õ 
ðB	 U§\¡\ð 	°e·l±l÷ 	r-   rÔ  c                   óf   ‡ — 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dZeedœZˆ fd	„Zˆ xZS )
ÚXcodec2PreTrainedModelr6   Úxcodec2)r´  TNrÇ   Úinput_values)rŠ   Ú
attentionsc                 ó  •— t         ‰| �  |«       t        |t        «      r?t	        j
                  |j                  «       t	        j
                  |j                  «       y t        |t        «      r@t        j                  |j                  «      }t	        j                  |j                  |«       y t        |t        «      r‹|j                  |j                   j"                  ¬«      \  }}}t	        j                  |j                   |«       t	        j                  |j$                  |«       t	        j                  |j&                  |«       y t        |t(        «      rRt+        d|j,                  z  d|j,                  z  |j.                  «      }t	        j                  |j0                  |«       y t        |t2        «      rLt+        |j4                  |j6                  |j.                  «      }t	        j                  |j0                  |«       y y )Nr€  r  r  )r=   Ú_init_weightsrg   ró   ÚinitÚzeros_r÷   rø   rš  r'   r   r�  Úcopy_rœ  rw  r~  ry  rH   rz  r{  r+  r  r  r	  r  r  r  r  )rG   r¢   rœ  ry  rz  r{  Úfilter_tensorrJ   s          €r.   rä  z$Xcodec2PreTrainedModel._init_weights«  sV  ø€ Ü‰Ñ˜fÔ%Ü�fÔ.Ô/Ü�K‰K˜Ÿ™Ô%Ü�K‰K˜Ÿ™Õ$Ü˜Ô 0Ô1Ü×&Ñ& v§|¡|Ó4ˆFÜ�J‰J�v—}‘} fÕ-Ü˜Ô ?Ô@Ø&,×&=Ñ&=ÀVÇ]Á]×EYÑEYÐ&=Ó&ZÑ#ˆF�E˜8Ü�J‰J�v—}‘} fÔ-Ü�J‰J�v—|‘| UÔ+Ü�J‰J�v—‘¨Õ1Ü˜Ô 1Ô2Ü0°°v·|±|Ñ1CÀSÈ6Ï<É<ÑEWÐY_×YkÑYkÓlˆMÜ�J‰J�v—}‘} mÕ4Ü˜Ô 3Ô4Ü0°·±À×@QÑ@QÐSY×SeÑSeÓfˆMÜ�J‰J�v—}‘} mÕ4ð 5r-   )r#   r$   r%   r   r)   Ú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ä  r{   r|   s   @r.   rß  rß  —  sj   ø… àÓØ!ÐØ!ÐØ&*Ð#ØÐØ#4Ð"5ÐØÐØ€NØÐØ ÐØ"&ÐØ!ÐØ$€Oà,Ø)ñÐ÷
5ð 5r-   rß  z!Xcodec2 neural audio codec model.)Úcustom_introc                   óê  ‡ — e Zd ZeZdefˆ fd„Zee	 	 	 ddej                  dej                  dej                  dz  dej                  dz  de
d	ee   d
eez  fd„«       «       Zee	 	 ddej                  dz  dej                  dz  d	ee   d
eez  fd„«       «       Zee	 	 	 ddej                  dej                  dej                  dz  dej                  dz  de
d	ee   d
eez  fd„«       «       Zˆ xZS )ÚXcodec2Modelr6   c                 óè  •— t         ‰| �  |«       |j                  | _        t        j                  |j
                  «      | _        t        |«      | _        t        |«      | _
        t        j                  |j                  |j
                  j                  z   |j                  |j
                  j                  z   «      | _        t        |«      | _        t#        |«      | _        | j'                  «        y ru   )r=   r>   rŸ  r   Úfrom_configrÆ  Úsemantic_encoderrÔ  Úsemantic_adapterr\  Úacoustic_encoderr„   r…   rT   Ú
fc_encoderr¸  rº  rÄ  Úacoustic_decoderÚ	post_initr‰   s     €r.   r>   zXcodec2Model.__init__Ä  s¹   ø€ Ü‰Ñ˜Ô à ×+Ñ+ˆŒÜ )× 5Ñ 5°f×6RÑ6RÓ SˆÔÜ 6°vÓ >ˆÔÜ .¨vÓ 6ˆÔÜŸ)™)Ø×Ñ ×!=Ñ!=×!IÑ!IÑIØ×Ñ ×!=Ñ!=×!IÑ!IÑIó
ˆŒô *¨&Ó1ˆŒÜ .¨vÓ 6ˆÔà�‰Õr-   Nrá  Úinput_featuresÚpadding_maskÚinput_features_maskÚoutput_latentsr©   rL   c                 ó  — t        j                  «       5  | j                  ||¬«      }ddd«       j                  j	                  dd«      }| j                  |«      }| j                  |«      }	t        j                  ||	gd¬«      }
| j                  |
j	                  dd«      «      }
| j                  |
«      \  }}|j	                  dd«      }|j	                  dd«      }d}|�~|j                  dd¬«      }|| j                  z  }t        j                  |j                  d   |j                  ¬	«      j                  dd«      }||k  j!                  |j"                  «      }t%        ||r||¬
«      S d|¬
«      S # 1 sw Y   �ŒTxY w)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¦   Nr   r   rd   r^   T)r[   rÛ   r€  )r    r!   r"   )r'   rz   rû  Úlast_hidden_staterj   rü  rý  rk   rþ  rº  r  rŸ  rV   rf   rH   rÊ   rX   rR   r0   )rG   rá  r  r  r  r  r©   Úsemantic_outputÚsemantic_hidden_statesÚacoustic_hidden_statesrŠ   r!   r    r"   Úaudio_lengthÚtoken_lengthÚidxs                    r.   ÚencodezXcodec2Model.encodeÔ  sŒ  € ô2 �]‰]‹_ñ 	hØ"×3Ñ3°NÐSfÐ3ÓgˆO÷	hà!0×!BÑ!B×!LÑ!LÈQÐPQÓ!RÐØ!%×!6Ñ!6Ð7MÓ!NÐð "&×!6Ñ!6°|Ó!DÐÜŸ	™	Ð#9Ð;QÐ"RÐXYÔZˆØŸ™¨×(?Ñ(?ÀÀ1Ó(EÓFˆð  $Ÿ~™~¨mÓ<Ñˆ�Ø×#Ñ# A qÓ)ˆØ!×+Ñ+¨A¨qÓ1ˆð  ÐØÐ#Ø'×+Ñ+°¸DÐ+ÓAˆLØ'¨4¯?©?Ñ:ˆLÜ—,‘,˜{×0Ñ0°Ñ4¸\×=PÑ=PÔQ×VÑVÐWXÐZ\Ó]ˆCØ # lÑ 2×6Ñ6°|×7IÑ7IÓJÐä#Ø#Ù-�GØ-ô
ð 	
à37Ø-ô
ð 	
÷/	hñ 	hús   •E;Å;Fr    r!   c                 óÞ   — |€|€t        d«      ‚|�,| j                  j                  |j                  dd«      «      }n|j                  dd«      } | j                  |fi |¤Ž}t        |¬«      S )a3  
        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.
        z3Either `latents` or `audio_codes` must be provided.r   r   )r   )r  rº  rÀ  rj   rÿ  r2   )rG   r    r!   r©   Úrecon_audios        r.   ÚdecodezXcodec2Model.decode
  su   € ð ˆ?˜{Ð2ÜÐRÓSÐSàÐ"Ø—n‘n×/Ñ/°×0EÑ0EÀaÈÓ0KÓL‰Gà×'Ñ'¨¨1Ó-ˆGà+�d×+Ñ+¨GÑ>°vÑ>ˆÜ#°Ô=Ð=r-   c                 ó  — |j                   d   }| j                  ||||dd¬«      } | j                  d	|j                  ddœ|¤Žd   dd|…f   }	t	        |	|j
                  |r|j                  nd|j                  ¬«      S )
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.

        Examples:

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

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

        >>> model_id = "HKUSTAudio/xcodec2-hf"
        >>> model = Xcodec2Model.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
        ```r^   T)r  r  r  r  Úreturn_dict)r!   r  r   .N)r   r    r!   r"   r,   )rf   r  r  r!   r   r    r"   )
rG   rá  r  r  r  r  r©   ÚlengthÚencoder_outputsr   s
             r.   rt   zXcodec2Model.forward#  s¥   € ðV ×#Ñ# BÑ'ˆàŸ+™+ØØ)Ø%Ø 3ØØð &ó 
ˆð #�t—{‘{Ð_¨?×+BÑ+BÐPTÑ_ÐX^Ñ_Ð`aÑbÐcfÐhoÐioÐhoÐcoÑpˆäØ%Ø'×3Ñ3Ù/=�O×+Ò+À4Ø,×=Ñ=ô	
ð 	
r-   )NNF)NN)r#   r$   r%   r   Úconfig_classr>   r   r   r'   r+   rñ   r   r   ry   r0   r  r2   r  r   rt   r{   r|   s   @r.   rø  rø  À  sž  ø„ à €Lð˜}õ ð  Øð
 -1Ø37Ø$ñ2
à—l‘lð2
ð Ÿ™ð2
ð —l‘l TÑ)ð	2
ð
 #Ÿ\™\¨DÑ0ð2
ð ð2
ð Ð+Ñ,ð2
ð 
Ð%Ñ	%ò2
ó ó ð2
ðh Øð ,0Ø'+ñ>à—\‘\ DÑ(ð>ð —‘ Ñ$ð>ð Ð+Ñ,ð	>ð
 
Ð%Ñ	%ò>ó ó ð>ð. Øð
 -1Ø37Ø$ñ:
à—l‘lð:
ð Ÿ™ð:
ð —l‘l TÑ)ð	:
ð
 #Ÿ\™\¨DÑ0ð:
ð ð:
ð Ð+Ñ,ð:
ð 
�Ñ	ò:
ó ó ô:
r-   rø  )r   )rÉ   )Qr  Úcollections.abcr   Údataclassesr   Útypingr   Únumpyr„  r'   Útorch.nnr„   Útorch.nn.functionalr±   r#  r   Ú r   rå  Úactivationsr	   Úcache_utilsr
   Úintegrationsr   r   r   Úmodeling_layersr   Úmodeling_rope_utilsr   r   Úmodeling_utilsr   r   Úprocessing_utilsr   Úutilsr   r   r   r   Úutils.genericr   Úautor   Úconfiguration_xcodec2r   r   r0   r2   ÚModuler4   r~   r‘   rš   r+   rx   r¡   rY   r¹   r»   rÔ   rå   ró   r  r  r+  r1  r@  rP  r\  rg  rw  rš  r¸  rÄ  rÔ  rß  rø  Ú__all__r,   r-   r.   ú<module>r*     s!  ðó( Ý $Ý !Ý ã Û Ý ß Ð Ý å &Ý !Ý  ß fÑ fÝ 9ß Kß FÝ &ß VÓ VÝ +Ý Ý 0ð Ø
ô1�Kó 1ó ó ð1ð( Ø
ô1˜;ó 1ó ó ð1ð" Ø
ô2˜;ó 2ó ó ð2ô><˜RŸY™Yô ><ôB�—‘ô ò(ñ Ð*Ó+òó ,ðð2	U˜UŸ\™\ð 	U°#ð 	U¸%¿,¹,ó 	Uð& ñ%Ø�I‰Ið%à�<‰<ð%ð 
�‰ð%ð �<‰<ð	%ð
 —L‘L 4Ñ'ð%ð ð%ð ð%ð Ð'Ñ(ó%ñ2 Ð)Ó*ôC)�r—y‘yó C)ó +ðC)ñL ˜YÓ'ôJ�R—Y‘Yó Jó (ðJô((Ð4ô (ôV&�r—y‘yô &òR+5ô\˜"Ÿ)™)ô ôD˜Ÿ	™	ô ô6 R§Y¡Yô ô0!˜"Ÿ)™)ô !ôH˜"Ÿ)™)ô ô.�R—Y‘Yô ô@:˜Ÿ™ô :ô0P1 b§i¡iô P1ôf2"�r—y‘yô 2"ôj&�r—y‘yô &ô,)3�R—Y‘Yô )3ôX+˜RŸY™Yô +ð\ ô%5˜_ó %5ó ð%5ñP Ð@ÔAô^
Ð)ó ^
ó Bð^
ðB Ð3Ð
4�r-   