Ë
    ÜÓ^j³c  ã                   ó´  — d Z ddlZddlmZ ddlmZ ddlZddlmZ ddl	mc m
Z ddlmZ ddlmZ ddlmZ 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 e G d„ de«      «       Ze G d„ de«      «       Ze G d„ de«      «       Z  G d„ dejB                  «      Z" G d„ dejB                  «      Z# G d„ dejB                  «      Z$ G d„ dejB                  «      Z% G d„ dejB                  «      Z& G d„ d ejB                  «      Z' G d!„ d"ejB                  «      Z( G d#„ d$ejB                  «      Z)e G d%„ d&e«      «       Z* ed'¬(«       G d)„ d*e*«      «       Z+d*d&gZ,y)+zTransformers Xcodec model.é    N)Ú	dataclass)Ú	lru_cacheé   )Úinitialization)Úconv1d_output_length)ÚPreTrainedAudioTokenizerBase)ÚUnpack)ÚModelOutputÚTransformersKwargsÚauto_docstringÚcan_return_tupleé   )Ú	AutoModelé   )ÚXcodecConfigc                   ób   — e Zd ZU dZdZej                  dz  ed<   dZej                  dz  ed<   y)ÚXcodecOutputao  
    Args:
        audio_codes (`torch.LongTensor`  of shape `(batch_size, num_quantizers, codes_length)`, *optional*):
            Discrete code indices computed using `model.encode`.
        audio_values (`torch.FloatTensor` of shape `(batch_size, channels, num_samples)`, *optional*)
            Decoded audio values obtained using the decoder part of Xcodec.
    NÚaudio_codesÚaudio_values)
Ú__name__Ú
__module__Ú__qualname__Ú__doc__r   ÚtorchÚ
LongTensorÚ__annotations__r   ÚFloatTensor© ó    úu/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/transformers/models/xcodec/modeling_xcodec.pyr   r   &   s3   … ñð ,0€K�×!Ñ! DÑ(Ó/Ø-1€L�%×#Ñ# dÑ*Ô1r   r   c                   ó:   — e Zd ZU dZdZej                  dz  ed<   y)ÚXcodecEncoderOutputz½
    Args:
        audio_codes (`torch.LongTensor`  of shape `(batch_size, num_quantizers, codes_length)`, *optional*):
            Discrete code indices computed using `model.encode`.
    Nr   )r   r   r   r   r   r   r   r   r   r   r    r"   r"   4   s   … ñð ,0€K�×!Ñ! DÑ(Ô/r   r"   c                   ó:   — e Zd ZU dZdZej                  dz  ed<   y)ÚXcodecDecoderOutputzÃ
    Args:
        audio_values (`torch.FloatTensor`  of shape `(batch_size, channels, num_samples)`, *optional*):
            Decoded audio values obtained using the decoder part of Xcodec.
    Nr   )r   r   r   r   r   r   r   r   r   r   r    r$   r$   ?   s   … ñð .2€L�%×#Ñ# dÑ*Ô1r   r$   c                   ól   ‡ — e Zd ZdZdedededefˆ fd„Zdej                  dej                  fd	„Z	ˆ xZ
S )
ÚXcodecResidualUnitzFResidual block for SemanticEncoder and SemanticDecoder used in Xcodec.ÚconfigÚin_channelsÚout_channelsÚdilationc           
      ó  •— t         ‰| �  «        t        j                  «       | _        |j
                  dz
  dz  |z  }t        j                  |||j
                  d||dd¬«      | _        t        j                  ||dd¬«      | _        y )Nr   r   F)ÚstrideÚpaddingr*   ÚgroupsÚbias)r(   r)   Úkernel_sizer/   )	ÚsuperÚ__init__ÚnnÚELUÚ
