Ë
    ÜÓ^jE
 ã                   óD  — d Z 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m	Z	 ddl
mZ dd	lmZ dd
lmZmZ ddlmZ ddlmZ 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(  e$jR                  e*«      Z+e#e G d„ de!«      «       «       Z, G d„ d«      Z-e#e G d„ de!«      «       «       Z.e#e G d„ de!«      «       «       Z/ G d„ de	j`                  «      Z1 G d„ d e	j`                  «      Z2 G d!„ d"e	j`                  «      Z3 G d#„ d$e	j`                  «      Z4 G d%„ d&e	j`                  «      Z5 G d'„ d(e	j`                  «      Z6d)„ Z7dPd*„Z8 G d+„ d,e	j`                  «      Z9d-ejt                  d.e;d/ejt                  fd0„Z<	 dQd1e	j`                  d2ejt                  d3ejt                  d4ejt                  d5ejt                  dz  d6e=d7e=d8ee"   fd9„Z> G d:„ d;e	j`                  «      Z? G d<„ d=e«      Z@ G d>„ d?e	j`                  «      ZA G d@„ dAe	j`                  «      ZB G dB„ dCe	j`                  «      ZC G dD„ dEe	j`                  «      ZD G dF„ dGe	j`                  «      ZE G dH„ dIe	j`                  «      ZFe# G dJ„ dKe«      «       ZG e#dL¬M«       G dN„ dOeG«      «       ZHdOdKgZIy)RzPyTorch Mimi model.é    N)ÚCallable)Ú	dataclass)ÚOptional)Únné   )Úinitialization)ÚACT2FN)ÚCacheÚDynamicCache)Ú!create_sliding_window_causal_mask)ÚGradientCheckpointingLayer)ÚBaseModelOutputWithPast)ÚROPE_INIT_FUNCTIONSÚdynamic_rope_update)ÚALL_ATTENTION_FUNCTIONSÚPreTrainedModel)ÚUnpack)ÚModelOutputÚTransformersKwargsÚauto_docstringÚlogging)Úmaybe_autocasté   )Ú
MimiConfigc                   óŠ   — e Zd ZU dZdZej                  dz  ed<   dZej                  dz  ed<   dZ
edz  ed<   dZedz  ed<   y)Ú
MimiOutputaV  
    audio_codes (`torch.LongTensor`  of shape `(batch_size, num_quantizers, codes_length)`, *optional*):
        Discrete code embeddings computed using `model.encode`.
    audio_values (`torch.FloatTensor` of shape `(batch_size, sequence_length)`, *optional*):
        Decoded audio values, obtained using the decoder part of Mimi.
    encoder_past_key_values (`Cache`, *optional*):
        Pre-computed hidden-states (key and values in the self-attention blocks) that can be used to speed up sequential decoding of the encoder transformer.
        This typically consists in the `past_key_values` returned by the model at a previous stage of decoding, when `use_cache=True` or `config.use_cache=True`.

        The model will output the same cache format that is fed as input.

        If `past_key_values` are used, the user can optionally input only the last `audio_values` or `audio_codes (those that don't
        have their past key value states given to this model).
    decoder_past_key_values (`Cache`, *optional*):
        Pre-computed hidden-states (key and values in the self-attention blocks) that can be used to speed up sequential decoding of the decoder transformer.
        This typically consists in the `past_key_values` returned by the model at a previous stage of decoding, when `use_cache=True` or `config.use_cache=True`.

        The model will output the same cache format that is fed as input.

        If `past_key_values` are used, the user can optionally input only the last `audio_values` or `audio_codes (those that don't
        have their past key value states given to this model).
    NÚaudio_codesÚaudio_valuesÚencoder_past_key_valuesÚdecoder_past_key_values)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r   ÚtorchÚ
LongTensorÚ__annotations__r   ÚFloatTensorr   r
   r    © ó    úq/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/transformers/models/mimi/modeling_mimi.pyr   r   )   sQ   … ñð. ,0€K�×!Ñ! DÑ(Ó/Ø-1€L�%×#Ñ# dÑ*Ó1Ø,0Ð˜U T™\Ó0Ø,0Ð˜U T™\Ô0r*   r   c            	       ó‚   — e Zd ZdZdedee   dee   dee   fd„Zdej                  defd	„Z
dej                  defd
„Zy)ÚMimiConv1dPaddingCachea�  
    Padding cache for MimiConv1d causal convolutions in order to support streaming via cache padding.
    See: https://huggingface.co/papers/2005.06720 & https://huggingface.co/papers/2204.07064

    A padding cache is a list of cached partial hidden states for each convolution layer.
    Hidden states are cached from the previous call to the MimiConv1d forward pass, given the padding size.
    Ú
num_layersÚper_layer_paddingÚper_layer_padding_modeÚper_layer_in_channelsc                 óä   — t        |«      t        |«      t        |«      h}t        |«      dk7  s|j                  «       |k7  rt        d|› d�«      ‚|| _        || _        || _        d g|z  | _        y )Nr   zExpected `num_layers` (zU) values in `per_layer_padding`, `per_layer_padding_mode` and `per_layer_in_channels`)ÚlenÚpopÚ
ValueErrorr/   r0   r1   Úpadding_cache)Úselfr.   r/   r0   r1   Úfrom_args_num_layerss         r+   Ú__init__zMimiConv1dPaddingCache.__init__R   sŒ   € ô !$Ð$5Ó 6¼Ð<RÓ8SÔUXÐYnÓUoÐpÐäÐ#Ó$¨Ò)Ð-A×-EÑ-EÓ-GÈ:Ò-UÜØ)¨*¨ð  6Kð  Lóð ð "3ˆÔØ&<ˆÔ#Ø%:ˆÔ"à"˜V jÑ0ˆÕr*   Úhidden_statesÚ	layer_idxc                 ó`  — |j                   d   |j                  |j                  }}}| j                  |   | j                  |   | j
                  |   }}}|dk(  rt        j                  |||||¬«      }	|	S |dk(  r&t        j                  |||||¬«      |ddd…f   z  }	|	S t        d|› d	�«      ‚)
ad  
        Initialize the cache for a specific layer.

        Parameters:
            hidden_states (`torch.Tensor`):
                The hidden states to initialize the cache with.
            layer_idx (`int`):
                The index of the layer to initialize the cache for.
        Returns:
            `torch.Tensor`, the initialized cache.
        r   Úconstant©ÚdeviceÚdtypeÚ	replicate.Nr   zPadding mode z not supported)
Úshaper@   r?   r/   r0   r1   r%   ÚzerosÚonesÚNotImplementedError)
r7   r:   r;   Ú
batch_sizer@   r?   ÚpaddingÚpadding_modeÚin_channelsÚcurrent_caches
             r+   Ú_cache_initz"MimiConv1dPaddingCache._cache_initg   sà   € ð %2×$7Ñ$7¸Ñ$:¸M×<OÑ<OÐQ^×QeÑQe˜6�Eˆ
à×"Ñ" 9Ñ-Ø×'Ñ'¨	Ñ2Ø×&Ñ& yÑ1ð  +�ˆð ˜:Ò%Ü!ŸK™K¨
°KÀÐQWÐ_dÔeˆMð Ðð ˜[Ò(ä—
‘
˜: {°GÀFÐRWÔXÐ[hÐilÐnpÐopÐnpÐipÑ[qÑqð ð Ðô &¨°l°^À>Ð&RÓSÐSr*   c                 óþ  — |j                   d   |j                  |j                  }}}| j                  |   | j                  |   }}| j
                  |   €| j                  ||«      }n| j
                  |   }|dkD  rXt        d||j                   d   z
  «      }	|	dkD  r't        j                  |dd…dd…|	 d…f   |gd¬«      }
n*|dd…dd…| d…f   }
nt        j                  ||d||¬«      }
|
| j
                  |<   |S )a¬  
        Updates the padding cache with the new padding states for the layer `layer_idx` and returns the current cache.

        Parameters:
            hidden_states (`torch.Tensor`):
                The hidden states to be partially cached.
            layer_idx (`int`):
                The index of the layer to cache the states for.
        Returns:
            `torch.Tensor` or `None`, the current padding cache.
        r   Néÿÿÿÿ©Údim)r@   r?   )rB   r@   r?   r/   r1   r6   rK   Úmaxr%   ÚcatÚempty)r7   r:   r;   rF   r@   r?   rG   rI   rJ   Ú	shortfallÚpadding_statess              r+   ÚupdatezMimiConv1dPaddingCache.update…   s  € ð %2×$7Ñ$7¸Ñ$:¸M×<OÑ<OÐQ^×QeÑQe˜6�Eˆ
Ø#×5Ñ5°iÑ@À$×B\ÑB\Ð]fÑBg�ˆà×Ñ˜iÑ(Ð0Ø ×,Ñ,¨]¸IÓF‰Mà ×.Ñ.¨yÑ9ˆMð �QŠ;Ü˜A˜w¨×)<Ñ)<¸RÑ)@Ñ@ÓAˆIØ˜1Š}Ü!&§¡¨Mº!ºQÀÀ
ÁÐ:KÑ,LÈmÐ+\ÐbdÔ!e‘à!.ªq²!°g°X±Y¨Ñ!?‘ä"Ÿ[™[¨°[À!È5ÐY_Ô`ˆNà(6ˆ×Ñ˜9Ñ%ØÐr*   N)r!   r"   r#   r$   ÚintÚlistÚstrr9   r%   ÚTensorrK   rU   r)   r*   r+   r-   r-   I   sl   „ ñð1àð1ð   ™9ð1ð !% S¡	ð	1ð
  $ C™yó1ð*¨¯©ð À#ó ð< E§L¡Lð ¸Sô r*   r-   c                   ób   — e Zd ZU dZdZej                  dz  ed<   dZe	dz  ed<   dZ
edz  ed<   y)ÚMimiEncoderOutputaÔ  
    audio_codes (`torch.LongTensor`  of shape `(batch_size, num_quantizers, codes_length)`, *optional*):
        Discrete code embeddings computed using `model.encode`.
    encoder_past_key_values (`Cache`, *optional*):
        Pre-computed hidden-states (key and values in the self-attention blocks) that can be used to speed up sequential decoding of the encoder transformer.
        This typically consists in the `past_key_values` returned by the model at a previous stage of decoding, when `use_cache=True` or `config.use_cache=True`.

        The model will output the same cache format that is fed as input.

        If `past_key_values` are used, the user can optionally input only the last `audio_values` or `audio_codes (those that don't
        have their past key value states given to this model).
    padding_cache (`MimiConv1dPaddingCache`, *optional*):
        Padding cache for MimiConv1d causal convolutions in order to support streaming via cache padding.
    Nr   r   r6   )r!   r"   r#   r$   r   r%   r&   r'   r   r
   r6   r-   r)   r*   r+   r[   r[   §   s=   … ñð ,0€K�×!Ñ! DÑ(Ó/Ø,0Ð˜U T™\Ó0Ø37€MÐ)¨DÑ0Ô7r*   r[   c                   óN   — e Zd ZU dZdZej                  dz  ed<   dZe	dz  ed<   y)ÚMimiDecoderOutputa+  
    audio_values (`torch.FloatTensor`  of shape `(batch_size, segment_length)`, *optional*):
        Decoded audio values, obtained using the decoder part of Mimi.
    decoder_past_key_values (`Cache`, *optional*):
        Pre-computed hidden-states (key and values in the self-attention blocks) that can be used to speed up sequential decoding of the decoder transformer.
        This typically consists in the `past_key_values` returned by the model at a previous stage of decoding, when `use_cache=True` or `config.use_cache=True`.

        The model will output the same cache format that is fed as input.

        If `past_key_values` are used, the user can optionally input only the last `audio_values` or `audio_codes (those that don't
        have their past key value states given to this model).
    Nr   r    )
