# Tokenizer de audio Pocket TTS

## Resumen

El tokenizador de audio de [Pocket TTS](https://huggingface.co/kyutai/pocket-tts): un códec con la arquitectura de [Mimi](./mimi) (convoluciones SEANet y un pequeño transformer causal en cada lado) cuyo cuantizador vectorial residual se reemplaza por un cuello de botella continuo de 32 dimensiones, el VAE-GAN de [Continuous Audio Language Models](https://huggingface.co/papers/2509.06926). Convierte audio de 24 kHz en latentes a 12.5 Hz y viceversa. Su codificador y decodificador pueden cargarse de forma independiente ([PocketTTSAudioTokenizerEncoderModel](/docs/transformers/main/es/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerEncoderModel), [PocketTTSAudioTokenizerDecoderModel](/docs/transformers/main/es/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerDecoderModel)). Es el `audio_tokenizer` de [PocketTTSProcessor](/docs/transformers/main/es/model_doc/pocket_tts#transformers.PocketTTSProcessor), compartido por cada checkpoint de Pocket TTS: el procesador codifica las indicaciones de voz con él y decodifica los latentes generados.

Este modelo fue aportado por [Eustache Le Bihan](https://huggingface.co/eustlb). El código original es [kyutai-labs/pocket-tts](https://github.com/kyutai-labs/pocket-tts).

## Uso

```python
from datasets import Audio, load_dataset
from transformers import AutoFeatureExtractor, AutoModel

model = AutoModel.from_pretrained("eustlb/pocket-tts-audio-tokenizer", device_map="auto")
feature_extractor = AutoFeatureExtractor.from_pretrained("eustlb/pocket-tts-audio-tokenizer")

dataset = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
dataset = dataset.cast_column("audio", Audio(sampling_rate=24000))
inputs = feature_extractor(dataset[0]["audio"]["array"], sampling_rate=24000, return_tensors="pt").to(model.device)

latents = model.encode(**inputs).latents
audio_values = model.decode(latents).audio_values
```

## PocketTTSAudioTokenizerConfig[[transformers.PocketTTSAudioTokenizerConfig]]

#### transformers.PocketTTSAudioTokenizerConfig[[transformers.PocketTTSAudioTokenizerConfig]]

```python
transformers.PocketTTSAudioTokenizerConfig(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, use_conv_shortcut: bool = False, upsample_groups: int = 512, num_hidden_layers: int = 2, intermediate_size: int = 2048, num_attention_heads: int = 8, num_key_value_heads: int = 8, head_dim: int | None = None, hidden_act: str = 'gelu_pytorch_tanh', 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, latent_stride: int = 16, latent_dim: int = 32)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/configuration_pocket_tts_audio_tokenizer.py#L38)

**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; los puntos de control publicados, y esta implementación, son mono.

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 `PocketTTSAudioTokenizerConv1d` del codificador.

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

upsampling_ratios (`list[int]`, *opcional*) : Proporciones de tamaño de kernel y stride de las convoluciones transpuestas del decodificador; el codificador las utiliza en orden inverso. Si no se especifica, el valor predeterminado es `[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.

use_conv_shortcut (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe usar una convolución como conexión de salto de los bloques residuales de SEANet; los puntos de control publicados no la usan.

upsample_groups (`int`, *opcional*, valor predeterminado 512) : Número de grupos de la convolución transpuesta que realiza el aumento de muestreo de los latentes a la tasa de SEANet.

num_hidden_layers (`int`, *opcional*, valor predeterminado `2`) : 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_pytorch_tanh`) : 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`) : Indica si el codificador transmite por defecto: en ese caso, devuelve la caché de relleno y la caché de clave-valor para pasarla a la siguiente llamada.

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.

latent_stride (`int`, *opcional*, valor predeterminado 16) : Número de fotogramas de SEANet por fotograma latente: el paso de la convolución del codificador que reduce la salida de SEANet a los latentes, y de la convolución transpuesta del decodificador que los vuelve a aumentar. Un fotograma latente cubre `prod(upsampling_ratios) * latent_stride` muestras de audio (`frame_size`, 1920 para los puntos de control publicados).

latent_dim (`int`, *opcional*, valor predeterminado: 32) : Dimensión de los latentes continuos. El cuantizador vectorial residual de Mimi se reemplaza por este cuello de botella: la convolución de muestreo descendente del codificador produce `latent_dim` canales, y el decodificador los proyecta de nuevo a `hidden_size` antes del muestreo ascendente.

Esta es la clase de configuración para almacenar la configuración de un PocketTTSAudioTokenizerModel. Se utiliza para instanciar un modelo Pocket Tts Audio Tokenizer 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 [eustlb/pocket-tts-audio-tokenizer](https://huggingface.co/eustlb/pocket-tts-audio-tokenizer)

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

Ejemplo:

```python
>>> from transformers import PocketTTSAudioTokenizerConfig, PocketTTSAudioTokenizerModel

>>> # a full codec, and its decoder alone
>>> model = PocketTTSAudioTokenizerModel(PocketTTSAudioTokenizerConfig())
>>> decoder_only = PocketTTSAudioTokenizerModel(PocketTTSAudioTokenizerConfig(encoder_config=None))
```

## PocketTTSAudioTokenizerEncoderConfig[[transformers.PocketTTSAudioTokenizerEncoderConfig]]

#### transformers.PocketTTSAudioTokenizerEncoderConfig[[transformers.PocketTTSAudioTokenizerEncoderConfig]]

```python
transformers.PocketTTSAudioTokenizerEncoderConfig(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, use_conv_shortcut: bool = False, upsample_groups: int = 512, num_hidden_layers: int = 2, intermediate_size: int = 2048, num_attention_heads: int = 8, num_key_value_heads: int = 8, head_dim: int | None = None, hidden_act: str = 'gelu_pytorch_tanh', 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, latent_stride: int = 16, latent_dim: int = 32)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/configuration_pocket_tts_audio_tokenizer.py#L214)

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

## PocketTTSAudioTokenizerDecoderConfig[[transformers.PocketTTSAudioTokenizerDecoderConfig]]

#### transformers.PocketTTSAudioTokenizerDecoderConfig[[transformers.PocketTTSAudioTokenizerDecoderConfig]]

```python
transformers.PocketTTSAudioTokenizerDecoderConfig(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, use_conv_shortcut: bool = False, upsample_groups: int = 512, num_hidden_layers: int = 2, intermediate_size: int = 2048, num_attention_heads: int = 8, num_key_value_heads: int = 8, head_dim: int | None = None, hidden_act: str = 'gelu_pytorch_tanh', 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, latent_stride: int = 16, latent_dim: int = 32)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/configuration_pocket_tts_audio_tokenizer.py#L242)

Configuración de la mitad decodificadora de PocketTTSAudioTokenizer (remuestreo, transformador decodificador y decodificador SEANet). Comparte todos los campos con [PocketTTSAudioTokenizerConfig](/docs/transformers/main/es/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerConfig) (consulte su documentación para conocer los argumentos), por lo que puede cargarse directamente desde un punto de control completo de PocketTTSAudioTokenizer.

## PocketTTSAudioTokenizerModel[[transformers.PocketTTSAudioTokenizerModel]]

#### transformers.PocketTTSAudioTokenizerModel[[transformers.PocketTTSAudioTokenizerModel]]

```python
transformers.PocketTTSAudioTokenizerModel(config: PocketTTSAudioTokenizerConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L1179)

**Parámetros:**

config ([PocketTTSAudioTokenizerConfig](/docs/transformers/main/es/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerConfig)) : 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/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El tokenizador de audio Pocket TTS: un códec con arquitectura Mimi y un latente continuo de 32 dimensiones a 12,5 Hz (el VAE-GAN de los modelos de lenguaje de audio continuo), que convierte audio de 24 kHz en latentes y viceversa.

Este modelo hereda de [PreTrainedModel](/docs/transformers/main/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.

#### encode[[transformers.PocketTTSAudioTokenizerModel.encode]]

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

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L1189)

**Parámetros:**

input_values (`torch.Tensor` de forma `(batch_size, audio_channels, num_samples)`) : Forma de onda de audio, tal como la devuelve [EncodecFeatureExtractor](/docs/transformers/main/es/model_doc/encodec#transformers.EncodecFeatureExtractor), que la rellena con ceros hasta un múltiplo de `config.frame_size` muestras, igual que el original.

padding_mask (`torch.Tensor` de forma `(batch_size, num_samples)`, *opcional*) : Máscara de las muestras de audio (`1`) en contraposición al relleno (`0`), a partir de la cual se calcula `latents_mask`.

encoder_past_key_values (`Cache`, *opcional*) : Caché de pares clave-valor del transformador codificador, devuelta por la llamada anterior durante la transmisión en streaming.

padding_cache (`PocketTTSAudioTokenizerConv1dPaddingCache`, *opcional*) : Caché de relleno de las convoluciones causales del codificador, devuelta por la llamada anterior durante la transmisió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 el audio en latentes continuos de forma `(batch_size, num_frames, latent_dim)`: los latentes de [PocketTTSAudioTokenizerEncoderModel.forward()](/docs/transformers/main/es/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerEncoderModel.forward), con los frames primero.

#### decode[[transformers.PocketTTSAudioTokenizerModel.decode]]

```python
decode(latents: Tensor, decoder_past_key_values: transformers.cache_utils.Cache | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L1244)

**Parámetros:**

latents (`torch.Tensor` de forma `(batch_size, num_frames, latent_dim)`) : Latentes continuos para decodificar, un fotograma por cada `config.frame_size` muestras de audio.

decoder_past_key_values (`Cache`, *opcional*) : Caché de pares clave-valor del transformador decodificador, devuelta por la llamada anterior al decodificar en fragmentos.

Decodifica latentes continuos en audio: los latentes se proyectan a `hidden_size` y luego se decodifican mediante [PocketTTSAudioTokenizerDecoderModel.forward()](/docs/transformers/main/es/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerDecoderModel.forward).

#### forward[[transformers.PocketTTSAudioTokenizerModel.forward]]

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

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L1272)

**Parámetros:**

input_values (`torch.Tensor` de forma `(batch_size, audio_channels, num_samples)`) : Forma de onda de audio, tal como la devuelve [EncodecFeatureExtractor](/docs/transformers/main/es/model_doc/encodec#transformers.EncodecFeatureExtractor).

padding_mask (`torch.Tensor` de forma `(batch_size, num_samples)`, *opcional*) : Máscara de las muestras de audio (`1`) en contraposición al relleno (`0`).

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

Un `PocketTTSAudioTokenizerOutput` 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 ([PocketTTSAudioTokenizerConfig](/docs/transformers/main/es/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerConfig)) y las entradas.

El método forward de [PocketTTSAudioTokenizerModel](/docs/transformers/main/es/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerModel) reemplaza 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, num_frames, latent_dim)`) -- Latentes continuos del audio.
- **latents_mask** (`torch.LongTensor` de forma `(batch_size, num_frames)`, *opcional*) -- Máscara de los fotogramas latentes calculados a partir de muestras de audio (`1`) en lugar de relleno (`0`).
- **audio_values** (`torch.Tensor` de forma `(batch_size, audio_channels, num_samples)`) -- Forma de onda de audio reconstruida a partir de los latentes.
- **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.

## PocketTTSAudioTokenizerEncoderModel[[transformers.PocketTTSAudioTokenizerEncoderModel]]

#### transformers.PocketTTSAudioTokenizerEncoderModel[[transformers.PocketTTSAudioTokenizerEncoderModel]]

```python
transformers.PocketTTSAudioTokenizerEncoderModel(config: PocketTTSAudioTokenizerEncoderConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L879)

**Parámetros:**

config ([PocketTTSAudioTokenizerEncoderConfig](/docs/transformers/main/es/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerEncoderConfig)) : 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/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

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

Este modelo hereda de [PreTrainedModel](/docs/transformers/main/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.PocketTTSAudioTokenizerEncoderModel.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.pocket_tts_audio_tokenizer.modeling_pocket_tts_audio_tokenizer.PocketTTSAudioTokenizerConv1dPaddingCache | None = None, use_streaming: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L940)

**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 (`PocketTTSAudioTokenizerConv1dPaddingCache`, *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:** `PocketTTSAudioTokenizerEncoderModelOutput` o `tuple(torch.Tensor)`

Un `PocketTTSAudioTokenizerEncoderModelOutput` 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 ([PocketTTSAudioTokenizerConfig](/docs/transformers/main/es/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerConfig)) y las entradas.

El método forward de [PocketTTSAudioTokenizerEncoderModel](/docs/transformers/main/es/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerEncoderModel) 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** (`PocketTTSAudioTokenizerConv1dPaddingCache`, *opcional*) -- Caché de relleno para las convoluciones causales de PocketTTSAudioTokenizerConv1d, con el fin de admitir la transmisión en streaming mediante relleno de 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.

## PocketTTSAudioTokenizerDecoderModel[[transformers.PocketTTSAudioTokenizerDecoderModel]]

#### transformers.PocketTTSAudioTokenizerDecoderModel[[transformers.PocketTTSAudioTokenizerDecoderModel]]

```python
transformers.PocketTTSAudioTokenizerDecoderModel(config: PocketTTSAudioTokenizerDecoderConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L1109)

**Parámetros:**

config ([PocketTTSAudioTokenizerDecoderConfig](/docs/transformers/main/es/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerDecoderConfig)) : 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/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

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

Este modelo hereda de [PreTrainedModel](/docs/transformers/main/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.PocketTTSAudioTokenizerDecoderModel.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/main/src/transformers/models/pocket_tts_audio_tokenizer/modeling_pocket_tts_audio_tokenizer.py#L1136)

**Parámetros:**

latents (`torch.Tensor` de forma `(batch_size, hidden_size, frames)`) : Latentes continuos para decodificar, tal como los calcula [PocketTTSAudioTokenizerModel.decode()](/docs/transformers/main/es/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerModel.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:** `PocketTTSAudioTokenizerDecoderOutput` o `tuple(torch.Tensor)`

Un `PocketTTSAudioTokenizerDecoderOutput` 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 ([PocketTTSAudioTokenizerConfig](/docs/transformers/main/es/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerConfig)) y las entradas.

El método forward de [PocketTTSAudioTokenizerDecoderModel](/docs/transformers/main/es/model_doc/pocket_tts_audio_tokenizer#transformers.PocketTTSAudioTokenizerDecoderModel) 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 mediante la parte decodificadora de PocketTTSAudioTokenizer.
- **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.