activationÚunit_kernel_sizeÚConv1dÚconv1Úconv2)Úselfr'   r(   r)   r*   r-   Ú	__class__s         €r    r2   zXcodecResidualUnit.__init__M   s}   ø€ Ü‰ÑÔÜŸ&™&›(ˆŒØ×+Ñ+¨aÑ/°AÑ5¸ÑAˆÜ—Y‘YØØØ×#Ñ#ØØØØØô	
ˆŒ
ô —Y‘Y¨<ÀlÐ`aÐhmÔnˆ�
r   Úhidden_stateÚreturnc                 ó”   — | j                  |«      }| j                  |«      }| j                  |«      }| j                  |«      }||z   S ©N)r5   r8   r9   )r:   r<   Úoutput_tensors      r    ÚforwardzXcodecResidualUnit.forward]   sE   € ØŸ™¨Ó5ˆØŸ
™
 =Ó1ˆØŸ™¨Ó6ˆØŸ
™
 =Ó1ˆØ˜mÑ+Ð+r   )r   r   r   r   r   Úintr2   r   ÚTensorrA   Ú__classcell__©r;   s   @r    r&   r&   J   sH   ø„ ÙPðo˜|ð o¸#ð oÈSð oÐ\_õ oð , E§L¡Lð ,°U·\±\÷ ,r   r&   c                   óh   ‡ — e Zd Zdedededefˆ fd„Zdej                  dej                  fd„Zˆ xZ	S )	ÚXcodecSemanticEncoderBlockr'   r(   r)   r,   c                 ó  •— t         ‰| �  «        t        j                  |j                  D �cg c]  }t        ||||«      ‘Œ c}«      | _        |dk(  rdnd|z  }|dz
  dz  }t        j                  |||||d¬«      | _        y c c}w )Nr   r   r   T©r0   r,   r-   r/   )	r1   r2   r3   Ú
ModuleListÚblock_dilationsr&   Ú	res_unitsr7   Úconv)	r:   r'   r(   r)   r,   r*   Úkernelr-   r;   s	           €r    r2   z#XcodecSemanticEncoderBlock.__init__f   sƒ   ø€ Ü‰ÑÔÜŸ™Ø\b×\rÑ\rÖsÐPXÔ ¨°[À(ÕKÒsó
ˆŒð
  ’k‘¨¨F©
ˆØ˜A‘: !Ñ#ˆÜ—I‘I˜k¨<ÀVÐTZÐdkÐrvÔwˆ�	ùò ts   ­Br<   r=   c                 óZ   — | j                   D ]
  } ||«      }Œ | j                  |«      }|S r?   )rL   rM   ©r:   r<   Úunits      r    rA   z"XcodecSemanticEncoderBlock.forwardq   s3   € Ø—N‘Nò 	.ˆDÙ Ó-‰Lð	.à—y‘y Ó.ˆØÐr   ©
r   r   r   r   rB   r2   r   rC   rA   rD   rE   s   @r    rG   rG   e   sE   ø„ ð	x˜|ð 	x¸#ð 	xÈSð 	xÐZ]õ 	xð E§L¡Lð °U·\±\÷ r   rG   c                   óV   ‡ — e Zd Zˆ fd„Zdej
                  dej
                  fd„Zˆ xZS )ÚSemanticEncoderc                 ó   •— t         ‰| �  «        t        |j                  «      t        |j                  «      k7  rt        d«      ‚t        j                  |j                  |j                  |j                  d|j                  dz  d¬«      | _
        |j                  }g }t        |j                  «      D ]>  \  }}t        |j                  |j                  |   z  «      }|t        ||||«      gz  }|}Œ@ t        j                  |«      | _        y )Nz:Number of strides must match the number of channel_ratios.r   r   F©r/   )r1   r2   ÚlenÚstridesÚchannel_ratiosÚ
ValueErrorr3   r7   Úsemantic_hidden_sizer0   rM   Ú	enumeraterB   rG   rJ   Úconv_blocks)r:   r'   r(   r]   Úir,   r)   r;   s          €r    r2   zSemanticEncoder.__init__y   sö   ø€ Ü‰ÑÔÜˆv�~‰~Ó¤# f×&;Ñ&;Ó"<Ò<ÜÐYÓZÐZÜ—I‘IØ×'Ñ'Ø×'Ñ'Ø×ÑØØ×Ñ !Ñ#Øô
ˆŒ	ð ×1Ñ1ˆØˆÜ" 6§>¡>Ó2ò 	'‰IˆAˆvÜ˜v×:Ñ:¸V×=RÑ=RÐSTÑ=UÑUÓVˆLØÔ6°v¸{ÈLÐZ`ÓaÐbÑbˆKØ&‰Kð	'ô
 Ÿ=™=¨Ó5ˆÕr   r<   r=   c                 óZ   — | j                  |«      }| j                  D ]
  } ||«      }Œ |S r?   )rM   r]   ©r:   r<   Úblocks      r    rA   zSemanticEncoder.forward�   s5   € Ø—y‘y Ó.ˆØ×%Ñ%ò 	/ˆEÙ  Ó.‰Lð	/àÐr   ©r   r   r   r2   r   rC   rA   rD   rE   s   @r    rT   rT   x   s#   ø„ ô6ð, E§L¡Lð °U·\±\÷ r   rT   c                   óh   ‡ — e Zd Zdedededefˆ fd„Zdej                  dej                  fd„Zˆ xZ	S )	ÚSemanticDecoderBlockr'   r(   r)   r,   c                 óh  •— t         ‰	| �  «        |dk(  r!t        j                  ||dddd¬«      | _        n:d|z  }|dz   dz  }|dz  dk(  rdnd}t        j
                  ||||||d¬«      | _        t        j                  |j                  D �cg c]  }t        ||||«      ‘Œ c}«      | _	        y c c}w )	Nr   r   TrI   r   r   FrV   )
r1   r2   r3   r7   rM   ÚConvTranspose1drJ   rK   r&   rL   )
r:   r'   r(   r)   r,   r0   r-   Úoutput_paddingr*   r;   s
            €r    r2   zSemanticDecoderBlock.__init__—   s¹   ø€ Ü‰ÑÔØ�QŠ;ÜŸ	™	ØØØØØØôˆD�Ið ˜f™*ˆKØ ‘z aÑ'ˆGØ"(¨1¡*°¢/™Q°qˆNÜ×*Ñ*Ø˜\¨;¸ÀÈÐ^côˆDŒIô Ÿ™Ø^d×^tÑ^tÖuÐRZÔ ¨°lÀHÕMÒuó
ˆ�ùÚus   ÂB/r<   r=   c                 óZ   — | j                  |«      }| j                  D ]
  } ||«      }Œ |S r?   )rM   rL   rP   s      r    rA   zSemanticDecoderBlock.forward®   s3   € Ø—y‘y Ó.ˆØ—N‘Nò 	.ˆDÙ Ó-‰Lð	.àÐr   rR   rE   s   @r    rd   rd   –   s@   ø„ ð