r!   r"   r#   r$   r   r%   r(   r'   r    r
   r)   r*   r+   r]   r]   ¾   s-   … ñð .2€L�%×#Ñ# dÑ*Ó1Ø,0Ð˜U T™\Ô0r*   r]   c                   ó(  ‡ — e Zd ZdZ	 	 	 	 	 	 ddedededededed	edz  d
ededz  fˆ fd„Zd„ Zd„ Z	de
j                  de
j                  fd„Zedde
j                  deeef   dedefd„«       Zde
j"                  de
j"                  fd„Zdd„Zˆ xZS )Ú
MimiConv1dz;Conv1d with asymmetric or causal padding and normalization.NrI   Úout_channelsÚkernel_sizeÚstrideÚdilationÚgroupsÚpad_modeÚbiasr;   c           	      ó8  •— t         ‰| �  «        |j                  | _        |€|j                  n|| _        |
| _        || _        |dkD  r$|dkD  rt        j                  d|› d|› d|› d�«       t        j                  |||||||	¬«      | _        | j                  j                  d   }t        j                  | j                  j                  d   t        j                   ¬«      }| j                  j"                  d   }t        j                  |dz
  |z  dz   t        j                   ¬«      }| j%                  d	|d
¬«       | j%                  d|d
¬«       | j%                  d||z
  d
¬«       | j&                  dz  | _        | j&                  | j(                  z
  | _        y )Nr   zNMimiConv1d has been initialized with stride > 1 and dilation > 1 (kernel_size=z stride=z, dilation=ú).)rc   rd   rf   r   ©r@   rb   F©Ú
persistentra   Úpadding_totalé   )Úsuperr9   Úuse_causal_convÚcausalre   r;   rI   ÚloggerÚwarningr   ÚConv1dÚconvra   r%   Útensorrb   Úint64rc   Úregister_bufferrl   Úpadding_rightÚpadding_left)r7   ÚconfigrI   r`   ra   rb   rc   rd   re   rf   r;   Ú	__class__s              €r+   r9   zMimiConv1d.__init__Õ   s~  ø€ ô 	‰ÑÔØ×,Ñ,ˆŒØ+3Ð+;˜ŸšÀˆŒØ"ˆŒØ&ˆÔð �AŠ:˜( Qš,Ü�N‰Nð!Ø!, ¨X°f°X¸[ÈÈ
ÐRTðVôô
 —I‘IØ˜ {°FÀXÐV\Ðcgô
ˆŒ	ð —i‘i×+Ñ+¨AÑ.ˆÜ—‘˜dŸi™i×.Ñ.¨qÑ1¼¿¹ÔEˆØ—9‘9×%Ñ% aÑ(ˆô —l‘l K°!¡O°xÑ#?À!Ñ#CÌ5Ï;É;ÔWˆà×Ñ˜X v¸%ÐÔ@Ø×Ñ˜]¨KÀEÐÔJØ×Ñ˜_¨k¸FÑ.BÈuÐÔUð "×/Ñ/°1Ñ4ˆÔØ ×.Ñ.°×1CÑ1CÑCˆÕr*   c                 óì   — t         j                  j                  }t        t         j                  j                  d«      r$t         j                  j                  j                  } || j
                  «       y ©NÚweight_norm©r   Úutilsr~   ÚhasattrÚparametrizationsrt   ©r7   r~   s     r+   Úapply_weight_normzMimiConv1d.apply_weight_norm  óF   € Ü—h‘h×*Ñ*ˆÜ”2—8‘8×,Ñ,¨mÔ<ÜŸ(™(×3Ñ3×?Ñ?ˆKá�D—I‘IÕr*   c                 óV   — t         j                  j                  | j                  «       y ©N©r   r€   Úremove_weight_normrt   ©r7   s    r+   r‰   zMimiConv1d.remove_weight_norm	  ó   € Ü
�‰×#Ñ# D§I¡IÕ.r*   r:   Úreturnc                 ó>  — |j                   d   }|| j                  z
  | j                  z   | j                  z  dz   }t	        j
                  |«      j                  t        j                  «      dz
  }|| j                  z  | j                  z   | j                  z
  }||z
  S )zSee `pad_for_conv1d`.rM   r   )rB   ra   rl   rb   r%   ÚceilÚtorv   )r7   r:   ÚlengthÚn_framesÚideal_lengths        r+   Ú_get_extra_padding_for_conv1dz(MimiConv1d._get_extra_padding_for_conv1d  s�   € ð
 ×$Ñ$ RÑ(ˆØ˜T×-Ñ-Ñ-°×0BÑ0BÑBÀdÇkÁkÑQÐTUÑUˆÜ—:‘:˜hÓ'×*Ñ*¬5¯;©;Ó7¸!Ñ;ˆØ $§+¡+Ñ-°×0@Ñ0@Ñ@À4×CUÑCUÑUˆà˜fÑ$Ð$r*   ÚpaddingsÚmodeÚvaluec                 ól  — | j                   d   }|\  }}|dk7  r"t        j                  j                  | |||«      S t	        ||«      }d}||k  r*||z
  dz   }t        j                  j                  | d|f«      } t        j                  j                  | |||«      }	|	j                   d   |z
  }
|	dd|
…f   S )zÊTiny wrapper around torch.nn.functional.pad, just to allow for reflect padding on small input.
        If this is the case, we insert extra 0 padding to the right before the reflection happens.
        rM   Úreflectr   r   .N)rB   r   Ú
functionalÚpadrP   )r:   r”   r•   r–   r�   ry   rx   Úmax_padÚ	extra_padÚpaddedÚends              r+   Ú_pad1dzMimiConv1d._pad1d  sÃ   € ð ×$Ñ$ RÑ(ˆØ&.Ñ#ˆ�mØ�9ÒÜ—=‘=×$Ñ$ ]°H¸dÀEÓJÐJä�l MÓ2ˆØˆ	Ø�WÒØ &Ñ(¨1Ñ,ˆIÜŸM™M×-Ñ-¨m¸aÀ¸^ÓLˆMÜ—‘×"Ñ" =°(¸DÀ%ÓHˆØ�l‰l˜2Ñ Ñ*ˆØ�c˜4˜C˜4�iÑ Ð r*   Úinput_lengthc                 óŒ  — || j                   z
  | j                  z   | j                  z  dz   }t        j                  |«      j                  t        j                  «      dz
  }|| j                  z  | j                   z   | j                  z
  }||z
  }| j                  r| j                  }|}n| j                  }| j                  |z   }||z   |z   }|d| j                  j                  d   z  z   | j                  j                  d   | j                  j                   d   dz
  z  z
  dz
  | j                  j                  d   z  dz   }|S )zD
        Return the length of the output of the MimiConv1d.
        r   rm   r   )ra   rl   rb   r%   rŽ   r�   rv   rp   ry   rx   rt   rG   rc   )r7   r    r‘   r’   Úextra_paddingry   rx   Úoutput_lengths           r+   Ú_get_output_lengthzMimiConv1d._get_output_length-  s=  € ð
 ! 4×#3Ñ#3Ñ3°d×6HÑ6HÑHÈDÏKÉKÑWÐZ[Ñ[ˆÜ—:‘:˜hÓ'×*Ñ*¬5¯;©;Ó7¸!Ñ;ˆØ $§+¡+Ñ-°×0@Ñ0@Ñ@À4×CUÑCUÑUˆØ$ |Ñ3ˆà�;Š;Ø×-Ñ-ˆLØ)‰Mà×,Ñ,ˆLØ ×.Ñ.°Ñ>ˆMð $ lÑ2°]ÑBˆð ˜1˜tŸy™y×0Ñ0°Ñ3Ñ3Ñ3°d·i±i×6HÑ6HÈÑ6KÈtÏyÉy×OdÑOdÐefÑOgÐjkÑOkÑ6lÑlÐopÑpØ�Y‰Y×Ñ˜aÑ ñ!à#$ñ%ˆð Ðr*   c                 óà  — | j                  |«      }| j                  s|�t        d«      ‚| j                  r8|�6|j                  || j                  «      }t        j                  ||gd¬«      }nn| j                  r+| j                  || j                  |f| j                  ¬«      }n7| j                  || j                  | j                  |z   f| j                  ¬«      }| j                  |«      }|S )Nz=`padding_cache` is not supported for non-causal convolutions.rm   rN   )r•   )r“   rp   r5   rU   r;   r%   rQ   rŸ   rl   re   ry   rx   rt   )r7   r:   r6   r¢   Úlayer_padding_caches        r+   ÚforwardzMimiConv1d.forwardG  sà   € Ø×:Ñ:¸=ÓIˆà�{Š{˜}Ð8ÜÐ\Ó]Ð]à�;Š;˜=Ð4Ø"/×"6Ñ"6°}ÀdÇnÁnÓ"UÐÜ!ŸI™IÐ':¸MÐ&JÐPQÔR‰Mà�[Š[à ŸK™K¨¸×8JÑ8JÈMÐ7ZÐae×anÑan˜KÓo‰Mð !ŸK™KØ × 1Ñ 1°4×3EÑ3EÈÑ3UÐVÐ]a×]jÑ]jð (ó ˆMð Ÿ	™	 -Ó0ˆØÐr*   )r   r   r   NTN)Úzeroç        r‡   )r!   r"   r#   r$   rV   rX   Úboolr9   r„   r‰   r%   rY   r“   ÚstaticmethodÚtupleÚfloatrŸ   r&   r¤   r§   Ú__classcell__©r{   s   @r+   r_   r_   Ò   s  ø„ ÙEð ØØØ#ØØ $ñ+Dð ð+Dð ð	+Dð
 ð+Dð ð+Dð ð+Dð ð+Dð ˜‘*ð+Dð ð+Dð ˜‘:õ+DòZò/ð
%à—|‘|ð
%ð 
�‰ó
%ð ñ!˜eŸl™lð !°e¸CÀ¸H±oð !ÈSð !Ðbgò !ó ð!ð$¨u×/?Ñ/?ð ÀE×DTÑDTó ÷4r*   r_   c                   óR   ‡ — e Zd ZdZ	 	 	 ddededededef
ˆ fd„Zd„ Zd	„ Zd
„ Zˆ xZ	S )ÚMimiConvTranspose1dzDConvTranspose1d with asymmetric or causal padding and normalization.rI   r`   ra   rb   rd   c                 ó  •— t         ‰	| �  «        |j                  | _        |j                  | _        t        j                  ||||||¬«      | _        | j                  s| j                  dk(  st        d«      ‚| j                  j                  d   }| j                  j                  d   }||z
  }| j                  r(t        j                  || j                  z  «      | _        n
|dz  | _        || j                  z
  | _        y )N)rd   rf   ç      ð?zB`trim_right_ratio` != 1.0 only makes sense for causal convolutionsr   rm   )rn   r9   ro   rp   Útrim_right_ratior   ÚConvTranspose1drt   r5   ra   rb   ÚmathrŽ   rx   ry   )
