# Mimi

[Mimi](https://huggingface.co/papers/2410.00037) es un modelo de códec de audio neuronal con variantes preentrenadas y cuantizadas, diseñado para la representación y compresión eficientes del habla. El modelo opera a 1,1 kbps con una tasa de fotogramas de 12 Hz y utiliza una arquitectura de codificador-decodificador convolucional combinada con un cuantizador vectorial residual de 16 libros de códigos. Mimi genera flujos duales de tokens, es decir, semánticos y acústicos, para equilibrar la riqueza lingüística con la reconstrucción de alta fidelidad. Sus características principales incluyen un codificador de streaming causal para un uso de baja latencia, una tokenización de doble vía para una generación flexible aguas abajo y una preparación para la integración con modelos de habla de gran escala como Moshi.

Puedes encontrar los checkpoints originales de Mimi bajo la organización [Kyutai](https://huggingface.co/kyutai/models?search=mimi).

>[!TIP]
> Este modelo fue aportado por [ylacombe](https://huggingface.co/ylacombe).
>
> Haz clic en los modelos Mimi en la barra lateral derecha para ver más ejemplos de cómo aplicar Mimi.

El siguiente ejemplo demuestra cómo codificar y decodificar audio con la clase [AutoModel](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoModel).

```python
from datasets import Audio, load_dataset

from transformers import AutoFeatureExtractor, MimiModel

librispeech_dummy = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")

# load model and feature extractor
model = MimiModel.from_pretrained("kyutai/mimi", device_map="auto")
feature_extractor = AutoFeatureExtractor.from_pretrained("kyutai/mimi")

# load audio sample
librispeech_dummy = librispeech_dummy.cast_column("audio", Audio(sampling_rate=feature_extractor.sampling_rate))
audio_sample = librispeech_dummy[-1]["audio"]["array"]
inputs = feature_extractor(raw_audio=audio_sample, sampling_rate=feature_extractor.sampling_rate, return_tensors="pt").to(model.device)

encoder_outputs = model.encode(inputs["input_values"], inputs["padding_mask"])
audio_values = model.decode(encoder_outputs.audio_codes, inputs["padding_mask"])[0]
# or the equivalent with a forward pass
audio_values = model(inputs["input_values"], inputs["padding_mask"]).audio_values
```

## MimiConfig[[transformers.MimiConfig]]

#### transformers.MimiConfig[[transformers.MimiConfig]]

```python
transformers.MimiConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, sampling_rate: int = 24000, audio_channels: int = 1, hidden_size: int = 512, num_filters: int = 64, num_residual_layers: int = 1, upsampling_ratios: list[int] | None = None, kernel_size: int = 7, last_kernel_size: int = 3, residual_kernel_size: int = 3, dilation_growth_rate: int = 2, use_causal_conv: bool = True, pad_mode: str = 'constant', compress: int = 2, trim_right_ratio: float = 1.0, codebook_size: int = 2048, codebook_dim: int = 256, num_quantizers: int = 32, use_conv_shortcut: bool = False, vector_quantization_hidden_dimension: int = 256, num_semantic_quantizers: int = 1, upsample_groups: int = 512, num_hidden_layers: int = 8, intermediate_size: int = 2048, num_attention_heads: int = 8, num_key_value_heads: int = 8, head_dim: int | None = None, hidden_act: str = 'gelu', max_position_embeddings: int = 8000, initializer_range: float = 0.02, norm_eps: float = 1e-05, use_cache: bool = False, use_streaming: bool = False, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, sliding_window: int = 250, attention_dropout: float | int = 0.0, layer_scale_initial_scale: float = 0.01, attention_bias: bool = False, tie_word_embeddings: bool = True)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/mimi/configuration_mimi.py#L28)

**Parámetros:**

sampling_rate (`int`, *opcional*, valor predeterminado `24000`) : La frecuencia de muestreo a la que deben digitalizarse los archivos de audio, expresada en hercios (Hz).

audio_channels (`int`, *opcional*, valor predeterminado 1) : Número de canales en los datos de audio. Puede ser 1 para mono o 2 para estéreo.

hidden_size (`int`, *opcional*, valor predeterminado `512`) : Dimensión de las representaciones ocultas.

num_filters (`int`, *opcional*, valor predeterminado 64) : Número de núcleos de convolución de la primera capa de muestreo por reducción `MimiConv1d`.

num_residual_layers (`int`,  *opcional*, valor predeterminado 1) : Número de capas residuales.

upsampling_ratios (`Sequence[int]`, *opcional*) : Relaciones de tamaño y paso del kernel. El codificador utiliza relaciones de muestreo descendente en lugar de relaciones de muestreo ascendente, por lo que utilizará las relaciones en el orden inverso al especificado aquí, que debe coincidir con el orden del decodificador. Si no se especifica, el valor predeterminado será `[8, 6, 5, 4]`

kernel_size (`int`, *opcional*, valor predeterminado `7`) : El tamaño del kernel de convolución.

last_kernel_size (`int`, *opcional*, valor predeterminado 3) : Tamaño del kernel para la última capa de convolución.

residual_kernel_size (`int`, *opcional*, valor predeterminado 3) : Tamaño del kernel para las capas residuales.

dilation_growth_rate (`int`, *opcional*, valor predeterminado 2) : Cuánto aumentar la dilatación en cada capa.

use_causal_conv (`bool`, *opcional*, valor predeterminado `True`) : Si se debe usar convolución totalmente causal.

pad_mode (`str`, *opcional*, valor predeterminado `"constant"`) : Modo de relleno para las convoluciones.

compress (`int`, *opcional*, valor predeterminado 2) : Dimensionalidad reducida en las ramas residuales.

trim_right_ratio (`float`, *opcional*, valor predeterminado 1.0) : Proporción para el recorte en la parte derecha de la convolución transpuesta bajo la configuración `use_causal_conv = True`. Si es igual a 1.0, significa que todo el recorte se realiza en la parte derecha.

codebook_size (`int`, *opcional*, valor predeterminado `2048`) : El número de libros de códigos paralelos utilizados por el modelo.

codebook_dim (`int`, *opcional*, valor predeterminado `256`) : Dimensionalidad de cada vector de incrustación del libro de códigos.

num_quantizers (`int`, *opcional*, valor predeterminado: 32) : Número de canales del cuantizador, o libros de códigos, en el cuantizador.

use_conv_shortcut (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe usar una capa convolucional como conexión 'skip' en el bloque `MimiResnetBlock`. Si es False, se utilizará una función identidad, lo que proporciona una conexión residual genérica.

vector_quantization_hidden_dimension (`int`, *opcional*, valor predeterminado 256) : Dimensión de la representación intermedia en el espacio de cuantización vectorial residual.

num_semantic_quantizers (`int`, *opcional*, valor predeterminado: 1) : Número de canales de cuantizador semántico, o libros de códigos, en el cuantizador semántico. Debe ser menor que `num_quantizers`.

upsample_groups (`int`, *opcional*, valor predeterminado 512) : Si `frame_rate!=encodec_frame_rate`, indica el número de grupos utilizados en la operación de remuestreo ascendente para pasar de una tasa a otra.

num_hidden_layers (`int`, *opcional*, valor predeterminado `8`) : Número de capas ocultas en el decodificador del Transformer.

intermediate_size (`int`, *opcional*, valor predeterminado `2048`) : Dimensión de las representaciones MLP.

num_attention_heads (`int`, *opcional*, valor predeterminado `8`) : Número de cabezas de atención para cada capa de atención en el decodificador del Transformer.

num_key_value_heads (`int`, *opcional*, valor predeterminado `8`) : Este es el número de cabezas de key_value que se deben utilizar para implementar Grouped Query Attention. Si `num_key_value_heads=num_attention_heads`, el modelo utilizará Multi Head Attention (MHA); si `num_key_value_heads=1`, el modelo utilizará Multi Query Attention (MQA); en caso contrario, se utilizará GQA. Al convertir un checkpoint multi-head a un checkpoint GQA, cada cabeza de key y value del grupo debe construirse mediante el promediado (meanpooling) de todas las cabezas originales dentro de ese grupo. Para más detalles, consulta [este artículo](https://huggingface.co/papers/2305.13245). Si no se especifica, el valor predeterminado será `num_attention_heads`.

head_dim (`int`, *opcional*) : La dimensión de la cabeza de atención. Si es None, se establecerá en hidden_size // num_attention_heads

hidden_act (`str`, *opcional*, valor predeterminado `gelu`) : La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

max_position_embeddings (`int`, *opcional*, valor predeterminado `8000`) : La longitud máxima de secuencia con la que se podría utilizar este modelo.

initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos.

norm_eps (`float`, *opcional*, valor predeterminado `1e-05`) : El epsilon utilizado por las capas de normalización de capas.

use_cache (`bool`, *opcional*, valor predeterminado `False`) : Indica si el modelo debe devolver las últimas atenciones de claves/valores (no utilizado por todos los modelos). Solo es relevante si `config.is_decoder=True` o cuando el modelo es un modelo generativo solo de decodificador.

use_streaming (`bool`, *opcional*, valor predeterminado `False`) : Si se debe usar el modo de streaming. Si es `True`, el método de codificación del modelo devolverá la caché de relleno que se puede usar en una llamada posterior al método de codificación.

rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *opcional*) : Diccionario que contiene los parámetros de configuración para las incrustaciones RoPE. El diccionario debe contener un valor para `rope_theta` y, opcionalmente, parámetros utilizados para el escalado en caso de que desee usar RoPE con `max_position_embeddings` más largas.

sliding_window (`int`, *opcional*, valor predeterminado `250`) : Tamaño de la ventana de atención deslizante. Si es `None`, no se aplica ninguna ventana deslizante.

attention_dropout (`Union[float, int]`, *opcional*, valor predeterminado `0.0`) : La proporción de dropout para las probabilidades de atención.

layer_scale_initial_scale (`float`, *opcional*, valor predeterminado `0.01`) : Escala a utilizar en las capas de autoatención. 0.1 para base, 1e-6 para grande. Establezca 0 para deshabilitar la escala de capa.

attention_bias (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe usar un sesgo en las capas de proyección de consulta, clave, valor y salida durante la autoatención.

tie_word_embeddings (`bool`, *opcional*, valor predeterminado `True`) : Indica si se deben vincular las incrustaciones de pesos según el mapeo `tied_weights_keys` del modelo.

Esta es la clase de configuración para almacenar la configuración de un MimiModel. Se utiliza para instanciar un modelo Mimi según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [kyutai/mimi](https://huggingface.co/kyutai/mimi)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

Ejemplo:

```python
>>> from transformers import MimiModel, MimiConfig

>>> # Initializing a "kyutai/mimi" style configuration
>>> configuration = MimiConfig()

>>> # Initializing a model (with random weights) from the "kyutai/mimi" style configuration
>>> model = MimiModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## MimiEncoderConfig[[transformers.MimiEncoderConfig]]

#### transformers.MimiEncoderConfig[[transformers.MimiEncoderConfig]]

```python
transformers.MimiEncoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, sampling_rate: int = 24000, audio_channels: int = 1, hidden_size: int = 512, num_filters: int = 64, num_residual_layers: int = 1, upsampling_ratios: list[int] | None = None, kernel_size: int = 7, last_kernel_size: int = 3, residual_kernel_size: int = 3, dilation_growth_rate: int = 2, use_causal_conv: bool = True, pad_mode: str = 'constant', compress: int = 2, trim_right_ratio: float = 1.0, codebook_size: int = 2048, codebook_dim: int = 256, num_quantizers: int = 32, use_conv_shortcut: bool = False, vector_quantization_hidden_dimension: int = 256, num_semantic_quantizers: int = 1, upsample_groups: int = 512, num_hidden_layers: int = 8, intermediate_size: int = 2048, num_attention_heads: int = 8, num_key_value_heads: int = 8, head_dim: int | None = None, hidden_act: str = 'gelu', max_position_embeddings: int = 8000, initializer_range: float = 0.02, norm_eps: float = 1e-05, use_cache: bool = False, use_streaming: bool = False, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, sliding_window: int = 250, attention_dropout: float | int = 0.0, layer_scale_initial_scale: float = 0.01, attention_bias: bool = False, tie_word_embeddings: bool = True)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/mimi/configuration_mimi.py#L249)

Configuración de la mitad codificadora de Mimi (codificador SEANet, transformador codificador y downsampling). Comparte todos los campos con [MimiConfig](/docs/transformers/v5.23.0/es/model_doc/mimi#transformers.MimiConfig) (consulte su documentación para conocer los argumentos), por lo que puede cargarse directamente desde un checkpoint completo de Mimi.

## MimiDecoderConfig[[transformers.MimiDecoderConfig]]

#### transformers.MimiDecoderConfig[[transformers.MimiDecoderConfig]]

```python
transformers.MimiDecoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, sampling_rate: int = 24000, audio_channels: int = 1, hidden_size: int = 512, num_filters: int = 64, num_residual_layers: int = 1, upsampling_ratios: list[int] | None = None, kernel_size: int = 7, last_kernel_size: int = 3, residual_kernel_size: int = 3, dilation_growth_rate: int = 2, use_causal_conv: bool = True, pad_mode: str = 'constant', compress: int = 2, trim_right_ratio: float = 1.0, codebook_size: int = 2048, codebook_dim: int = 256, num_quantizers: int = 32, use_conv_shortcut: bool = False, vector_quantization_hidden_dimension: int = 256, num_semantic_quantizers: int = 1, upsample_groups: int = 512, num_hidden_layers: int = 8, intermediate_size: int = 2048, num_attention_heads: int = 8, num_key_value_heads: int = 8, head_dim: int | None = None, hidden_act: str = 'gelu', max_position_embeddings: int = 8000, initializer_range: float = 0.02, norm_eps: float = 1e-05, use_cache: bool = False, use_streaming: bool = False, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, sliding_window: int = 250, attention_dropout: float | int = 0.0, layer_scale_initial_scale: float = 0.01, attention_bias: bool = False, tie_word_embeddings: bool = True)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/mimi/configuration_mimi.py#L277)

Configuración de la mitad decodificadora de Mimi (remuestreo, transformador decodificador y decodificador SEANet). Comparte todos los campos con [MimiConfig](/docs/transformers/v5.23.0/es/model_doc/mimi#transformers.MimiConfig) (consulte su documentación para conocer los argumentos), por lo que se puede cargar directamente desde un checkpoint completo de Mimi.

## MimiModel[[transformers.MimiModel]]

#### transformers.MimiModel[[transformers.MimiModel]]

```python
transformers.MimiModel(config: MimiConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/mimi/modeling_mimi.py#L1346)

**Parámetros:**

config ([MimiConfig](/docs/transformers/v5.23.0/es/model_doc/mimi#transformers.MimiConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo de códec de audio neuronal Mimi.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

#### decode[[transformers.MimiModel.decode]]

```python
decode(audio_codes: Tensor, padding_mask: typing.Optional[torch.Tensor] = None, decoder_past_key_values: transformers.cache_utils.Cache | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/mimi/modeling_mimi.py#L1430)

Decodifica los fotogramas dados en una forma de onda de audio de salida: los códigos se descuantizan en los latentes de [MimiDecoderModel.forward()](/docs/transformers/v5.23.0/es/model_doc/mimi#transformers.MimiDecoderModel.forward).

#### encode[[transformers.MimiModel.encode]]

```python
encode(input_values: Tensor, padding_mask: typing.Optional[torch.Tensor] = None, num_quantizers: float | None = None, encoder_past_key_values: transformers.cache_utils.Cache | None = None, padding_cache: transformers.models.mimi.modeling_mimi.MimiConv1dPaddingCache | None = None, use_streaming: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/mimi/modeling_mimi.py#L1394)

Codifica la forma de onda de audio de entrada en códigos discretos de forma `(batch_size, num_quantizers, frames)`: los latentes de [MimiEncoderModel.forward()](/docs/transformers/v5.23.0/es/model_doc/mimi#transformers.MimiEncoderModel.forward), cuantizados.

#### forward[[transformers.MimiModel.forward]]

```python
forward(input_values: Tensor, padding_mask: typing.Optional[torch.Tensor] = None, num_quantizers: int | None = None, audio_codes: typing.Optional[torch.Tensor] = None, encoder_past_key_values: transformers.cache_utils.Cache | None = None, decoder_past_key_values: transformers.cache_utils.Cache | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/mimi/modeling_mimi.py#L1453)

**Parámetros:**

input_values (`torch.Tensor` de forma `(batch_size, channels, sequence_length)`, *opcional*) : Entrada de audio sin procesar convertida a Float.

padding_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Indica qué entradas deben ignorarse debido al relleno, donde los elementos son 1 para *no enmascarado* o 0 para *enmascarado*.

num_quantizers (`int`, *opcional*) : Número de cuantizadores (es decir, libros de códigos) a utilizar. De forma predeterminada, se utilizan todos los cuantizadores.

audio_codes (`torch.LongTensor` de forma `(batch_size, num_quantizers, codes_length)`, *opcional*) : Incrustaciones de códigos discretos calculadas usando `model.encode`.

encoder_past_key_values (`Cache`, *opcional*) : Estados ocultos precalculados (claves y valores en los bloques de autoatención) que se pueden utilizar para acelerar la decodificación secuencial del transformador codificador. Esto suele consistir en los `past_key_values` devueltos por el modelo en una etapa anterior de la decodificación, cuando `use_cache=True` o `config.use_cache=True`. El modelo devolverá el mismo formato de caché que se le proporcione como entrada. Si se utilizan `past_key_values`, el usuario puede introducir opcionalmente solo los últimos `audio_values` o `audio_codes (aquellos que no tienen sus estados de clave y valor pasados proporcionados a este modelo).

decoder_past_key_values (`Cache`, *opcional*) : Estados ocultos precalculados (claves y valores en los bloques de autoatención) que se pueden utilizar para acelerar la decodificación secuencial del transformador decodificador. Esto suele consistir en los `past_key_values` devueltos por el modelo en una etapa anterior de la decodificación, cuando `use_cache=True` o `config.use_cache=True`. El modelo emitirá el mismo formato de caché que se le proporcione como entrada. Si se utilizan `past_key_values`, el usuario puede introducir opcionalmente solo los últimos `audio_values` o `audio_codes (aquellos que no tienen sus estados de clave y valor pasados proporcionados a este modelo).

**Devuelve:** `MimiOutput` o `tuple(torch.Tensor)`

Un `MimiOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([MimiConfig](/docs/transformers/v5.23.0/es/model_doc/mimi#transformers.MimiConfig)) y las entradas.

El método forward de [MimiModel](/docs/transformers/v5.23.0/es/model_doc/mimi#transformers.MimiModel) sobrescribe el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **audio_codes** (`torch.LongTensor` de forma `(batch_size, num_quantizers, codes_length)`, *opcional*) -- Incrustaciones de códigos discretos calculadas con `model.encode`.
- **audio_values** (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) -- Valores de audio decodificados, obtenidos utilizando la parte decodificadora de Mimi.
- **encoder_past_key_values** (`Cache`, *opcional*) -- Estados ocultos precalculados (claves y valores en los bloques de autoatención) que se pueden utilizar para acelerar la decodificación secuencial del transformador codificador. Esto suele consistir en `past_key_values` devueltos por el modelo en una etapa anterior de la decodificación, cuando `use_cache=True` o `config.use_cache=True`.

  El modelo generará el mismo formato de caché que se proporciona como entrada.

  Si se utilizan `past_key_values`, el usuario puede introducir opcionalmente solo los últimos `audio_values` o `audio_codes (aquellos que no tienen sus estados de valores clave pasados proporcionados a este modelo).
- **decoder_past_key_values** (`Cache`, *opcional*) -- Estados ocultos precalculados (claves y valores en los bloques de autoatención) que se pueden usar para acelerar la decodificación secuencial del transformador decodificador. Esto suele consistir en `past_key_values` devueltos por el modelo en una etapa anterior de la decodificación, cuando `use_cache=True` o `config.use_cache=True`.

  El modelo generará el mismo formato de caché que se proporciona como entrada.

  Si se utilizan `past_key_values`, el usuario puede introducir opcionalmente solo los últimos `audio_values` o `audio_codes (aquellos que no tienen sus estados de valores clave pasados proporcionados a este modelo).

Ejemplos:

```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
```

## MimiEncoderModel[[transformers.MimiEncoderModel]]

#### transformers.MimiEncoderModel[[transformers.MimiEncoderModel]]

```python
transformers.MimiEncoderModel(config: MimiEncoderConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/mimi/modeling_mimi.py#L1147)

**Parámetros:**

config ([MimiEncoderConfig](/docs/transformers/v5.23.0/es/model_doc/mimi#transformers.MimiEncoderConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

La mitad codificadora de Mimi: codificador SEANet, transformador codificador y muestreo descendente, desde audio hasta latentes continuos.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

#### forward[[transformers.MimiEncoderModel.forward]]

```python
forward(input_values: Tensor, padding_mask: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, padding_cache: transformers.models.mimi.modeling_mimi.MimiConv1dPaddingCache | None = None, use_streaming: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/mimi/modeling_mimi.py#L1208)

**Parámetros:**

input_values (`torch.Tensor` de forma `(batch_size, channels, sequence_length)`) : Valores flotantes de la forma de onda de audio de entrada.

padding_mask (`torch.Tensor` de forma `(batch_size, channels, sequence_length)`, *opcional*) : Indica qué entradas deben ignorarse debido al relleno, donde los elementos son 1 para *no enmascarado* o 0 para *enmascarado*.

past_key_values (`Cache`, *opcional*) : Estados ocultos precalculados (claves y valores en los bloques de autoatención) del transformador codificador, utilizados para acelerar la codificación en streaming.

padding_cache (`MimiConv1dPaddingCache`, *opcional*) : Caché de relleno de las convoluciones causales, utilizada para la codificación en streaming.

use_streaming (`bool`, *opcional*) : Si se debe codificar en modo de streaming, devolviendo las cachés para pasarlas a la siguiente llamada.

Codifica la forma de onda de audio de entrada en latentes continuos de forma `(batch_size, latent_dim, frames)`. --

**Devuelve:** `MimiEncoderModelOutput` o `tuple(torch.Tensor)`

Un `MimiEncoderModelOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([MimiConfig](/docs/transformers/v5.23.0/es/model_doc/mimi#transformers.MimiConfig)) y las entradas.

El método forward de [MimiEncoderModel](/docs/transformers/v5.23.0/es/model_doc/mimi#transformers.MimiEncoderModel) sobrescribe el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **latents** (`torch.Tensor` de forma `(batch_size, latent_dim, frames)`) -- Latentes continuos del audio, un fotograma por cada `config.frame_size` muestras de audio.
- **past_key_values** (`Cache`, *opcional*) -- Estados ocultos precalculados (claves y valores en los bloques de autoatención) del transformador codificador, devueltos durante la transmisión en streaming.
- **padding_cache** (`MimiConv1dPaddingCache`, *opcional*) -- Caché de relleno para las convoluciones causales de MimiConv1d, con el fin de admitir la transmisión en streaming mediante el relleno de la caché.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando `output_hidden_states=True`) -- Estados ocultos del transformador codificador en la salida de cada capa más su entrada.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando `output_attentions=True`) -- Pesos de atención de cada capa del transformador codificador.

## MimiDecoderModel[[transformers.MimiDecoderModel]]

#### transformers.MimiDecoderModel[[transformers.MimiDecoderModel]]

```python
transformers.MimiDecoderModel(config: MimiDecoderConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/mimi/modeling_mimi.py#L1279)

**Parámetros:**

config ([MimiDecoderConfig](/docs/transformers/v5.23.0/es/model_doc/mimi#transformers.MimiDecoderConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

La mitad decodificadora de Mimi: remuestreo, transformador decodificador y decodificador SEANet, desde latentes continuos hasta audio.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

#### forward[[transformers.MimiDecoderModel.forward]]

```python
forward(latents: Tensor, padding_mask: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/mimi/modeling_mimi.py#L1306)

**Parámetros:**

latents (`torch.Tensor` de forma `(batch_size, hidden_size, frames)`) : Latentes continuos para decodificar, tal como los calcula [MimiModel.decode()](/docs/transformers/v5.23.0/es/model_doc/mimi#transformers.MimiModel.decode).

padding_mask (`torch.Tensor` de forma `(batch_size, channels, sequence_length)`, *opcional*) : Indica qué entradas deben ignorarse debido al relleno, donde los elementos son 1 para *no enmascarado* o 0 para *enmascarado*.

past_key_values (`Cache`, *opcional*) : Estados ocultos precalculados (claves y valores en los bloques de autoatención) del transformador decodificador, utilizados para acelerar la decodificación en streaming.

Decodifica los fotogramas dados en una forma de onda de audio de salida. Tenga en cuenta que la salida podría ser un poco mayor que la --

input. En ese caso, cualquier paso adicional al final se puede recortar. --

**Devuelve:** `MimiDecoderOutput` o `tuple(torch.Tensor)`

Un `MimiDecoderOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([MimiConfig](/docs/transformers/v5.23.0/es/model_doc/mimi#transformers.MimiConfig)) y las entradas.

El método forward de [MimiDecoderModel](/docs/transformers/v5.23.0/es/model_doc/mimi#transformers.MimiDecoderModel) sobrescribe el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **audio_values** (`torch.Tensor` de forma `(batch_size, audio_channels, num_samples)`, *opcional*) -- Valores de audio decodificados, obtenidos utilizando la parte decodificadora de Mimi.
- **decoder_past_key_values** (`Cache`, *opcional*) -- Estados ocultos precalculados (claves y valores en los bloques de autoatención) que se pueden usar para acelerar la decodificación secuencial del transformador decodificador. Esto suele consistir en `past_key_values` devueltos por el modelo en una etapa anterior de la decodificación, cuando `use_cache=True` o `config.use_cache=True`.

  El modelo generará el mismo formato de caché que se proporciona como entrada.

  Si se utilizan `past_key_values`, el usuario puede introducir opcionalmente solo los últimos `audio_values` o `audio_codes (aquellos que no tienen sus estados de valores clave pasados proporcionados a este modelo).
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando `output_hidden_states=True`) -- Estados ocultos del transformador decodificador en la salida de cada capa más su entrada.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando `output_attentions=True`) -- Pesos de atención de cada capa del transformador decodificador.