˜|ð 
¸#ð 
ÈSð 
ÐZ]õ 
ð. E§L¡Lð °U·\±\÷ r   rd   c                   óV   ‡ — e Zd Zˆ fd„Zdej
                  dej
                  fd„Zˆ xZS )ÚSemanticDecoderc                 ó   •— t         ‰| �  «        t        j                  |j                  t        |j                  |j                  d   z  «      |j                  d|j                  dz  d¬«      | _        g }t        |j                  «      D ]Œ  \  }}t        |j                  |j                  |   z  «      }|t        |j                  «      dz
  k  r)t        |j                  |j                  |dz      z  «      }n|j                  }|t        ||||«      gz  }ŒŽ t        j                  |«      | _        t        j                  |j                  |j                  |j                  d|j                  dz  d¬«      | _        y )Nr   r   r   F)r(   r)   r0   r,   r-   r/   )r,   r-   r/   )r1   r2   r3   r7   r[   rB   rY   r0   r8   r\   rX   rW   rd   rJ   r]   r9   )r:   r'   r]   r^   r,   r(   r)   r;   s          €r    r2   zSemanticDecoder.__init__¶   s_  ø€ Ü‰ÑÔÜ—Y‘YØ×3Ñ3Ü˜V×8Ñ8¸6×;PÑ;PÐQRÑ;SÑSÓTØ×*Ñ*ØØ×&Ñ&¨!Ñ+Øô
ˆŒ
ð ˆÜ" 6§>¡>Ó2ò 	]‰IˆAˆvÜ˜f×9Ñ9¸F×<QÑ<QÐRSÑ<TÑTÓUˆKà”C˜×-Ñ-Ó.°Ñ2Ò3Ü" 6×#>Ñ#>À×AVÑAVÐWXÐ[\ÑW\ÑA]Ñ#]Ó^‘à%×:Ñ:�àÔ0°¸ÀlÐTZÓ[Ð\Ñ\‰Kð	]ô Ÿ=™=¨Ó5ˆÔÜ—Y‘YØ×'Ñ'Ø×'Ñ'Ø×ÑØØ×&Ñ&¨!Ñ+Øô
ˆ�
r   r<   r=   c                 ó|   — | j                  |«      }| j                  D ]
  } ||«      }Œ | j                  |«      }|S r?   )r8   r]   r9   r`   s      r    rA   zSemanticDecoder.forwardÕ   sC   € Ø—z‘z ,Ó/ˆØ×%Ñ%ò 	/ˆEÙ  Ó.‰Lð	/à—z‘z ,Ó/ˆØÐr   rb   rE   s   @r    rj   rj   µ   s#   ø„ ô
ð> E§L¡Lð °U·\±\÷ r   rj   c                   ó4   ‡ — e Zd ZdZˆ fd„Zd„ Zd„ Zd„ Zˆ xZS )ÚXcodecEuclideanCodebookz!Codebook with Euclidean distance.c                 ó¦  •— t         ‰| �  «        t        j                  |j                  |j
                  «      }|j                  | _        | j                  dt        j                  dg«      «       | j                  dt        j                  |j                  «      «       | j                  d|«       | j                  d|j                  «       «       y )NÚinitedTÚcluster_sizeÚembedÚ	embed_avg)	r1   r2   r   ÚzerosÚcodebook_sizeÚcodebook_dimÚregister_bufferrC   Úclone)r:   r'   rr   r;   s      €r    r2   z XcodecEuclideanCodebook.__init__à   s˜   ø€ Ü‰ÑÔÜ—‘˜F×0Ñ0°&×2EÑ2EÓFˆØ#×1Ñ1ˆÔØ×Ñ˜X¤u§|¡|°T°FÓ';Ô<Ø×Ñ˜^¬U¯[©[¸×9MÑ9MÓ-NÔOØ×Ñ˜W eÔ,Ø×Ñ˜[¨%¯+©+«-Õ8r   c                 ó  — | j                   j                  «       }|j                  d«      j                  dd¬«      }|d|z  |z  z
  |j                  d«      j                  dd¬«      z    }|j	                  d¬«      j
                  }|S )Nr   r   T)Úkeepdimr   éÿÿÿÿ©Údim)rr   ÚtÚpowÚsumÚmaxÚindices)r:   Úhidden_statesrr   Úscaled_statesÚdistÚ	embed_inds         r    Úquantizez XcodecEuclideanCodebook.quantizeê   s‚   € Ø—
‘
—‘“ˆØ%×)Ñ)¨!Ó,×0Ñ0°¸DÐ0ÓAˆØ  ]Ñ!2°UÑ!:Ñ:¸U¿Y¹YÀq»\×=MÑ=MÈaÐY]Ð=MÓ=^Ñ^Ð_ˆØ—H‘H �HÓ$×,Ñ,ˆ	ØÐr   c                 ó�   — |j                   }|j                  d|d   f«      }| j                  |«      } |j                  |d d Ž }|S )Nr{   )ÚshapeÚreshaper‡   Úview)r:   rƒ   r‰   r†   s       r    ÚencodezXcodecEuclideanCodebook.encodeñ   sO   € Ø×#Ñ#ˆØ%×-Ñ-¨r°5¸±9¨oÓ>ˆØ—M‘M -Ó0ˆ	Ø"�I—N‘N E¨#¨2 JÐ/ˆ	ØÐr   c                 óŒ   — t        j                  |j                  | j                  j                  «      | j                  «      }|S r?   )ÚFÚ	embeddingÚtorr   Údevice)r:   r†   Ú	quantizeds      r    ÚdecodezXcodecEuclideanCodebook.decodeø   s/   € Ü—K‘K 	§¡¨T¯Z©Z×->Ñ->Ó ?ÀÇÁÓLˆ	ØÐr   )	r   r   r   r   r2   r‡   rŒ   r“   rD   rE   s   @r    rn   rn   Ý   s   ø„ Ù+ô9òòör   rn   c                   ó4   ‡ — e Zd ZdZdefˆ fd„Zd„ Zd„ Zˆ xZS )ÚXcodecVectorQuantizationzY
    Vector quantization implementation. Currently supports only euclidean distance.
    r'   c                 óB   •— t         ‰| �  «        t        |«      | _        y r?   )r1   r2   rn   Úcodebook)r:   r'   r;   s     €r    r2   z!XcodecVectorQuantization.__init__  s   ø€ Ü‰ÑÔÜ/°Ó7ˆ�r   c                 ób   — |j                  ddd«      }| j                  j                  |«      }|S ©Nr   r   r   )Úpermuter—   rŒ   )r:   rƒ   Úembed_ins      r    rŒ   zXcodecVectorQuantization.encode  s/   € Ø%×-Ñ-¨a°°AÓ6ˆØ—=‘=×'Ñ'¨Ó6ˆØˆr   c                 ób   — | j                   j                  |«      }|j                  ddd«      }|S r™   )r—   r“   rš   )r:   r†   r‡   s      r    r“   zXcodecVectorQuantization.decode  s/   € Ø—=‘=×'Ñ'¨	Ó2ˆØ×#Ñ# A q¨!Ó,ˆØˆr   )	r   r   r   r   r   r2   rŒ   r“   rD   rE   s   @r    r•   r•   ý   s   ø„ ñð8˜|õ 8ò
ör   r•   c                   ó®   ‡ — e Zd ZdZdefˆ fd„Zd„ Zddefd„Zdde	j                  de	j                  fd„Zd	e	j                  de	j                  fd
„Zˆ xZS )Ú XcodecResidualVectorQuantizationzv
    Residual vector quantization implementation. Follows Algorithm 1 in https://huggingface.co/papers/2107.03312
    r'   c                 ó  •— t         ‰| �  «        t        j                  t	        |j
                  «      D �cg c]  }t        |«      ‘Œ c}«      | _        |j                  | _        |j                  | _	        |j
                  | _        y c c}w r?   )
r1   r2   r3   rJ   ÚrangeÚnum_quantizersr•   Ú
quantizersÚ
frame_rateru   )r:   r'   Ú_r;   s      €r    r2   z)XcodecResidualVectorQuantization.__init__  sk   ø€ Ü‰ÑÔÜŸ-™-ÔSXÐY_×YnÑYnÓSoÖ(pÈaÔ)AÀ&Õ)IÒ(pÓqˆŒØ ×+Ñ+ˆŒØ#×1Ñ1ˆÔØ$×3Ñ3ˆÕùò )qs   ¶Bc                 ó`   — t        j                  | j                  «      | j                  z  dz  S )zReturn bandwidth per quantizer.iè  )ÚmathÚlog2ru   r£   )r:   s    r    Úget_bandwidth_per_quantizerz<XcodecResidualVectorQuantization.get_bandwidth_per_quantizer  s%   € ä�y‰y˜×+Ñ+Ó,¨t¯©Ñ>ÀÑEÐEr   r=   c           	      ó¢   — | j                  «       }| j                  }|�0|dkD  r+t        t        dt	        j
                  ||z  «      «      «      }|S )z:Return num_quantizers based on specified target bandwidth.ç        r   )r¨   r¡   rB   r�   r¦   Úfloor)r:   Ú	bandwidthÚbw_per_qr¡   s       r    Ú get_num_quantizers_for_bandwidthzAXcodecResidualVectorQuantization.get_num_quantizers_for_bandwidth#  sL   € à×3Ñ3Ó5ˆØ×,Ñ,ˆØÐ  Y°¢_Ü ¤ Q¬¯