r7   rz   rI   r`   ra   rb   rd   rf   rl   r{   s
            €r+   r9   zMimiConvTranspose1d.__init__a  sä   ø€ ô 	‰ÑÔØ×,Ñ,ˆŒØ &× 7Ñ 7ˆÔÜ×&Ñ& {°LÀ+ÈvÐ^dÐkoÔpˆŒ	à—’˜t×4Ñ4¸Ò;ÜÐaÓbÐbà—i‘i×+Ñ+¨AÑ.ˆØ—‘×!Ñ! !Ñ$ˆØ# fÑ,ˆð �;Š;ô "&§¡¨=¸4×;PÑ;PÑ+PÓ!QˆDÕð "/°!Ñ!3ˆDÔà)¨D×,>Ñ,>Ñ>ˆÕr*   c                 óì   — t         j                  j                  }t        t         j                  j                  d«      r$t         j                  j                  j                  } || j
                  «       y r}   r   rƒ   s     r+   r„   z%MimiConvTranspose1d.apply_weight_norm…  r…   r*   c                 óV   — t         j                  j                  | j                  «       y r‡   rˆ   rŠ   s    r+   r‰   z&MimiConvTranspose1d.remove_weight_normŒ  r‹   r*   c                 ó†   — | j                  |«      }|j                  d   | j                  z
  }|d| j                  |…f   }|S )NrM   .)rt   rB   rx   ry   )r7   r:   rž   s      r+   r§   zMimiConvTranspose1d.forward�  sM   € ØŸ	™	 -Ó0ˆð ×!Ñ! "Ñ%¨×(:Ñ(:Ñ:ˆØ% c¨4×+<Ñ+<¸sÐ+BÐ&BÑCˆØÐr*   )r   r   T)
r!   r"   r#   r$   rV   r9   r„   r‰   r§   r®   r¯   s   @r+   r±   r±   ^  sX   ø„ ÙNð ØØñ"?ð ð"?ð ð	"?ð
 ð"?ð ð"?ð õ"?òHò/ör*   r±   c                   ó>   ‡ — e Zd ZdZdededee   fˆ fd„Zdd„Zˆ xZ	S )ÚMimiResnetBlockz;
    Residual block from SEANet model as used by Mimi.
    rz   rO   Ú	dilationsc           	      ó   •— t         ‰| �  «        |j                  df}t        |«      t        |«      k7  rt	        d«      ‚||j
                  z  }g }t        t        ||«      «      D ]R  \  }\  }}	|dk(  r|n|}
|t        |«      dz
  k(  r|n|}|t        j                  «       gz  }|t        ||
|||	¬«      gz  }ŒT t        j                  |«      | _        |j                  rt        |||d¬«      | _        y t        j                  «       | _        y )Nr   z7Number of kernel sizes should match number of dilationsr   )rc   )ra   )rn   r9   Úresidual_kernel_sizer3   r5   ÚcompressÚ	enumerateÚzipr   ÚELUr_   Ú
ModuleListÚblockÚuse_conv_shortcutÚshortcutÚIdentity)r7   rz   rO   r¼   Úkernel_sizesÚhiddenrÄ   Úira   rc   Úin_chsÚout_chsr{   s               €r+   r9   zMimiResnetBlock.__init__�  s  ø€ Ü‰ÑÔØ×3Ñ3°QÐ7ˆÜˆ|Ó¤ I£Ò.ÜÐVÓWÐWà˜Ÿ™Ñ'ˆØˆÜ*3´C¸ÀiÓ4PÓ*Qò 	[Ñ&ˆAÑ&�˜XØ šF‘S¨ˆFØ¤# lÓ"3°aÑ"7Ò7‘c¸VˆGØ”b—f‘f“h�ZÑˆEØ”j ¨°¸+ÐPXÔYÐZÑZ‰Eð		[ô
 —]‘] 5Ó)ˆŒ
à×#Ò#Ü& v¨s°CÀQÔGˆD�MäŸK™K›MˆD�Mr*   c                 óþ   — |}| j                   D ]%  }t        |t        «      r |||¬«      }Œ ||«      }Œ' t        | j                  t        «      r| j                  ||¬«      }||z   S | j                  |«      }||z   S ©N©r6   )rÄ   Ú
isinstancer_   rÆ   )r7   r:   r6   ÚresidualÚlayers        r+   r§   zMimiResnetBlock.forward±  s„   € Ø ˆà—Z‘Zò 	5ˆEÜ˜%¤Ô,Ù % mÀ=Ô Q‘á % mÓ 4‘ð		5ô �d—m‘m¤ZÔ0Ø—}‘} X¸]�}ÓKˆHð ˜-Ñ'Ð'ð —}‘} XÓ.ˆHà˜-Ñ'Ð'r*   r‡   )
r!   r"   r#   r$   r   rV   rW   r9   r§   r®   r¯   s   @r+   r»   r»   ˜  s+   ø„ ñð*˜zð *°ð *ÀÀSÁ	õ *÷((r*   r»   c                   ó0   ‡ — e Zd ZdZdefˆ fd„Zdd„Zˆ xZS )ÚMimiEncoderzSEANet encoder as used by Mimi.rz   c           	      óÖ  •— t         ‰| �  «        t        ||j                  |j                  |j
                  «      g}d}dg}t        |j                  «      D ]Ì  }||j                  z  }t        |j                  «      D ]O  }|j                  dt        |«      › d�dt        |«      › d�g«       |t        |||j                  |z  dg«      gz  }ŒQ |t        j                  «       gz  }|j!                  dt        |«      › �«       |t        |||dz  |dz  |¬«      gz  }|dz  }ŒÎ |t        j                  «       gz  }|j!                  dt        |«      › �«       |t        |||j                  z  |j"                  |j$                  «      gz  }t        j&                  |«      | _        || _        t-        | j*                  «      D ]#  \  }}	| j/                  |	«      }
t1        |
d|«       Œ% y )	Nr   zlayers.0zlayers.z.block.1z.block.3rm   ©ra   rb   r;   )rn   r9   r_   Úaudio_channelsÚnum_filtersra   ÚreversedÚupsampling_ratiosÚrangeÚnum_residual_layersÚextendr3   r»   Údilation_growth_rater   rÂ   ÚappendÚhidden_sizeÚlast_kernel_sizerÃ   ÚlayersÚ_mimiconv1d_layer_namesrÀ   Úget_submoduleÚsetattr)r7   rz   ÚmodelÚscalingÚmimiconv1d_layer_namesÚratioÚcurrent_scaleÚjr;   Ú	layernameÚ
conv_layerr{   s              €r+   r9   zMimiEncoder.__init__Å  sô  ø€ Ü‰ÑÔÜ˜F F×$9Ñ$9¸6×;MÑ;MÈv×OaÑOaÓbÐcˆØˆð #- Ðô ˜f×6Ñ6Ó7ò 
	ˆEØ# f×&8Ñ&8Ñ8ˆMä˜6×5Ñ5Ó6ò g�Ø&×-Ñ-°¼¸U»¸ÀHÐ/MÐQXÔY\Ð]bÓYcÐXdÐdlÐOmÐ.nÔoØœ/¨&°-À&×B]ÑB]Ð_`ÑB`ÐbcÐAdÓeÐfÑf‘ðgð ”b—f‘f“h�ZÑˆEØ"×)Ñ)¨G´C¸³J°<Ð*@ÔAØ”j ¨¸ÈÑ8IÐW\Ð_`ÑW`ÐinÔoÐpÑpˆEØ�q‰L‰Gð
	ð 	”"—&‘&“(�ÑˆØ×%Ñ%¨´°E³
¨|Ð&<Ô=Ø”*˜V W¨v×/AÑ/AÑ%AÀ6×CUÑCUÐW]×WnÑWnÓoÐpÑpˆä—m‘m EÓ*ˆŒØ'=ˆÔ$ô %.¨d×.JÑ.JÓ$Kò 	8Ñ ˆI�yØ×+Ñ+¨IÓ6ˆJÜ�J ¨YÕ7ñ	8r*   c                 óz   — | j                   D ]+  }t        |t        t        f«      r |||¬«      }Œ$ ||«      }Œ- |S rÎ   )râ   rÐ   r_   r»   )r7   r:   r6   rÒ   s       r+   r§   zMimiEncoder.forwardæ  sB   € Ø—[‘[ò 	5ˆEÜ˜%¤*¬oÐ!>Ô?Ù % mÀ=Ô Q‘á % mÓ 4‘ð		5ð
 Ðr*   r‡   ©r!   r"   r#   r$   r   r9   r§   r®   r¯   s   @r+   rÔ   rÔ   Â  s   ø„ Ù)ð8˜zõ 8÷Br*   rÔ   c                   óB   ‡ — e Zd ZdZˆ fd„Zdej                  fd„Zˆ xZS )ÚMimiLayerScalez©Layer scale from [Touvron et al 2021] (https://huggingface.co/papers/2103.17239).
    This rescales diagonally the residual outputs close to 0, with a learnt scale.
    c                 ó´   •— t         ‰| �  «        |j                  }|j                  }t	        j
                  t        j                  |f|d¬«      «      | _        y )NT)Úrequires_grad)	rn   r9   rà   Úlayer_scale_initial_scaler   Ú	Parameterr%   ÚfullÚscale)r7   rz   ÚchannelsÚinitial_scaler{   s       €r+   r9   zMimiLayerScale.__init__ô  sD   ø€ Ü‰ÑÔØ×%Ñ%ˆØ×8Ñ8ˆÜ—\‘\¤%§*¡*¨h¨[¸-ÐW[Ô"\Ó]ˆ�
r*   Úxc                 ó    — | j                   |z  S r‡   )r÷   )r7   rú   s     r+   r§   zMimiLayerScale.forwardú  s   € Ø�z‰z˜A‰~Ðr*   )	r!   r"   r#   r$   r9   r%   rY   r§   r®   r¯   s   @r+   rñ   rñ   ï  s   ø„ ñô^ð˜Ÿ™÷ r*   rñ   c                   óÄ   ‡ — e Zd ZU ej                  ed<   ddefˆ fd„Ze	 	 	 ddedz  de	d   de
dz  ded	ef   fd
„«       Z ej                  «       ed„ «       «       Zˆ xZS )ÚMimiRotaryEmbeddingÚinv_freqNrz   c                 ó®  •— t         ‰| �  «        |j                  | _        |j                  | _        || _        | j
                  j                  d   | _        | j                  }| j                  dk7  rt        | j                     } || j
                  |«      \  }| _
        | j                  d|d¬«       | j                  d|j                  «       d¬«       y )NÚ	rope_typeÚdefaultrþ   Frj   Úoriginal_inv_freq)rn   r9   Úmax_position_embeddingsÚmax_seq_len_cachedÚoriginal_max_seq_lenrz   Úrope_parametersr   Úcompute_default_rope_parametersr   Úattention_scalingrw   Úclone)r7   rz   r?   Úrope_init_fnrþ   r{   s        €r+   r9   zMimiRotaryEmbedding.__init__  s¶   ø€ Ü‰ÑÔØ"(×"@Ñ"@ˆÔØ$*×$BÑ$BˆÔ!àˆŒàŸ™×4Ñ4°[ÑAˆŒØ!%×!EÑ!EˆØ�>‰>˜YÒ&Ü.¨t¯~©~Ñ>ˆLÙ+7¸¿¹ÀVÓ+LÑ(ˆ�$Ô(à×Ñ˜Z¨¸eÐÔDØ×ÑÐ0°(·.±.Ó2BÈuÐÕUr*   r?   ztorch.deviceÚseq_lenrŒ   ztorch.Tensorc                 ó  — | j                   d   }t        | dd«      xs | j                  | j                  z  }d}d|t	        j
                  d|dt        j                  ¬«      j                  |t        j                  ¬«      |z  z  z  }||fS )	a¨  
        Computes the inverse frequencies according to the original RoPE implementation
        Args:
            config ([`~transformers.PreTrainedConfig`]):
                The model configuration.
            device (`torch.device`):
                The device to use for initialization of the inverse frequencies.
            seq_len (`int`, *optional*):
                The current sequence length. Unused for this type of RoPE.
        Returns:
            Tuple of (`torch.Tensor`, `float`), containing the inverse frequencies for the RoPE embeddings and the
            post-processing scaling factor applied to the computed cos/sin (unused in this type of RoPE).
        Ú
rope_thetaÚhead_dimNr³   r   rm   ri   r>   )	r  Úgetattrrà   Únum_attention_headsr%   Úarangerv   r�   r­   )rz   r?   r  ÚbaserO   Úattention_factorrþ   s          r+   r  z3MimiRotaryEmbedding.compute_default_rope_parameters  s�   € ð& ×%Ñ% lÑ3ˆÜ�f˜j¨$Ó/Òc°6×3EÑ3EÈ×IcÑIcÑ3cˆàÐð Ø”U—\‘\ ! S¨!´5·;±;Ô?×BÑBÈ&ÔX]×XcÑXcÐBÓdÐgjÑjÑkñ
ˆð Ð)Ð)Ð)r*   c                 óN  — | j                   d d d …d f   j                  «       j                  |j                  d   dd«      j	                  |j
                  «      }|d d …d d d …f   j                  «       }t        |j
                  j                  t        «      r/|j
                  j                  dk7  r|j
                  j                  nd}t        |d¬«      5  |j                  «       |j                  «       z  j                  dd«      }t        j                  ||fd¬	«      }|j                  «       | j                  z  }|j                  «       | j                  z  }	d d d «       j	                  |j                   ¬
«      	j	                  |j                   ¬
«      fS # 1 sw Y   ŒAxY w)Nr   rM   r   ÚmpsÚcpuF)Údevice_typeÚenabledrm   rN   ri   )rþ   r­   ÚexpandrB   r�   r?   rÐ   ÚtyperX   r   Ú	transposer%   rQ   Úcosr  Úsinr@   )
r7   rú   Úposition_idsÚinv_freq_expandedÚposition_ids_expandedr  ÚfreqsÚembr  r  s
             r+   r§   zMimiRotaryEmbedding.forward0  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$r‡   ©NNN)r!   r"   r#   r%   rY   r'   r   r9   r«   r   rV   r¬   r­   r  Úno_gradr   r§   r®   r¯   s   @r+   rý   rý   ÿ  s˜   ø… Ø�l‰lÓñV˜zõ Vð  à$(Ø+/Ø"ñ*Ø˜TÑ!ð*à˜Ñ(ð*ð �t‘ð*ð 
ˆ~˜uÐ$Ñ	%ò	*ó ð*ð: €U‡]�]ƒ_Øñ<ó ó ô<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..NrM   rm   rN   )rB   r%   rQ   )rú   Úx1Úx2s      r+   Úrotate_halfr(  A  sZ   € à	
ˆ3Ð"�!—'‘'˜"‘+ Ñ"Ð"Ð"Ñ	#€BØ	
ˆ3�—‘˜‘˜qÑ Ñ"Ð"Ñ	#€BÜ�9‰9�r�c˜2�Y BÔ'Ð'r*   c                 óž   — |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Úkr  r  Úunsqueeze_dimÚq_embedÚk_embeds          r+   Úapply_rotary_pos_embr0  I  sY   € ð$ �-‰-˜Ó
&€CØ
�-‰-˜Ó
&€CØ�3‰wœ; q›>¨CÑ/Ñ0€GØ�3‰wœ; q›>¨CÑ/Ñ0€GØ�GÐÐr*   c                   óV   ‡ — e Zd Zˆ fd„Zdej
                  dej
                  fd„Zˆ xZS )ÚMimiMLPc                 ó$  •— t         ‰| �  «        || _        t        |j                     | _        t        j                  |j                  |j                  d¬«      | _
        t        j                  |j                  |j                  d¬«      | _        y )NF©rf   )rn   r9   rz   r	   Ú
hidden_actÚactivation_fnr   ÚLinearrà   Úintermediate_sizeÚfc1Úfc2©r7   rz   r{   s     €r+   r9   zMimiMLP.__init__c  sj   ø€ Ü‰ÑÔØˆŒÜ# F×$5Ñ$5Ñ6ˆÔÜ—9‘9˜V×/Ñ/°×1IÑ1IÐPUÔVˆŒÜ—9‘9˜V×5Ñ5°v×7IÑ7IÐPUÔVˆ�r*   r:   rŒ   c                 ól   — | j                  |«      }| j                  |«      }| j                  |«      }|S r‡   )r9  r6  r:  )r7   r:   s     r+   r§   zMimiMLP.forwardk  s4   € ØŸ™ Ó/ˆØ×*Ñ*¨=Ó9ˆØŸ™ Ó/ˆØÐr*   )r!   r"   r#   r9   r%   rY   r§   r®   r¯   s   @r+   r2  r2  b  s$   ø„ ôWð U§\¡\ð °e·l±l÷ r*   r2  r:   Ún_reprŒ   c                 óª   — | j                   \  }}}}|dk(  r| S | dd…dd…ddd…dd…f   j                  |||||«      } | j                  |||z  ||«      S )zÔ
    This is the equivalent of torch.repeat_interleave(x, dim=1, repeats=n_rep). The hidden states go from (batch,
    num_key_value_heads, seqlen, head_dim) to (batch, num_attention_heads, seqlen, head_dim)
    r   N)rB   r  Úreshape)r:   r=  ÚbatchÚnum_key_value_headsÚslenr  s         r+   Ú	repeat_kvrC  s  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Úkeyr–   Úattention_maskrç   Ú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 )Nrm   r   rM   )rO   r@   )ÚpÚtrainingr   )rC  Únum_key_value_groupsr%   Úmatmulr  r   r™   ÚsoftmaxÚfloat32r�   r@   rH  rL  Ú
contiguous)rD  rE  rF  r–   rG  rç   rH  rI  Ú
key_statesÚvalue_statesÚattn_weightsÚattn_outputs               r+   Úeager_attention_forwardrV  €  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dededz  fˆ fd„Z	 	 	 ddej                  dej                  dz  de	dz  d	e
ej                  ej                  f   dz  d
e
ej                  ej                  f   f
d„Zˆ xZS )ÚMimiAttentionz=Multi-headed attention from 'Attention Is All You Need' paperNrz   r;   c                 óˆ  •— t         ‰| �  «        || _        || _        |j                  | _        |j
                  | _        |j                  | _        |j                  | _        |j                  | _	        | j                  | j                  z  | _
        |j                  | _        d| _        dt        j                  |j                  «      z  | _        | j
                  | j                  z  dk7  r&t!        d| j
                  › d| 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&                  ¬«      | _        |j0                  | _        y )NTr   r   z?hidden_size must be divisible by num_heads (got `hidden_size`: z and `num_heads`: rh   r4  )rn   r9   rz   r;   Úattention_dropoutrà   r  Ú	num_headsr  rA  rM  r  Ú	is_causalr¶   Úsqrtrç   r5   r   r7  Úattention_biasÚq_projÚk_projÚv_projÚo_projÚsliding_window©r7   rz   r;   r{   s      €r+   r9   zMimiAttention.__init__œ  sµ  ø€ Ü‰ÑÔØˆŒØ"ˆŒà!'×!9Ñ!9ˆÔØ!×-Ñ-ˆÔØ×3Ñ3ˆŒØŸ™ˆŒØ#)×#=Ñ#=ˆÔ Ø$(§N¡N°d×6NÑ6NÑ$NˆÔ!Ø'-×'EÑ'EˆÔ$ØˆŒØœ4Ÿ9™9 V§_¡_Ó5Ñ5ˆŒà×Ñ˜dŸn™nÑ,°Ò1ÜØQÐRV×RbÑRbÐQcØ$ T§^¡^Ð$4°Bð8óð ô
 —i‘i × 0Ñ 0°$·.±.À4Ç=Á=Ñ2PÐW]×WlÑWlÔmˆŒÜ—i‘i × 0Ñ 0°$×2JÑ2JÈTÏ]É]Ñ2ZÐag×avÑavÔwˆŒÜ—i‘i × 0Ñ 0°$×2JÑ2JÈTÏ]É]Ñ2ZÐag×avÑavÔwˆŒÜ—i‘i §¡°·±Ñ >À×@PÑ@PÐW]×WlÑWlÔmˆŒØ$×3Ñ3ˆÕr*   r:   rG  Úpast_key_valuesÚposition_embeddingsrŒ   c                 ó   — |j                   d d }g |¢d‘| j                  ‘­}| j                  |«      j                  |«      j	                  dd«      }| j                  |«      j                  |«      j	                  dd«      }	| j                  |«      j                  |«      j	                  dd«      }
|\  }}t        ||	||«      \  }}	|� |j                  |	|
| j                  «      \  }	}
t        j                  | j                  j                  t        «      } || ||	|
|f| j                  sdn| j                   | j"                  | j$                  dœ|¤Ž\  }} |j&                  g |¢d‘­Ž j)                  «       }| j+                  |«      }||fS )NrM   r   rm   r©   )rH  rç   rc  )rB   r  r_  Úviewr  r`  ra  r0  rU   r;   r   Úget_interfacerz   Ú_attn_implementationrV  rL  rZ  rç   rc  r?  rQ  rb  )r7   r:   rG  re  rf  rI  Úinput_shapeÚhidden_shapeÚquery_statesrR  rS  r  r  Úattention_interfacerU  rT  s                   r+   r§   zMimiAttention.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Ü#7¸ÀjÐRUÐWZÓ#[Ñ ˆ�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*   r‡   r#  )r!   r"   r#   r$   r   rV   r9   r%   rY   r
   r¬   r§   r®   r¯   s   @r+   rX  rX  ™  s—   ø„ ÙGñ4˜zð 4°c¸D±jõ 4ð< /3Ø(,ØHLñ')à—|‘|ð')ð Ÿ™ tÑ+ð')ð  ™ð	')ð
 # 5§<¡<°·±Ð#=Ñ>ÀÑEð')ð 
ˆu�|‰|˜UŸ\™\Ð)Ñ	*÷')r*   rX  c                   ó&  ‡ — e Zd Zdedefˆ fd„Z	 	 	 	 	 ddej                  dej                  dz  dedz  de	dz  d	e	dz  d
e
ej                  ej                  f   dz  de
ej                  e
ej                  ej                  f   dz  f   fd„Zˆ xZS )ÚMimiTransformerLayerrz   r;   c                 óˆ  •— t         ‰| �  «        |j                  | _        t        ||¬«      | _        t        |«      | _        t        j                  |j                  |j                  ¬«      | _
        t        j                  |j                  |j                  ¬«      | _        t        |«      | _        t        |«      | _        y )N)rz   r;   )Úeps)rn   r9   rà   rX  Ú	self_attnr2  Úmlpr   Ú	LayerNormÚnorm_epsÚinput_layernormÚpost_attention_layernormrñ   Úself_attn_layer_scaleÚmlp_layer_scalerd  s      €r+   r9   zMimiTransformerLayer.__init__â  s‰   ø€ Ü‰ÑÔØ!×-Ñ-ˆÔä&¨fÀ	ÔJˆŒä˜6“?ˆŒÜ!Ÿ|™|¨F×,>Ñ,>ÀFÇOÁOÔTˆÔÜ(*¯©°V×5GÑ5GÈVÏ_É_Ô(]ˆÔ%Ü%3°FÓ%;ˆÔ"Ü-¨fÓ5ˆÕr*   Nr:   rG  re  Úoutput_attentionsÚ	use_cacherf  rŒ   c           
      ó  — |}| j                  |«      } | j                  d||||||dœ|¤Ž\  }}	|| j                  |«      z   }|}| j                  |«      }| j	                  |«      }|| j                  |«      z   }|f}