©
°9¸xÑ3GÓ(HÓ!IÓJˆNØÐr   Ú
embeddingsc                 óò   — | j                  |«      }|}g }| j                  d| D ]:  }|j                  |«      }|j                  |«      }||z
  }|j	                  |«       Œ< t        j                  |«      }	|	S )a  
        Encode the input tensor into discrete indices using RVQ, with the number of quantizers selected based on the given bandwidth.
        Each quantizer /codebook residually quantizes the input and returns the nearest indices in terms of Euclidian distance.
        N)r®   r¢   rŒ   r“   Úappendr   Ústack)
r:   r¯   r¬   r¡   ÚresidualÚall_indicesÚ	quantizerr‚   r’   Úout_indicess
             r    rŒ   z'XcodecResidualVectorQuantization.encode+  s†   € ð
 ×>Ñ>¸yÓIˆØˆØˆØŸ™¨¨.Ð9ò 	(ˆIØ×&Ñ& xÓ0ˆGØ!×(Ñ(¨Ó1ˆIØ )Ñ+ˆHØ×Ñ˜wÕ'ð		(ô
 —k‘k +Ó.ˆØÐr   Úcodesc                 óê   — t        j                  d|j                  ¬«      }t        |«      D ]C  \  }}| j                  |   }|j                  |«      }||j                  |j                  «      z   }ŒE |S )z9Decode the given codes to their quantized representation.rª   )r‘   )r   Útensorr‘   r\   r¢   r“   r�   )r:   r·   Úquantized_outr^   r‚   rµ   r’   s          r    r“   z'XcodecResidualVectorQuantization.decode;  sm   € äŸ™ S°·±Ô>ˆÜ# EÓ*ò 	G‰JˆAˆwØŸ™¨Ñ*ˆIØ!×(Ñ(¨Ó1ˆIØ)¨I¯L©L¸¿¹Ó,FÑF‰Mð	Gð Ðr   r?   )r   r   r   r   r   r2   r¨   rB   r®   r   rC   rŒ   r“   rD   rE   s   @r    rž   rž     s\   ø„ ñð4˜|õ 4òFñÀ#ó ñ §¡ð À%Ç,Á,ó ð ˜EŸL™Lð ¨U¯\©\÷ r   rž   c                   óx   — e Zd ZdZeZdZdZdZdgZ	 e