|r|
|	fz  }
|
S )N)r:   rG  re  r{  r|  rf  r)   )rw  rs  ry  rx  rt  rz  )r7   r:   rG  re  r{  r|  rf  rI  rÑ   Úself_attn_weightsÚoutputss              r+   r§   zMimiTransformerLayer.forwardî  sÁ   € ð !ˆà×,Ñ,¨]Ó;ˆð ,:¨4¯>©>ð ,
Ø'Ø)Ø+Ø/ØØ 3ñ,
ð ñ,
Ñ(ˆÐ(ð ! 4×#=Ñ#=¸mÓ#LÑLˆð !ˆØ×5Ñ5°mÓDˆØŸ™ Ó/ˆØ  4×#7Ñ#7¸Ó#FÑFˆà Ð"ˆáØÐ)Ð+Ñ+ˆGàˆr*   )NNFFN)r!   r"   r#   r   rV   r9   r%   rY   r
   rª   r¬   r(   r§   r®   r¯   s   @r+   rp  rp  á  sÌ   ø„ ð
6˜zð 
6°cõ 
6ð /3Ø(,Ø).Ø!&ØHLñ%à—|‘|ð%ð Ÿ™ tÑ+ð%ð  ™ð	%ð
   $™;ð%ð ˜$‘;ð%ð # 5§<¡<°·±Ð#=Ñ>ÀÑEð%ð 
ˆu× Ñ  %¨×(9Ñ(9¸5×;LÑ;LÐ(LÑ"MÐPTÑ"TÐTÑ	U÷%r*   rp  c                   óØ   ‡ — e Zd ZdZdefˆ fd„Z	 	 	 	 	 	 	 	 ddej                  dz  dej                  dz  dej                  dz  de	dz  d	e
dz  d
e
dz  de
dz  de
dz  deez  fd„Zˆ xZS )ÚMimiTransformerModelz�
    Transformer decoder consisting of *config.num_hidden_layers* layers. Each layer is a [`MimiTransformerLayer`]

    Args:
        config: MimiConfig
    rz   c           	      óò   •— t         ‰| �  «        t        j                  t	        |j
                  «      D �cg c]  }t        ||«      ‘Œ c}«      | _        t        |«      | _	        d| _
        || _        y c c}w )NF)rn   r9   r   rÃ   rÛ   Únum_hidden_layersrp  râ   rý   Ú
rotary_embÚgradient_checkpointingrz   rd  s      €r+   r9   zMimiTransformerModel.__init__  sb   ø€ Ü‰ÑÔä—m‘mÜFKÈF×LdÑLdÓFeÖf¸Ô! &¨)Õ4Òfó
ˆŒô .¨fÓ5ˆŒà&+ˆÔ#Øˆ�ùò gs   ¶A4Nr:   rG  r  re  r|  r{  Úoutput_hidden_statesÚreturn_dictrŒ   c	           
      óX  — |�|n| j                   j                  }|�|n| j                   j                  }|�|n| j                   j                  }|�|n| j                   j                  }| j
                  r%| j                  r|rt        j                  d«       d}|r|€t        | j                   ¬«      }|€V|�|j                  «       nd}
t        j                  |j                  d   |j                  ¬«      |
z   }|j                  d«      }t!        | j                   ||||¬«      }| j#                  ||«      }|rd	nd}|rd	nd}| j$                  D ]*  }|r||fz  } ||||||||¬
«      }|d   }|sŒ"||d   fz  }Œ, |r||fz  }|st'        d„ ||||fD «       «      S t)        ||||¬«      S )a|  
        Args:
            hidden_states (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
                Embedded representation that will be contextualized by the model
            attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
                Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:

                - 1 for tokens that are **not masked**,
                - 0 for tokens that are **masked**.

                [What are attention masks?](../glossary#attention-mask)

                Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
                [`PreTrainedTokenizer.__call__`] for details.

                If `past_key_values` is used, optionally only the last `decoder_input_ids` have to be input (see
                `past_key_values`).

                If you want to change padding behavior, you should read [`modeling_opt._prepare_decoder_attention_mask`]
                and modify to your needs. See diagram 1 in [the paper](https://huggingface.co/papers/1910.13461) for more
                information on the default strategy.

                - 1 indicates the head is **not masked**,
                - 0 indicates the head is **masked**.
            position_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
                Indices of positions of each input sequence tokens in the position embeddings. Selected in the range `[0,
                config.n_positions - 1]`.

                [What are position IDs?](../glossary#position-ids)
            past_key_values (`Cache`, *optional*):
                It is a [`~cache_utils.Cache`] instance. For more details, see our [kv cache guide](https://huggingface.co/docs/transformers/en/kv_cache).

                If `past_key_values` are used, the user can optionally input only the last `input_ids` (those that don't
                have their past key value states given to this model) of shape `(batch_size, 1)` instead of all `input_ids`
                of shape `(batch_size, sequence_length)`.
            use_cache (`bool`, *optional*):
                If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see
                `past_key_values`).
            output_attentions (`bool`, *optional*):
                Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned
                tensors for more detail.
            output_hidden_states (`bool`, *optional*):
                Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
                more detail.
            return_dict (`bool`, *optional*):
                Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
        NzX`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`.F)rz   r   r   ©r?   )rz   Úinputs_embedsrG  re  r  r)   )rG  r  re  r{  r|  rf  c              3   ó&   K  — | ]	  }|€Œ|–— Œ y ­wr‡   r)   )Ú.0Úvs     r+   ú	<genexpr>z/MimiTransformerModel.forward.<locals>.<genexpr>Ÿ  s   è ø€ ò ØÐbcÑbo”ñùs   ‚Š)Úlast_hidden_statere  r:   Ú
attentions)rz   r{  r†  r|  r‡  r…  rL  rq   Úwarning_oncer   Úget_seq_lengthr%   r  rB   r?   r*  r   r„  râ   r¬   r   )r7   r:   rG  r  re  r|  r{  r†  r‡  rI  Úpast_seen_tokensÚcausal_maskrf  Úall_hidden_statesÚall_self_attnsÚdecoder_layerÚlayer_outputss                    r+   r§   zMimiTransformerModel.forward)  sú  € ðv 2CÐ1NÑ-ÐTX×T_ÑT_×TqÑTqÐà$8Ð$DÑ È$Ï+É+×JjÑJjð 	ð "+Ð!6‘I¸D¿K¹K×<QÑ<Qˆ	à%0Ð%<‘kÀ$Ç+Á+×BYÑBYˆà×&Ò&¨4¯=ª=¹YÜ×ÑØjôð ˆIá˜Ð0Ü*°$·+±+Ô>ˆOàÐØCRÐC^˜×=Ñ=Ô?ÐdeÐÜ Ÿ<™<¨×(;Ñ(;¸AÑ(>À}×G[ÑG[Ô\Ð_oÑoˆLØ'×1Ñ1°!Ó4ˆLä7Ø—;‘;Ø'Ø)Ø+Ø%ô
ˆð #Ÿo™o¨m¸\ÓJÐñ #7™B¸DÐÙ0™°dˆà!Ÿ[™[ò 	6ˆMÙ#Ø! mÐ%5Ñ5Ð!á)ØØ*Ø)Ø /Ø"3Ø#Ø$7ôˆMð *¨!Ñ,ˆMâ Ø =°Ñ#3Ð"5Ñ5‘ð#	6ñ(  Ø -Ð!1Ñ1ÐáÜñ Ø)¨?Ð<MÈ~Ð^ôó ð ô 'Ø+Ø+Ø+Ø%ô	
ð 	
r*   )NNNNNNNN)r!   r"   r#   r$   r   r9   r%   r&   rY   r
   rª   r¬   r   r§   r®   r¯   s   @r+   r�  r�    sÎ   ø„ ñð	˜zõ 	ð 26Ø.2Ø04Ø(,Ø!%Ø)-Ø,0Ø#'ñ
à×'Ñ'¨$Ñ.ð
ð Ÿ™ tÑ+ð
ð ×&Ñ&¨Ñ-ð	
ð
  ™ð
ð ˜$‘;ð
ð   $™;ð
ð # T™kð
ð ˜D‘[ð
ð 
Ð(Ñ	(÷
r*   r�  c                   ó.   ‡ — e Zd ZdZdefˆ fd„Zd„ Zˆ xZS )ÚMimiDecoderzSEANet decoder as used by Mimi.rz   c           	      ó°  •— t         ‰| �  «        t        dt        |j                  «      z  «      }t        ||j                  ||j                  z  |j                  «      g}|j                  D ]…  }||j                  z  }|t        j                  «       gz  }|t        |||dz  |dz  |¬«      gz  }t        |j                  «      D ]%  }|t        ||dz  |j                  |z  df«      gz  }Œ' |dz  }Œ‡ |t        j                  «       gz  }|t        ||j                  |j                   |j"                  «      gz  }t        j$                  |«      | _        y )Nrm   rÖ   r   )rn   r9   rV   r3   rÚ   r_   rà   rØ   ra   r   rÂ   r±   rÛ   rÜ   r»   rÞ   r×   rá   rÃ   râ   )r7   rz   rç   ræ   ré   rê   rë   r{   s          €r+   r9   zMimiDecoder.__init__®  s[  ø€ Ü‰ÑÔÜ�aœ3˜v×7Ñ7Ó8Ñ8Ó9ˆÜ˜F F×$6Ñ$6¸À&×BTÑBTÑ8TÐV\×VhÑVhÓiÐjˆð ×-Ñ-ò 
	ˆEØ# f×&8Ñ&8Ñ8ˆMà”b—f‘f“h�ZÑˆEØÜ# F¨M¸=ÈAÑ;MÐ[`ÐcdÑ[dÐmrÔsðñ ˆEô ˜6×5Ñ5Ó6ò l�Øœ/¨&°-À1Ñ2DÀv×GbÑGbÐdeÑGeÐghÐFiÓjÐkÑk‘ðlà˜‰M‰Gð
	ð 	”"—&‘&“(�ÑˆØ”*˜V V×%7Ñ%7¸×9NÑ9NÐPV×PgÑPgÓhÐiÑiˆÜ—m‘m EÓ*ˆ�r*   c                 ó8   — | j                   D ]
  } ||«      }Œ |S r‡   )râ   )r7   r:   rÒ   s      r+   r§   zMimiDecoder.forwardÆ  s%   € Ø—[‘[ò 	1ˆEÙ! -Ó0‰Mð	1àÐr*   rï   r¯   s   @r+   rš  rš  «  s   ø„ Ù)ð+˜zõ +ö0r*   rš  c                   ój   ‡ — e Zd ZdZd
dedefˆ fd„Zedej                  fd„«       Z
d„ Zd„ Zd	„ Zˆ xZS )ÚMimiEuclideanCodebookz!Codebook with Euclidean distance.rz   Úepsilonc                 ó¢  •— t         ‰| �  «        t        j                  |j                  |j
                  «      }|j                  | _        | j                  dt        j                  dgt        j                  ¬«      «       | j                  dt        j                  |j                  «      «       | j                  d|«       d | _
        || _        y )NÚinitializedTri   Úcluster_usageÚ	embed_sum)rn   r9   r%   rC   Úcodebook_sizeÚcodebook_dimrw   ru   rP  rD   Ú_embedrŸ  )r7   rz   rŸ  Úembedr{   s       €r+   r9   zMimiEuclideanCodebook.__init__Ï  s–   ø€ Ü‰ÑÔÜ—‘˜F×0Ñ0°&×2EÑ2EÓFˆà#×1Ñ1ˆÔà×Ñ˜]¬E¯L©L¸$¸ÄuÇ}Á}Ô,UÔVØ×Ñ˜_¬e¯j©j¸×9MÑ9MÓ.NÔOØ×Ñ˜[¨%Ô0ØˆŒØˆ�r*   rŒ   c                 ó°   — | j                   €?| j                  | j                  j                  | j                  ¬«      d d …d f   z  | _         | j                   S )N)Úmin)r¦  r£  r¢  ÚclamprŸ  rŠ   s    r+   r§  zMimiEuclideanCodebook.embedÛ  sJ   € à�;‰;ÐØŸ.™.¨4×+=Ñ+=×+CÑ+CÈÏÉÐ+CÓ+UÒVWÐY]ÐV]Ñ+^Ñ^ˆDŒKØ�{‰{Ðr*   c                 ó¸   — t        j                  |d    j                  «       | j                  d    j                  «       d¬«      d   }|j	                  d¬«      }|S )Nrm   )rK  r   rM   rN   )r%   Úcdistr­   r§  Úargmin)r7   r:   ÚdistsÚ	embed_inds       r+   ÚquantizezMimiEuclideanCodebook.quantizeá  sS   € ô —‘˜M¨$Ñ/×5Ñ5Ó7¸¿¹ÀDÑ9I×9OÑ9OÓ9QÐUVÔWÐXYÑZˆØ—L‘L R�LÓ(ˆ	ØÐr*   c                 ó�   — |j                   }|j                  d|d   f«      }| j                  |«      } |j                  |d d Ž }|S )NrM   )rB   r?  r°  rh  )r7   r:   rB   r¯  s       r+   ÚencodezMimiEuclideanCodebook.encodeé  sO   € Ø×#Ñ#ˆà%×-Ñ-¨r°5¸±9¨oÓ>ˆà—M‘M -Ó0ˆ	à"�I—N‘N E¨#¨2 JÐ/ˆ	ØÐr*   c                 óZ   — t         j                  j                  || j                  «      }|S r‡   )r   r™   Ú	embeddingr§  ©r7   r¯  r°  s      r+   ÚdecodezMimiEuclideanCodebook.decodeô  s!   € Ü—=‘=×*Ñ*¨9°d·j±jÓAˆØˆr*   )gñhãˆµøä>)r!   r"   r#   r$   r   r­   r9   Úpropertyr%   rY   r§  r°  r²  r¶  r®   r¯   s   @r+   rž  rž  Ì  sG   ø„ Ù+ñ
˜zð 
°Eõ 
ð ð�u—|‘|ò ó ðò
òör*   rž  c                   ó4   ‡ — e Zd ZdZdefˆ fd„Zd„ Zd„ Zˆ xZS )ÚMimiVectorQuantizationzY
    Vector quantization implementation. Currently supports only euclidean distance.
    rz   c                 óB   •— t         ‰| �  «        t        |«      | _        y r‡   )rn   r9   rž  Úcodebookr;  s     €r+   r9   zMimiVectorQuantization.__init__ÿ  s   ø€ Ü‰ÑÔÜ-¨fÓ5ˆ�r*   c                 ób   — |j                  ddd«      }| j                  j                  |«      }|S ©Nr   rm   r   )Úpermuter»  r²  )r7   r:   Úembed_ins      r+   r²  zMimiVectorQuantization.encode  s/   € Ø%×-Ñ-¨a°°AÓ6ˆØ—=‘=×'Ñ'¨Ó6ˆØˆr*   c                 ób   — | j                   j                  |«      }|j                  ddd«      }|S r½  )r»  r¶  r¾  rµ  s      r+   r¶  zMimiVectorQuantization.decode  s/   € Ø—=‘=×'Ñ'¨	Ó2ˆØ×#Ñ# A q¨!Ó,ˆØˆr*   )	r!   r"   r#   r$   r   r9   r²  r¶  r®   r¯   s   @r+   r¹  r¹  ú  s   ø„ ñð6˜zõ 6òö
r*   r¹  c                   ó°   ‡ — e Zd ZdZddededz  fˆ fd„Zddej                  dedz  dej                  fd„Z	d	ej                  dej                  fd
„Z
ˆ xZS )ÚMimiResidualVectorQuantizerzResidual Vector Quantizer.Nrz   Únum_quantizersc                 ób  •— t         ‰| �  «        |j                  | _        |j                  | _        |�|n|j                  | _        t        j                  t        | j                  «      D �cg c]  }t        |«      ‘Œ c}«      | _	        d | _
        d | _        |j                  |j                  k7  ryt        j
                  j                  |j                  |j                  dd¬«      | _
        t        j
                  j                  |j                  |j                  dd¬«      | _        y y c c}w )Nr   Fr4  )rn   r9   r¤  Ú
frame_raterÃ  r   rÃ   rÛ   r¹  râ   Ú
input_projÚoutput_projÚ$vector_quantization_hidden_dimensionrà   r%   rs   )r7   rz   rÃ  Ú_r{   s       €r+   r9   z$MimiResidualVectorQuantizer.__init__  sþ   ø€ Ü‰ÑÔØ#×1Ñ1ˆÔØ ×+Ñ+ˆŒØ0>Ð0J™nÐPV×PeÑPeˆÔÜ—m‘mÌUÐSW×SfÑSfÓMgÖ$hÈÔ%;¸FÕ%CÒ$hÓiˆŒàˆŒØˆÔØ×6Ñ6¸&×:LÑ:LÒLÜ#Ÿh™hŸo™oØ×"Ñ" F×$OÑ$OÐQRÐY^ð .ó ˆDŒOô  %Ÿx™xŸ™Ø×;Ñ;¸V×=OÑ=OÐQRÐY^ð  /ó  ˆDÕð	 Mùò	 %is   Á-D,Ú
embeddingsrŒ   c                 ó*  — | j                   �| j                  |«      }|�|n| j                  }|}g }| j                  d| D ]:  }|j                  |«      }|j	                  |«      }||z
  }|j                  |«       Œ< t        j                  |«      }|S )úñ
        Encode a given input tensor with the specified frame rate at the given number of quantizers / codebooks. The RVQ encode method sets
        the appropriate number of quantizers to use and returns indices for each quantizer.
        N)rÆ  rÃ  râ   r²  r¶  rß   r%   Ústack)	r7   rÊ  rÃ  rÑ   Úall_indicesrÒ   ÚindicesÚ	quantizedÚout_indicess	            r+   r²  z"MimiResidualVectorQuantizer.encode"  sœ   € ð
 �?‰?Ð&ØŸ™¨Ó4ˆJà+9Ð+E™È4×K^ÑK^ˆàˆØˆØ—[‘[  .Ð1ò 	(ˆEØ—l‘l 8Ó,ˆGØŸ™ WÓ-ˆIØ )Ñ+ˆHØ×Ñ˜wÕ'ð		(ô
 —k‘k +Ó.ˆØÐr*   Úcodesc                 ó  — t        j                  d|j                  ¬«      }|j                  dd«      }t	        |«      D ]*  \  }}| j
                  |   }|j                  |«      }||z   }Œ, | j                  �| j                  |«      }|S )zJDecode the given codes of shape [B, K, T] to the quantized representation.r©   r‰  r   r   )r%   ru   r?   r  rÀ   râ   r¶  rÇ  )r7   rÒ  Úquantized_outrÊ   rÏ  rÒ   rÐ  s          r+   r¶  z"MimiResidualVectorQuantizer.decode6  s‡   € äŸ™ S°·±Ô>ˆØ—‘  1Ó%ˆÜ# EÓ*ò 	6‰JˆAˆwØ—K‘K ‘NˆEØŸ™ WÓ-ˆIØ)¨IÑ5‰Mð	6ð
 ×ÑÐ'Ø ×,Ñ,¨]Ó;ˆMØÐr*   r‡   )r!   r"   r#   r$   r   rV   r9   r%   rY   r²  r¶  r®   r¯   s   @r+   rÂ  rÂ    sa   ø„ Ù$ñ˜zð ¸3À¹:õ ñ" §¡ð ¸sÀT¹zð ÐUZ×UaÑUaó ð(˜EŸL™Lð ¨U¯\©\÷ r*   rÂ  c                   ó¤   ‡ — e Zd ZdZdefˆ fd„Zddej                  dedz  dej                  fd„Z	d	ej                  dej                  fd
„Z
ˆ xZS )Ú MimiSplitResidualVectorQuantizerz Split Residual Vector Quantizer.rz   c                 óR  •— t         ‰| �  «        |j                  | _        |j                  | _        |j                  | _        |j                  | _        |j                  |j                  z
  | _        t        || j                  «      | _	        t        || j                  «      | _
        y r‡   )rn   r9   r¤  rÅ  rÃ  Úmax_num_quantizersÚnum_semantic_quantizersÚnum_acoustic_quantizersrÂ  Ú"semantic_residual_vector_quantizerÚ"acoustic_residual_vector_quantizerr;  s     €r+   r9   z)MimiSplitResidualVectorQuantizer.__init__G  sŠ   ø€ Ü‰ÑÔØ#×1Ñ1ˆÔØ ×+Ñ+ˆŒØ"(×"7Ñ"7ˆÔà'-×'EÑ'EˆÔ$Ø'-×'<Ñ'<¸v×?]Ñ?]Ñ']ˆÔ$ä2MÈfÐVZ×VrÑVrÓ2sˆÔ/Ü2MÈfÐVZ×VrÑVrÓ2sˆÕ/r*   NrÊ  rÃ  rŒ   c                 ó¬  — |€| j                   n|}|| j                   kD  rt        d| j                   › d|› d�«      ‚|| j                  k  rt        d| j                  › d|› d�«      ‚| j                  j	                  |«      }|| j                  kD  rC| j
                  j	                  ||| j                  z
  ¬«      }t        j                  ||gd¬«      }|S )rÌ  úcThe number of quantizers (i.e codebooks) asked should be lower than the total number of quantizers ú, but is currently ú.zgThe number of quantizers (i.e codebooks) asked should be higher than the number of semantic quantizers )rÃ  r   rN   )rØ  r5   rÙ  rÛ  r²  rÜ  r%   rQ   )r7   rÊ  rÃ  rÒ  Úacoustic_codess        r+   r²  z'MimiSplitResidualVectorQuantizer.encodeS  s8  € ð 5CÐ4J˜×0Ò0ÐP^ˆà˜D×3Ñ3Ò3ÜØuÐvz÷  wNñ  wNð  vOð  Obð  cqð  brð  rsð  tóð ð ˜D×8Ñ8Ò8ÜØyÐz~÷  {Wñ  {Wð  zXð  Xkð  lzð  k{ð  {|ð  }óð ð
 ×7Ñ7×>Ñ>¸zÓJˆà˜D×8Ñ8Ò8Ø!×DÑD×KÑKØ¨>¸D×<XÑ<XÑ+Xð Ló ˆNô —I‘I˜u nÐ5¸1Ô=ˆEàˆr*   rÒ  c                 óü   — | j                   j                  |dd…d| j                  …f   «      }|j                  d   | j                  kD  r1|| j                  j                  |dd…| j                  d…f   «      z  }|S )z7Decode the given codes to the quantized representation.Nr   )rÛ  r¶  rÙ  rB   rÜ  )r7   rÒ  rÔ  s      r+   r¶  z'MimiSplitResidualVectorQuantizer.decodep  s   € ð ×?Ñ?×FÑFÀuÊQÐPnÐRV×RnÑRnÐPnÐMnÑGoÓpˆð �;‰;�q‰>˜D×8Ñ8Ò8Ø˜T×DÑD×KÑKÈEÒRSÐUY×UqÑUqÑUsÐRsÑLtÓuÑuˆMØÐr*   r‡   )r!   r"   r#   r$   r   r9   r%   rY   r­   r²  r¶  r®   r¯   s   @r+   rÖ  rÖ  D  sX   ø„ Ù*ð