j                  «       d„ «       Zd„ Zd„ Zed	„ «       Zdd„Zy
)ÚXcodecPreTrainedModelz†
    An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
    models.
    ÚxcodecÚinput_valuesÚaudiorž   c                 ó°  — t        |t        j                  «      rct        j                  |j
                  d| j                  j                  ¬«       |j                  � t        j                  |j                  «       yyt        |t        j                  t        j                  f«      r?t        j                  |j                  «       t        j                  |j
                  «       yt        |t        j                  «      rŒt        j                  |j
                  «       |j                  �`t        j                   |j"                  |j$                  |j&                  d   z  z  «      }t        j(                  |j                  | |¬«       yy|j*                  j,                  dk(  r t        j                  |j.                  «       yt        |t        j0                  «      r|j3                  «        yt        |t        j4                  «      r#t        j                  |j
                  dd¬«       yt        |t6        «      r÷|j8                  j;                  «       D ]^  }t        |t        j                  «      sŒt        j<                  |j
                  d¬«       t        j>                  |j                  d«       Œ` |j@                  j;                  «       D ]^  }t        |t        j                  «      sŒt        j<                  |j
                  d¬«       t        j>                  |j                  d«       Œ` yt        |tB        «      r’t        jD                  |jF                  tI        jJ                  d	g«      «       t        j                  |jL                  «       t        j                  |jN                  «       t        j                  |jP                  «       yy)
zInitialize the weightsrª   )ÚmeanÚstdNr   )ÚaÚbÚSnake1dg{®Gáz”?)rÂ   T))Ú
isinstancer3   ÚLinearÚinitÚnormal_Úweightr'   Úinitializer_ranger/   Úzeros_Ú	LayerNormÚ	GroupNormÚones_r7   Úkaiming_normal_r¦   Úsqrtr.   r(   r0   Úuniform_r;   r   Úalpharf   Úreset_parametersÚ	EmbeddingÚXcodecModelÚacoustic_encoderÚmodulesÚtrunc_normal_Ú	constant_Úacoustic_decoderrn   Úcopy_rp   r   rC   rq   rr   rs   )r:   ÚmoduleÚkÚ	submodules       r    Ú_init_weightsz#XcodecPreTrainedModel._init_weightsR  sv  € ô �fœbŸi™iÔ(Ü�L‰L˜Ÿ™¨S°d·k±k×6SÑ6SÕTØ�{‰{Ð&Ü—‘˜FŸK™KÕ(ð 'ä˜¤§¡¬r¯|©|Ð <Ô=Ü�K‰K˜Ÿ™Ô$Ü�J‰J�v—}‘}Õ%Ü˜¤§	¡	Ô*Ü× Ñ  §¡Ô/Ø�{‰{Ð&Ü—I‘I˜fŸm™m¨v×/AÑ/AÀF×DVÑDVÐWXÑDYÑ/YÑZÓ[�Ü—‘˜fŸk™k¨a¨R°1Ö5ð 'ð ×Ñ×&Ñ&¨)Ò3Ü�J‰J�v—|‘|Õ$Ü˜¤× 2Ñ 2Ô3Ø×#Ñ#Õ%Ü˜¤§¡Ô-Ü�L‰L˜Ÿ™¨S°dÖ;Ü˜¤Ô,ð $×4Ñ4×<Ñ<Ó>ò 6�	Ü˜i¬¯©Õ3Ü×&Ñ& y×'7Ñ'7¸TÕBÜ—N‘N 9§>¡>°1Õ5ð6ð $×4Ñ4×<Ñ<Ó>ò 6�	Ü˜i¬¯©Õ3Ü×&Ñ& y×'7Ñ'7¸TÕBÜ—N‘N 9§>¡>°1Õ5ñ6ô ˜Ô 7Ô8Ü�J‰J�v—}‘}¤e§l¡l°D°6Ó&:Ô;Ü�K‰K˜×+Ñ+Ô,Ü�K‰K˜Ÿ™Ô%Ü�K‰K˜×(Ñ(Õ)ð	 9r   c                 ó8  — t         j                  j                  j                  j                  } || j
                  j                  «        || j
                  j                  «       | j
                  j                  D ]`  } ||j                  «       |j                  |j                  |j                  fD ]&  } ||j                  «        ||j                  «       Œ( Œb  || j                  j                  d¬«        || j                  j                  d¬«       | j                  j                  D ]f  } ||j                  d¬«       |j                  |j                  |j                  fD ]*  } ||j                  d¬«        ||j                  d¬«       Œ, Œh y)znApply weight norm in the acoustic encoder and decoder because the original checkpoint has weight norm applied.rÊ   ©ÚnameN)r   r3   ÚutilsÚparametrizationsÚweight_normr×   r8   r9   ra   Ú	res_unit1Ú	res_unit2Ú	res_unit3rÛ   Úconv_t1)r:   ræ   ra   Úres_units       r    Úapply_weight_normz'XcodecPreTrainedModel.apply_weight_normx  s9  € ä—h‘h—n‘n×5Ñ5×AÑAˆá�D×)Ñ)×/Ñ/Ô0Ù�D×)Ñ)×/Ñ/Ô0à×*Ñ*×0Ñ0ò 	,ˆEÙ˜Ÿ™Ô$Ø"Ÿ_™_¨e¯o©o¸u¿¹ÐOò ,�Ù˜HŸN™NÔ+Ù˜HŸN™NÕ+ñ,ð	,ñ 	�D×)Ñ)×/Ñ/°hÕ?Ù�D×)Ñ)×/Ñ/°hÕ?à×*Ñ*×0Ñ0ò 	;ˆEÙ˜Ÿ™¨HÕ5Ø"Ÿ_™_¨e¯o©o¸u¿¹ÐOò ;�Ù˜HŸN™N°Õ:Ù˜HŸN™N°Ö:ñ;ñ	;r   c                 óŽ  — | j                   | j                  fD ]•  }|j                  «       D ]€  }	 t        j                  j
                  j                  |d¬«       t        |d«      sŒ<d|j                  v sŒKt        j                  j
                  j                  j                  |dd¬«       Œ‚ Œ— y# t        t        f$ r Y Œhw xY w)z=Remove the weight norm from the acoustic encoder and decoder.rÊ   râ   rå   T)Úleave_parametrizedN)r×   rÛ   rØ   r   r3   rä   Úremove_weight_normrZ   ÚAttributeErrorÚhasattrrå   ÚparametrizeÚremove_parametrizations)r:   rÝ   Úms      r    rï   z(XcodecPreTrainedModel.remove_weight_normŽ  s³   € à×,Ñ,¨d×.CÑ.CÐDò 	mˆFØ—^‘^Ó%ò m�ðÜ—H‘H—N‘N×5Ñ5°a¸hÐ5ÔGô ˜1Ð0Õ1°hÀ!×BTÑBTÒ6TÜ—H‘H—N‘N×.Ñ.×FÑFÀqÈ(ÐgkÐFÕlñmñ	møô #¤NÐ3ò Ùðús   °+B2Â2CÃCc                 óR   ‡— dt         j                  fˆfd„Št         ‰|«      «      S )zA
        Recursively iterate to fetch all Conv1d layers.
        rÝ   c                 óº   •— g }t        | t        j                  «      r|j                  | «       | j	                  «       D ]  }|j                   ‰|«      «       Œ |S r?   )rÆ   r3   r7   r±   ÚchildrenÚextend)rÝ   Úparams_listÚchildÚget_conv1d_layers_recursives      €r    rû   zMXcodecPreTrainedModel._get_conv1d_layers.<locals>.get_conv1d_layers_recursiveŸ  sZ   ø€ ØˆKä˜&¤"§)¡)Ô,Ø×"Ñ" 6Ô*ð  Ÿ™Ó*ò G�Ø×"Ñ"Ñ#>¸uÓ#EÕFðGð Ðr   )r3   ÚModuleÚtuple)r:   rÝ   rû   s     @r    Ú_get_conv1d_layersz(XcodecPreTrainedModel._get_conv1d_layers™  s&   ø€ ð
	´·	±	õ 
	ô Ñ0°Ó8Ó9Ð9r   Nc                 óV   — |€| }| j                  |«      }|D ]  }t        ||«      }Œ |S )zo
        For a given module, compute the output length that would be obtained after all Conv1d layers.
        )rþ   r   )r:   Úinput_lengthrÝ   Úconv1d_layersÚlayers        r    Ú_get_conv1d_output_lengthsz0XcodecPreTrainedModel._get_conv1d_output_lengths­  sC   € ð ˆ>ØˆFà×/Ñ/°Ó7ˆà"ò 	EˆEÜ/°°|ÓD‰Lð	Eð Ðr   r?   )r   r   r   r   r   Úconfig_classÚbase_model_prefixÚmain_input_nameÚinput_modalitiesÚ_no_split_modulesr   Úno_gradrà   rì   rï   r   rþ   r  r   r   r    r¼   r¼   E  sg   „ ñð
  €LØ ÐØ$€OØÐØ;Ð<Ðà€U‡]�]ƒ_ñ#*ó ð#*òJ;ò,	mð ñ:ó ð:ô&r   r¼   z$The Xcodec neural audio codec model.)Úcustom_introc                   óà  ‡ — e Zd Zˆ fd„Zedej                  fd„«       Zdej                  dej                  fd„Z
e	 	 ddej                  dedz  d	edz  dej                  ez  fd
„«       Ze	 ddej                  d	edz  dej                  ez  fd„«       Zee	 	 ddej                  dej                  dz  dedz  dee   deej                  ej                  f   ez  f
d„«       «       Zˆ xZS )rÖ   c                 ó8  •— t         ‰| �  |«       || _        |j                  dz  | _        t        j                  |j                  «      }|j                  | _	        |j                  | _        | j                  | j                  «       t        |«      | _        t        |«      | _        t        j                  |j"                  «      j%                  «       | _        t)        j*                  |j,                  |j,                  «      | _        t)        j*                  |j,                  |j"                  j,                  «      | _        t)        j*                  |j,                  |j                  j,                  «      | _        t5        |«      | _        | j9                  «        y )Nr   )r1   r2   r'   Ú
hop_lengthÚpadr   Úfrom_configÚacoustic_model_configÚencoderr×   ÚdecoderrÛ   Ú_adjust_dac_decoderrT   Úencoder_semanticrj   Údecoder_semanticÚsemantic_model_configÚevalÚsemantic_modelr3   rÇ   Úhidden_sizeÚfcÚfc1Úfc2rž   rµ   Ú	post_init)r:   r'   Úacoustic_modelr;   s      €r    r2   zXcodecModel.__init__¾  s)  ø€ Ü‰Ñ˜Ô ØˆŒØ×$Ñ$¨Ñ)ˆŒÜ"×.Ñ.¨v×/KÑ/KÓLˆØ .× 6Ñ 6ˆÔØ .× 6Ñ 6ˆÔØ× Ñ  ×!6Ñ!6Ô7Ü /°Ó 7ˆÔÜ /°Ó 7ˆÔÜ'×3Ñ3°F×4PÑ4PÓQ×VÑVÓXˆÔÜ—)‘)˜F×.Ñ.°×0BÑ0BÓCˆŒÜ—9‘9˜V×/Ñ/°×1MÑ1M×1YÑ1YÓZˆŒÜ—9‘9˜V×/Ñ/°×1MÑ1M×1YÑ1YÓZˆŒÜ9¸&ÓAˆŒð 	�‰Õr   r  c                 óz  — | j                  «       D ]]  }t        |t        j                  «      sŒt        |j                  t
        «      r|j                  d   n|j                  }|dz  f|_        Œ_ t        | d«      r?t        | j                  t        j                  «      rt        j                  «       | _        yyy)zì
        DAC implemented in Xcodec is slightly different from the HF version.
        DAC in Xcodec adjusts the output padding in every ConvTranspose1d in the decoder and removes
        the final `nn.Tanh` activation function.
        r   r   ÚtanhN)rØ   rÆ   r3   rf   r,   rý   rg   rñ   r   ÚTanhÚIdentity)r  rÝ   r,   s      r    r  zXcodecModel._adjust_dac_decoderÑ  s�   € ð —o‘oÓ'ò 	6ˆFÜ˜&¤"×"4Ñ"4Õ5Ü-7¸¿¹ÄuÔ-M˜Ÿ™ qÒ)ÐSY×S`ÑS`�Ø)/°!©¨�Õ%ð	6ô �7˜FÔ#¬