t˜zõ 
tñ §¡ð ¸uÀt¹|ð ÐW\×WcÑWcó ð:	˜EŸL™Lð 	¨U¯\©\÷ 	r*   rÖ  c                   ó„   ‡ — e Zd ZU eed<   dZdZdZdZddgZ	dgZ
dZdZdZdZdZ ej"                  «       ˆ fd	„«       Zˆ xZS )
ÚMimiPreTrainedModelrz   ÚmimiÚinput_valuesÚaudioTrÖ  rp  re  c                 óŠ  •— t         ‰| �  |«       t        |t        j                  t        j
                  f«      rŒt        j                  |j                  «       |j                  �`t        j                  |j                  |j                  |j                  d   z  z  «      }t        j                  |j                  | |¬«       yyt        |t         «      r5t        j"                  |j$                  | j&                  j(                  «       yt        |t*        «      rº|j,                  j                  d   }|j,                  j.                  d   }|j,                  j0                  d   }|dz
  |z  dz   }t        j"                  |j.                  |«       t        j"                  |j                  |«       t        j"                  |j2                  ||z
  «       yt        |t4        «      r^t        j6                  |j8                  «       t        j6                  |j:                  «       t        j<                  |j>                  «       yy)zInitialize the weightsNr   )ÚaÚbr   ) rn   Ú_init_weightsrÐ   r   rs   rµ   ÚinitÚkaiming_normal_Úweightrf   r¶   r]  rd   rI   ra   Úuniform_rñ   Ú	constant_r÷   rz   rô   r_   rt   rb   rc   rl   rž  Úones_r¡  r¢  Úzeros_r£  )r7   rD  r,  ra   rb   rc   r{   s         €r+   rë  z!MimiPreTrainedModel._init_weightsŒ  s–  ø€ ô 	‰Ñ˜fÔ%Ü�fœrŸy™y¬"×*<Ñ*<Ð=Ô>Ü× Ñ  §¡Ô/Ø�{‰{Ð&Ü—I‘I˜fŸm™m¨v×/AÑ/AÀF×DVÑDVÐWXÑDYÑ/YÑZÓ[�Ü—‘˜fŸk™k¨a¨R°1Ö5ð 'ô ˜¤Ô/Ü�N‰N˜6Ÿ<™<¨¯©×)NÑ)NÕOÜ˜¤
Ô+Ø Ÿ+™+×1Ñ1°!Ñ4ˆKØ—[‘[×'Ñ'¨Ñ*ˆFØ—{‘{×+Ñ+¨AÑ.ˆHØ&¨™?¨hÑ6¸Ñ:ˆKÜ�N‰N˜6Ÿ=™=¨&Ô1Ü�N‰N˜6×-Ñ-¨{Ô;Ü�N‰N˜6×/Ñ/°¸vÑ1EÕFÜ˜Ô 5Ô6Ü�J‰J�v×)Ñ)Ô*Ü�J‰J�v×+Ñ+Ô,Ü�K‰K˜×(Ñ(Õ)ð 7r*   )r!   r"   r#   r   r'   Úbase_model_prefixÚmain_input_nameÚinput_modalitiesÚsupports_gradient_checkpointingÚ_no_split_modulesÚ_skip_keys_device_placementÚ_supports_flash_attnÚ_supports_sdpaÚ_supports_flex_attnÚ_supports_attention_backendÚ_can_compile_fullgraphr%   r$  rë  r®   r¯   s   @r+   rä  rä  |  sl   ø… àÓØÐØ$€OØÐØ&*Ð#Ø;Ð=SÐTÐØ#4Ð"5ÐØÐØ€NØÐØ"&Ðà!Ðà€U‡]�]ƒ_ó*ó ô*r*   rä  z,
    The Mimi neural audio codec model.
    )Úcustom_introc                   ó˜  ‡ — e Zd Zdefˆ fd„Z	 	 	 	 ddej                  dedededz  de	dz  d	e
dz  d
e
dz  deej                  ej                  dz  f   fd„Zdej                  dej                  fd„Zddej                  defd„Z	 	 	 	 	 	 ddej                  dej                  dz  dedz  dedz  de	dz  d	e
dz  d
e
dz  deej                  ej                  dz  f   ez  fd„Z	 	 ddej                  dedz  d
e
dz  dej                  fd„Z	 	 	 ddej                  dej                  dz  dedz  d
e
dz  deej                  ej                  f   ez  f
d„Ze	 	 	 	 	 	 ddej                  dej                  dz  dedz  dej                  dz  dedz  dedz  d
e
dz  deej                  ej                  f   ez  fd„«       Zˆ xZS )Ú	MimiModelrz   c                 ó˜  •— t         ‰| �  |«       || _        t        |«      | _        t        |«      | _        d | _        d | _        |j                  |j                  k7  rÄt        ||j                  |j                  dt        |j                  |j                  z  «      z  dddt        | j                  j                  «      ¬«      | _        t!        ||j                  |j                  dt        |j                  |j                  z  «      z  dd|j"                  ¬«      | _        t        |«      | _        t'        |«      | _        t+        |«      | _        t        t/        j0                  | j                  j2                  «      «      | _        d| j4                  z  | j                  j2                  k7  rt7        d«      ‚| j9                  «        y )Nrm   FrA   )ra   rb   rf   re   r;   )ra   rb   rf   rd   z'The codebook_size must be a power of 2.)rn   r9   rz   rÔ   Úencoderr�  Úencoder_transformerÚ
downsampleÚupsamplerÅ  Úencodec_frame_rater_   rà   rV   r3   rã   r±   Úupsample_groupsÚdecoder_transformerrš  ÚdecoderrÖ  Ú	quantizerr¶   Úlog2r¤  Úbits_per_codebookr5   Ú	post_initr;  s     €r+   r9   zMimiModel.__init__«  sx  ø€ Ü‰Ñ˜Ô ØˆŒä" 6Ó*ˆŒÜ#7¸Ó#?ˆÔ àˆŒØˆŒØ×Ñ × 9Ñ 9Ò9Ü(ØØ×"Ñ"Ø×"Ñ"Ø¤ F×$=Ñ$=À×@QÑ@QÑ$QÓ RÑRØØØ$Ü˜dŸl™l×BÑBÓCô	ˆDŒOô 0ØØ×"Ñ"Ø×"Ñ"Ø¤ F×$=Ñ$=À×@QÑ@QÑ$QÓ RÑRØØØ×-Ñ-ôˆDŒMô $8¸Ó#?ˆÔ Ü" 6Ó*ˆŒä9¸&ÓAˆŒä!$¤T§Y¡Y¨t¯{©{×/HÑ/HÓ%IÓ!JˆÔØˆd×$Ñ$Ñ$¨¯©×(AÑ(AÒAÜÐFÓGÐGð 	�‰Õr*   Nræ  rÃ  Úpadding_maskre  r6   Úuse_streamingr‡  rŒ   c                 óv  — | j                  ||¬«      }| j                  |j                  dd«      |||¬«      }	|r|	j                  d«      }nt	        |	«      dkD  r|	d   }|	d   j                  dd«      }| j                  ||¬«      }| j                  j                  ||«      }
|
j                  dd«      }
|
||fS )z€
        Encodes the given input using the underlying VQVAE. The padding mask is required to compute the correct scale.
        rÏ   r   rm   )re  r|  r‡  re  r   )r  r  r  Úgetr3   r  r
  r²  )r7   ræ  rÃ  r  re  r6   r  r‡  rÊ  Úencoder_outputsrÒ  s              r+   Ú_encode_framezMimiModel._encode_frameÖ  sÏ   € ð —\‘\ ,¸m�\ÓLˆ
ð ×2Ñ2Ø× Ñ   AÓ&Ø+Ø#Ø#ð	 3ó 
ˆñ Ø-×1Ñ1Ð2CÓD‰OÜ�Ó! AÒ%Ø-¨aÑ0ˆOØ$ QÑ'×1Ñ1°!°QÓ7ˆ
Ø—_‘_ Z¸}�_ÓMˆ
à—‘×%Ñ% j°.ÓAˆØ—‘  1Ó%ˆØ�o }Ð4Ð4r*   r    c                 óÊ   — |}| j                   j                  D ],  }| j                   j                  |«      j                  |«      }Œ. | j                  j                  |«      }|S )zL
        Return the number of frames of the encoded audio waveform.
        )r  rã   rä   r¤   r  )r7   r    r£   Ú
layer_names       r+   Úget_encoded_lengthzMimiModel.get_encoded_lengthù  sb   € ð %ˆð Ÿ,™,×>Ñ>ò 	eˆJØ ŸL™L×6Ñ6°zÓB×UÑUÐVcÓd‰Mð	eð Ÿ™×:Ñ:¸=ÓIˆàÐr*   Úpadding_sidec                 óf  — | j                  |j                  d¬«      «      }t        j                  |j	                  «       |j
                  ¬«      j                  t        |«      d«      }||j                  d«      k  }|j                  |j
                  «      }|dk(  r|S |j                  dg¬«      S )zR
        Get the mask for the audio codes from the original padding mask.
        rM   rN   r‰  r   Úright)Údims)r  Úsumr%   r  rP   r?   r  r3   r*  r�   Úflip)r7   r  r  Úencoded_lengthsÚaudio_codes_masks        r+   Úget_audio_codes_maskzMimiModel.get_audio_codes_mask  sª   € ð ×1Ñ1°,×2BÑ2BÀrÐ2BÓ2JÓKˆä Ÿ<™<¨×(;Ñ(;Ó(=Ào×F\ÑF\Ô]×dÑdÜ�Ó  "ó
Ðð ,¨o×.GÑ.GÈÓ.JÑJÐØ+×.Ñ.¨|×/BÑ/BÓCÐà˜7Ò"Ø#Ð#à#×(Ñ(¨r¨dÐ(Ó3Ð3r*   r   c           	      óô  — |�|n| j                   j                  }|�|n| j                   j                  }|€| j                   j                  n|}|| j                   j                  kD  r&t	        d| j                   j                  › d|› d�«      ‚|j
                  \  }}	}
|	dk  s|	dkD  rt	        d|	› �«      ‚|€#t        j                  |«      j                  «       }|�r^|�€[g g g }}}| j                  j                  D ]ž  }|j                  | j                  j                  |«      j                  «       |j                  | j                  j                  |«      j                  «       |j                  | j                  j                  |«      j                  «       Œ  |j                  | j                   j                  «       |j                  | j                   j                  «       |j                  | j                   j                  «       t#        t%        | j                  j                  «      dz   |||¬«      }| j'                  |||j                  «       ||||¬«      \  }}}|s|||fS t)        |||«      S )	aE  
        Encodes the input audio waveform into discrete codes.

        Args:
            input_values (`torch.Tensor` of shape `(batch_size, channels, sequence_length)`):
                Float values of the input audio waveform.
            padding_mask (`torch.Tensor` of shape `(batch_size, channels, sequence_length)`):
                Indicates which inputs are to be ignored due to padding, where elements are either 1 for *not masked* or 0
                for *masked*.
            num_quantizers (`int`, *optional*):
                Number of quantizers (i.e codebooks) to use. By default, all quantizers are used.
            encoder_past_key_values (`Cache`, *optional*):
                Pre-computed hidden-states (key and values in the self-attention blocks) that can be used to speed up sequential decoding of the encoder transformer.
                This typically consists in the `past_key_values` returned by the model at a previous stage of decoding, when `use_cache=True` or `config.use_cache=True`.

                The model will output the same cache format that is fed as input.

                If `past_key_values` are used, the user can optionally input only the last `audio_values` or `audio_codes (those that don't
                have their past key value states given to this model).
            return_dict (`bool`, *optional*):
                Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.

        Returns:
            `codebook` of shape `[batch_size, num_codebooks, frames]`, the discrete encoded codes for the input audio waveform.
        rÞ  rß  rà  r   rm   z1Number of audio channels must be 1 or 2, but got )r.   r/   r0   r1   )re  r6   r  r‡  )rz   r‡  r  rÃ  r5   rB   r%   Ú	ones_likerª   r  rã   rß   rä   rl   re   rI   r  r-   r3   r  r[   )r7   ræ  r  rÃ  r   r6   r  r‡  rÉ  rø   r    r/   r0   r1   r  Úencoded_framess                   r+   r²  zMimiModel.encode  sƒ  € ðF &1Ð%<‘kÀ$Ç+Á+×BYÑBYˆØ)6Ð)B™ÈÏÉ×HaÑHaˆà7EÐ7M˜Ÿ™×3Ò3ÐSaˆà˜DŸK™K×6Ñ6Ò6ÜØuÐvz÷  wBñ  wB÷  wQñ  wQð  vRð  Reð  ftð  euð  uvð  wóð ð %1×$6Ñ$6Ñ!ˆˆ8�\à�aŠ<˜8 aš<ÜÐPÐQYÐPZÐ[Ó\Ð\àÐÜ Ÿ?™?¨<Ó8×=Ñ=Ó?ˆLâ˜]Ñ2ØOQÐSUÐWYÐ7LÐ5ÐØ"Ÿl™l×BÑBò a�
Ø!×(Ñ(¨¯©×)CÑ)CÀJÓ)O×)]Ñ)]Ô^Ø&×-Ñ-¨d¯l©l×.HÑ.HÈÓ.T×.]Ñ.]Ô^Ø%×,Ñ,¨T¯\©\×-GÑ-GÈ
Ó-S×-_Ñ-_Õ`ðað ×$Ñ$ T§_¡_×%BÑ%BÔCØ"×)Ñ)¨$¯/©/×*BÑ*BÔCØ!×(Ñ(¨¯©×)DÑ)DÔEä2Ü˜tŸ|™|×CÑCÓDÀqÑHØ"3Ø'=Ø&;ô	ˆMð BF×ASÑASØØØ×ÑÓØ3Ø'Ø'Ø#ð BTó B
Ñ>ˆÐ/°ñ àØ'Øðð ô ! Ð1HÈ-ÓXÐXr*   rÒ  c                 óD  — | j                   j                  |«      }| j                  |«      }| j                  |j	                  dd«      ||¬«      }|r|j                  d«      }nt        |«      dkD  r|d   }|d   j	                  dd«      }| j                  |«      }||fS )Nr   rm   ©re  r‡  re  r   )r
  r¶  r  r  r  r  r3   r	  )r7   rÒ  re  r‡  rÊ  Údecoder_outputsr  s          r+   Ú_decode_framezMimiModel._decode_framet  s­   € ð —^‘^×*Ñ*¨5Ó1ˆ
à—]‘] :Ó.ˆ
Ø×2Ñ2Ø× Ñ   AÓ&¸ÐU`ð 3ó 
ˆñ Ø-×1Ñ1Ð2CÓD‰OÜ�Ó! AÒ%Ø-¨aÑ0ˆOØ$ QÑ'×1Ñ1°!°QÓ7ˆ
Ø—,‘,˜zÓ*ˆØ˜Ð'Ð'r*   r   r    c                 óö   — |�|n| j                   j                  }| j                  |||¬«      \  }}|�5|j                  d   |j                  d   k  r|dd|j                  d   …f   }|s||fS t	        ||«      S )aÊ  
        Decodes the given frames into an output audio waveform.

        Note that the output might be a bit bigger than the input. In that case, any extra steps at the end can be
        trimmed.

        Args:
            audio_codes (`torch.LongTensor`  of shape `(batch_size, num_quantizers, codes_length)`, *optional*):
                Discrete code embeddings computed using `model.encode`.
            padding_mask (`torch.Tensor` of shape `(batch_size, channels, sequence_length)`):
                Indicates which inputs are to be ignored due to padding, where elements are either 1 for *not masked* or 0
                for *masked*.
            decoder_past_key_values (`Cache`, *optional*):
                Pre-computed hidden-states (key and values in the self-attention blocks) that can be used to speed up sequential decoding of the decoder transformer.
                This typically consists in the `past_key_values` returned by the model at a previous stage of decoding, when `use_cache=True` or `config.use_cache=True`.

                The model will output the same cache format that is fed as input.

                If `past_key_values` are used, the user can optionally input only the last `audio_values` or `audio_codes (those that don't
                have their past key value states given to this model).
            return_dict (`bool`, *optional*):
                Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.

        Nr$  rM   .)rz   r‡  r&  rB   r]   )r7   r   r  r    r‡  r   s         r+   r¶  zMimiModel.decodeˆ  s§   € ð> &1Ð%<‘kÀ$Ç+Á+×BYÑBYˆà04×0BÑ0BØÐ)@Èkð 1Có 1
Ñ-ˆÐ-ð
 Ð#¨×(:Ñ(:¸2Ñ(>À×ASÑASÐTVÑAWÒ(WØ'¨Ð-E¨|×/AÑ/AÀ"Ñ/EÐ-EÐ(EÑFˆLáàØ'ðð ô ! Ð/FÓGÐGr*   c                 ó¸  — |�|n| j                   j                  }|€#t        j                  |«      j	                  «       }|€B| j                  |||||¬«      }	|	d   }|r|	j                  d«      }nt        |	«      dkD  r|	d   }| j                  ||||¬«      }
|
d   }|r|
j                  d«      }nt        |
«      dkD  r|
d   }|s||||fS t        ||||¬«      S )aº
  
        input_values (`torch.FloatTensor` of shape `(batch_size, channels, sequence_length)`, *optional*):
            Raw audio input converted to Float.
        padding_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
            Indicates which inputs are to be ignored due to padding, where elements are either 1 for *not masked* or 0
            for *masked*.
        num_quantizers (`int`, *optional*):
            Number of quantizers (i.e codebooks) to use. By default, all quantizers are used.
        audio_codes (`torch.LongTensor`  of shape `(batch_size, num_quantizers, codes_length)`, *optional*):
            Discrete code embeddings computed using `model.encode`.
        encoder_past_key_values (`Cache`, *optional*):
            Pre-computed hidden-states (key and values in the self-attention blocks) that can be used to speed up sequential decoding of the encoder transformer.
            This typically consists in the `past_key_values` returned by the model at a previous stage of decoding, when `use_cache=True` or `config.use_cache=True`.

            The model will output the same cache format that is fed as input.

            If `past_key_values` are used, the user can optionally input only the last `audio_values` or `audio_codes (those that don't
            have their past key value states given to this model).
        decoder_past_key_values (`Cache`, *optional*):
            Pre-computed hidden-states (key and values in the self-attention blocks) that can be used to speed up sequential decoding of the decoder transformer.
            This typically consists in the `past_key_values` returned by the model at a previous stage of decoding, when `use_cache=True` or `config.use_cache=True`.

            The model will output the same cache format that is fed as input.

            If `past_key_values` are used, the user can optionally input only the last `audio_values` or `audio_codes (those that don't
            have their past key value states given to this model).

        Examples:

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

        >>> dataset = load_dataset("hf-internal-testing/ashraq-esc50-1-dog-example")
        >>> audio_sample = dataset["train"]["audio"][0]["array"]

        >>> model_id = "kyutai/mimi"
        >>> model = MimiModel.from_pretrained(model_id)
        >>> feature_extractor = AutoFeatureExtractor.from_pretrained(model_id)

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

        >>> outputs = model(**inputs)
        >>> audio_codes = outputs.audio_codes
        >>> audio_values = outputs.audio_values
        ```)r‡  r   re  r   )r   r   r   r    )
rz   r‡  r%   r!  rª   r²  r  r3   r¶  r   )r7   ræ  r  rÃ  r   r   r    r‡  rI  r  r%  r   s               r+   r§   zMimiModel.forward¸  s  € ðt &1Ð%<‘kÀ$Ç+Á+×BYÑBYˆàÐÜ Ÿ?™?¨<Ó8×=Ñ=Ó?ˆLàÐØ"Ÿk™kØ˜l¨NÐ<SÐalð *ó ˆOð *¨!Ñ,ˆKÙØ*9×*=Ñ*=Ð>OÓ*PÑ'Ü�_Ó%¨Ò)Ø*9¸!Ñ*<Ð'àŸ+™+ k°<ÐAXÐfq˜+ÓrˆØ& qÑ)ˆÙØ&5×&9Ñ&9Ð:KÓ&LÑ#Ü�Ó! AÒ%Ø&5°aÑ&8Ð#áØ Ð/FÐH_Ð`Ð`äØ#Ø%Ø$;Ø$;ô	
ð 	
r*   )NNNN)r  )NNNNNN)NNr#  )r!   r"   r#   r   r9   r%   rY   rV   r
   r-   rª   r¬   r  r&   r  rX   r  r­   r[   r²  r&  r]   r¶  r   r   r§   r®   r¯   s   @r+   r   r   ¥  s  ø„ ð)˜zõ )ð` )-Ø7;Ø%)Ø#'ñ!5à—l‘lð!5ð ð!5ð ð	!5ð
  ™ð!5ð .°Ñ4ð!5ð ˜d‘{ð!5ð ˜D‘[ð!5ð 
ˆu�|‰|˜UŸ\™\¨DÑ0Ð0Ñ	1ó!5ðF¨u×/?Ñ/?ð ÀE×DTÑDTó ñ4°·±ð 4ÈSó 4ð( -1Ø'+Ø04Ø7;Ø%)Ø#'ñYYà—l‘lðYYð —l‘l TÑ)ðYYð  ™ð	YYð
 "'¨¡ðYYð .°Ñ4ðYYð ˜d‘{ðYYð ˜D‘[ðYYð 
ˆu�|‰|˜UŸ\™\¨DÑ0Ð0Ñ	1Ð4EÑ	EóYYð| )-Ø#'ñ	(à�|‰|ð(ð  ™ð(ð ˜D‘[ð	(ð
 
�‰ó(ð. -1Ø04Ø#'ñ.Hà—\‘\ð.Hð —l‘l TÑ)ð.Hð "'¨¡ð	.Hð
 ˜D‘[ð.Hð 
ˆu�|‰|˜UŸ\™\Ð)Ñ	*Ð->Ñ	>ó.Hð` ð -1Ø%)Ø+/Ø04Ø04Ø#'ñW
à—l‘lðW
ð —l‘l TÑ)ðW
ð ˜d™
ð	W
ð
 —\‘\ DÑ(ðW
ð "'¨¡ðW
ð "'¨¡ðW
ð ˜D‘[ðW
ð 
ˆu�|‰|˜UŸ\™\Ð)Ñ	*¨ZÑ	7òW
ó ôW
r*   r   )r   )r©   )Jr$   r¶   Úcollections.abcr   Údataclassesr   Útypingr   r%   r   Ú r   rì  Úactivationsr	   Úcache_utilsr
   r   Úmasking_utilsr   Úmodeling_layersr   Úmodeling_outputsr   Úmodeling_rope_utilsr   r   Úmodeling_utilsr   r   Úprocessing_utilsr   r€   r   r   r   r   Úutils.genericr   Úconfiguration_mimir   Ú
get_loggerr!   rq   r   r-   r[   r]   ÚModuler_   r±   r»   rÔ   rñ   rý   r(  r0  r2  rY   rV   rC  r­   rV  rX  rp  r�  rš  rž  r¹  rÂ  rÖ  rä  r   Ú__all__r)   r*   r+   ú<module>r:     sÄ  ðñ ã Ý $Ý !Ý ã Ý å &Ý !ß .Ý >Ý 9Ý 7ß Kß FÝ &ß MÓ MÝ +Ý *ð 
ˆ×	Ñ	˜HÓ	%€ð Ø
ô1�ó 1ó ó ð1÷<[ñ [ð| Ø
ô8˜ó 8ó ó ð8ð* Ø
ô1˜ó 1ó ó ð1ô$I�—‘ô IôX7˜"Ÿ)™)ô 7ôt'(�b—i‘iô '(ôT*�"—)‘)ô *ôZ�R—Y‘Yô ô ><˜"Ÿ)™)ô ><òD(óô2ˆb�i‰iô ð"	U˜UŸ\™\ð 	U°#ð 	U¸%¿,¹,ó 	Uð( ñ%Ø�I‰Ið%à�<‰<ð%ð 
�‰ð%ð �<‰<ð	%ð
 —L‘L 4Ñ'ð%ð ð%ð ð%ð Ð'Ñ(ó%ô2E)�B—I‘Iô E)ôP2Ð5ô 2ôjR
˜2Ÿ9™9ô R
ôj�"—)‘)ô ôB*˜BŸI™Iô *ô\˜RŸY™Yô ô(3 "§)¡)ô 3ôl5 r§y¡yô 5ðp ô%*˜/ó %*ó ð%*ñP ðôô
f
Ð#ó f
óð
f
ðR Ð-Ð
.�r*   