°7·<±<ÄÇÁÔ(IÜŸ;™;›=ˆG�Lð )JÐ#r   r¾   r=   c                 óT  — |d d …dd d …f   }t        j                  || j                  | j                  f«      }t        j                  «       5  | j	                  |d¬«      }|j
                  }d d d «       t        j                  d¬«      }|j                  d¬«      S # 1 sw Y   Œ2xY w)Nr   T)Úoutput_hidden_statesr   r|   )rŽ   r  r   r	  r  rƒ   r²   rÁ   )r:   r¾   Úoutputsrƒ   Ústackeds        r    Ú_extract_semantic_featuresz&XcodecModel._extract_semantic_featuresß  s�   € Ø#¢A qª! GÑ,ˆÜ—u‘u˜\¨D¯H©H°d·h±hÐ+?Ó@ˆÜ�]‰]‹_ñ 	2Ø×)Ñ)¨,ÈTÐ)ÓRˆGØ#×1Ñ1ˆM÷	2ô —+‘+˜m°Ô3ˆØ�|‰| ˆ|Ó"Ð"÷	2ð 	2ús   Á BÂB'Nr¬   Úreturn_dictc                 óú  — |�|n| j                   j                  }|j                  d   }|dk7  rt        d|› �«      ‚|€| j                   j                  d   }n>|| j                   j                  vr&t        d|› d| j                   j                  › d�«      ‚| j                  |«      j                  «       }| j                  |j                  dd«      «      }| j                  |j                  d   | j                  «      |j                  d   k7  r<| j                  t        j                  || j                  | j                  f«      «      }n| j                  |«      }t        j                  |j                  |j                   «      |gd¬«      }| j#                  |j                  dd«      «      j                  dd«      }| j$                  j'                  ||«      }	|	j                  d	d«      }	|s|	S t)        |	«      S )
ac  
        input_values (`torch.FloatTensor` of shape `(batch_size, channels, num_samples)`):
            Float values of the input audio waveform.
        bandwidth (`float`, *optional*):
            The target bandwidth in (kbps) supports only values in `config.target_bandwidths`.
            Defaults to the highest available bandwidth `4.0` kbps.
        return_dict (`bool`, *optional*):
            Whether or not to return a [`~utils.ModelOutput`].

        Returns:
            `torch.LongTensor` of shape `(batch_size, num_quantizers, codes_length)` containing the discrete encoded audio codes.
        r   zAudio must be mono, but got r{   z)This model doesn't support the bandwidth z. Select one of ú.r   r|   r   )r'   r(  r‰   rZ   Útarget_bandwidthsr'  Údetachr  Ú	transposer  r×   rŽ   r  r   Úcatr�   r‘   r  rµ   rŒ   r"   )
r:   r¾   r¬   r(  ÚchannelsÚe_semantic_inputÚ
e_semanticÚ
e_acousticr¯   r   s
             r    rŒ   zXcodecModel.encodeé  sÏ  € ð& &1Ð%<‘kÀ$Ç+Á+×BYÑBYˆà×%Ñ% aÑ(ˆØ�qŠ=ÜÐ;¸H¸:ÐFÓGÐGàÐØŸ™×5Ñ5°bÑ9‰IØ˜dŸk™k×;Ñ;Ñ;ÜØ;¸I¸;ÐFVÐW[×WbÑWb×WtÑWtÐVuÐuvÐwóð ð  ×:Ñ:¸<ÓH×OÑOÓQÐØ×*Ñ*Ð+;×+EÑ+EÀaÈÓ+KÓLˆ
ð ×*Ñ*¨<×+=Ñ+=¸aÑ+@À$×BWÑBWÓXÐ\f×\lÑ\lÐmnÑ\oÒoØ×.Ñ.¬q¯u©u°\ÀDÇHÁHÈdÏhÉhÐCWÓ/XÓY‰Jà×.Ñ.¨|Ó<ˆJä—Y‘Y 
§¡¨j×.?Ñ.?Ó @À*ÐMÐSTÔUˆ
Ø—W‘W˜Z×1Ñ1°!°QÓ7Ó8×BÑBÀ1ÀaÓHˆ
Ø—n‘n×+Ñ+¨J¸	ÓBˆØ!×+Ñ+¨A¨qÓ1ˆáØÐä" ;Ó/Ð/r   r   c                 ó2  — |�|n| j                   j                  }|j                  dd«      }| j                  j	                  |«      }| j                  |j                  dd«      «      j                  dd«      }| j                  |«      }|s|S t        |«      S )a¬  
        audio_codes (`torch.LongTensor`  of shape `(batch_size, num_quantizers, codes_length)`):
            Discrete code indices computed using `model.encode`.
        return_dict (`bool`, *optional*):
            Whether or not to return a [`~utils.ModelOutput`]

        Returns:
            Decoded audio values of shape `(batch_size, channels, num_samples)` obtained using the decoder part of
            Xcodec.
        r   r   r   )r'   r(  r-  rµ   r“   r  rÛ   r$   )r:   r   r(  r’   Úquantized_acousticr   s         r    r“   zXcodecModel.decode  sŽ   € ð  &1Ð%<‘kÀ$Ç+Á+×BYÑBYˆà!×+Ñ+¨A¨qÓ1ˆØ—N‘N×)Ñ)¨+Ó6ˆ	Ø!ŸX™X i×&9Ñ&9¸!¸QÓ&?Ó@×JÑJÈ1ÈaÓPÐØ×,Ñ,Ð-?Ó@ˆáØÐä" <Ó0Ð0r   Úkwargsc                 ó    — |j                   d   }|€| j                  ||d¬«      }| j                  |d¬«      d   dd|…f   }t        ||¬«      S )	a+  
        input_values (`torch.FloatTensor` of shape `(batch_size, channels, num_samples)`):
            The raw float values of the input audio waveform.
        audio_codes (`torch.LongTensor`  of shape `(batch_size, num_quantizers, codes_length)`:
            Discrete code indices computed using `model.encode`.
        bandwidth (`float`, *optional*):
            Target bandwidth in kbps. Must be one of `config.target_bandwidths`. Defaults to the highest available bandwidth.
        bandwidth (`float`, *optional*):
            Target bandwidth in kbps. Must be one of `config.target_bandwidths`. Defaults to the highest available bandwidth.

        Returns:
            `XcodecOutput` or tuple `(audio_codes, audio_values)`:
            - `audio_codes` of shape `(batch_size, num_quantizers, codes_length)`: the quantized discrete codes.
            - `audio_values` of shape `(batch_size, channels, num_samples)`: the reconstructed audio waveform given the codes.

        Example:

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

        >>> model_id = "hf-audio/xcodec-hubert-librispeech"
        >>> model = XcodecModel.from_pretrained(model_id)
        >>> feature_extractor = AutoFeatureExtractor.from_pretrained(model_id)

        >>> dataset = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
        >>> dataset = dataset.cast_column("audio", Audio(sampling_rate=feature_extractor.sampling_rate))
        >>> audio_sample = dataset[0]['audio']['array']

        >>> inputs = feature_extractor(raw_audio=audio_sample, return_tensors="pt")

        >>> outputs = model(**inputs)
        >>> audio_codes = outputs.audio_codes
        >>> audio_values = outputs.audio_values
        ```
        r{   NF)r(  Tr   .)r   r   )r‰   rŒ   r“   r   )r:   r¾   r   r¬   r5  Úlengthr   s          r    rA   zXcodecModel.forward9  s`   € ðZ ×#Ñ# BÑ'ˆàÐØŸ+™+ l°IÈ5˜+ÓQˆKà—{‘{ ;¸D�{ÓAÀ!ÑDÀSÈ'È6È'À\ÑRˆä¨À,ÔOÐOr   )NNr?   )r   r   r   r2   Ústaticmethodr3   rü   r  r   r   r'  r   rC   ÚfloatÚboolr"   rŒ   r$   r“   r   r	   r   rý   r   rA   rD   rE   s   @r    rÖ   rÖ   ¼  so  ø„ ôð& ð) R§Y¡Yò )ó ð)ð#°u×7HÑ7Hð #ÈU×M^ÑM^ó #ð ð #'Ø#'ñ	10à—l‘lð10ð ˜4‘<ð10ð ˜D‘[ð	10ð
 
�‰Ð+Ñ	+ò10ó ð10ðf ð $(ñ1à—\‘\ð1ð ˜D‘[ð1ð 
�‰Ð+Ñ	+ò	1ó ð1ð6 Øð ,0Ø"&ñ	2Pà—l‘lð2Pð —\‘\ DÑ(ð2Pð ˜4‘<ð	2Pð
 Ð+Ñ,ð2Pð 
ˆu�|‰|˜UŸ\™\Ð)Ñ	*¨\Ñ	9ò2Pó ó ô2Pr   rÖ   )-r   r¦   Údataclassesr   Ú	functoolsr   r   Útorch.nnr3   Útorch.nn.functionalÚ
functionalrŽ   Ú r   rÈ   Úaudio_utilsr   Úmodeling_utilsr   Úprocessing_utilsr	   rä   r
   r   r   r   Úautor   Úconfiguration_xcodecr   r   r"   r$   rü   r&   rG   rT   rd   rj   rn   r•   rž   r¼   rÖ   Ú__all__r   r   r    ú<module>rG     sh  ðñ !ã Ý !Ý ã Ý ß Ð å &Ý /Ý :Ý &÷ó õ Ý .ð ô
2�;ó 
2ó ð
2ð ô0˜+ó 0ó ð0ð ô2˜+ó 2ó ð2ô,˜Ÿ™ô ,ô6 §¡ô ô&�b—i‘iô ô<˜2Ÿ9™9ô ô>%�b—i‘iô %ôP˜bŸi™iô ô@˜rŸy™yô ô,/ r§y¡yô /ðd ôsÐ8ó só ðsñl ÐGÔHôpPÐ'ó pPó IðpPðf Ð1Ð
2�r   