# Pocket TTS

## Resumen

Pocket TTS es el modelo de texto a voz de 100M de parámetros de [Kyutai](https://kyutai.org), un [Continuous Audio Language Model](https://huggingface.co/papers/2509.06926) que se ejecuta más rápido que el tiempo real en CPU. Un transformer causal emite un latente de audio continuo por cuadro (12.5 Hz) a través de una cabeza de flujo de un solo paso, y una cabeza de fin de habla decide cuándo detenerse.

El procesador contiene el [tokenizador de audio de Pocket TTS](./pocket_tts_audio_tokenizer), un códec basado en Mimi que codifica los prompts de voz y decodifica los latentes generados a audio de 24 kHz. Las voces predefinidas se incluyen como cachés KV (`voices/`).

Se han publicado dos cabezas de flujo: autodistilación lagrangiana (`flow_type="lsd"`, predeterminada) y derivante (`flow_type="drifting"`, `english_drifting_26-09`). Se admite el ajuste fino, consulte [Entrenamiento](#training).

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).

## Consejos de uso

- Prepara las entradas con [apply_chat_template()](/docs/transformers/v5.23.0/es/main_classes/processors#transformers.ProcessorMixin.apply_chat_template) (un mensaje de `user` por texto, `add_generation_prompt=True`). El normalizador del tokenizador prepara el texto de la misma manera que el original, con la configuración del idioma del checkpoint.
- `generate` devuelve `audio_latents` y `audio_latents_mask`; decódialos con [PocketTTSProcessor.decode()](/docs/transformers/v5.23.0/es/model_doc/pocket_tts#transformers.PocketTTSProcessor.decode).
- `max_new_tokens` tiene un valor predeterminado basado en la longitud del texto, y la generación se detiene poco después de que el logit de fin de habla cruce `eos_threshold`.
- `do_sample=False` coincide con el original a temperatura 0. Con muestreo, `temperature` (valor predeterminado 0.3) es la varianza del ruido inicial del flujo.
- Divide el texto largo con [PocketTTSProcessor.split_text()](/docs/transformers/v5.23.0/es/model_doc/pocket_tts#transformers.PocketTTSProcessor.split_text), una conversación por fragmento.

## Uso

### Voz

La voz puede otorgarse de tres maneras.

**1. Clonar una grabación**: un elemento `audio` en la conversación.

```python
from transformers import AutoModelForTextToWaveform, AutoProcessor

model_id = "eustlb/pocket-tts"
processor = AutoProcessor.from_pretrained(model_id, device_map="auto")
model = AutoModelForTextToWaveform.from_pretrained(model_id, device_map="auto")

url = "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/en-Alice_woman.wav"
conversation = [
    {
        "role": "user",
        "content": [
            {"type": "audio", "url": url},
            {"type": "text", "text": "Hello world. I am Kyutai's Pocket TTS."},
        ],
    }
]
inputs = processor.apply_chat_template(
    conversation, tokenize=True, return_dict=True, add_generation_prompt=True
).to(model.device)

outputs = model.generate(**inputs)
audio = processor.decode(outputs.audio_latents, outputs.audio_latents_mask)
processor.save_audio(audio, "cloned.wav")
```

**2. Latentes precalculados**: un elemento `audio` vacío, con los latentes pasados al procesador.

```python
from transformers import AutoModelForTextToWaveform, AutoProcessor
from transformers.audio_utils import load_audio

model_id = "eustlb/pocket-tts"
processor = AutoProcessor.from_pretrained(model_id, device_map="auto")
model = AutoModelForTextToWaveform.from_pretrained(model_id, device_map="auto")

# e.g. a recording encoded once by the processor's audio tokenizer,
# to reuse without re-encoding it
url = "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/en-Alice_woman.wav"
features = processor.feature_extractor(
    load_audio(url, sampling_rate=24000), sampling_rate=24000
).to(processor.audio_tokenizer.device)
# (num_frames, latent_dim)
voice = processor.audio_tokenizer.encode(**features).latents[0]

conversation = [
    {
        "role": "user",
        "content": [
            {"type": "audio"},
            {"type": "text", "text": "Hello world. I am Kyutai's Pocket TTS."},
        ],
    }
]
inputs = processor.apply_chat_template(
    conversation,
    tokenize=True,
    return_dict=True,
    add_generation_prompt=True,
    processor_kwargs={"audio_prompt_latents": [voice]},
).to(model.device)

outputs = model.generate(**inputs)
audio = processor.decode(outputs.audio_latents, outputs.audio_latents_mask)
processor.save_audio(audio, "latents.wav")
```

**3. Contexto en caché**: la caché KV del prompt de voz, pasada como `past_key_values`. Las voces incluidas (`voices/`) utilizan esta forma.

```python
from huggingface_hub import hf_hub_download
from safetensors.torch import load_file
from transformers import AutoModelForTextToWaveform, AutoProcessor, DynamicCache

model_id = "eustlb/pocket-tts"
processor = AutoProcessor.from_pretrained(model_id, device_map="auto")
model = AutoModelForTextToWaveform.from_pretrained(model_id, device_map="auto")

voice = load_file(hf_hub_download(model_id, "voices/alba.safetensors"))
layers = []
for i, layer in enumerate(model.model.layers):
    # each layer's cache on that layer's device
    device = layer.self_attn.k_proj.weight.device
    layers.append(
        (voice[f"layers.{i}.keys"].to(device), voice[f"layers.{i}.values"].to(device))
    )
voice_cache = DynamicCache(layers, config=model.config)

conversation = [
    {
        "role": "user",
        "content": [{"type": "text", "text": "Hello world. I am Kyutai's Pocket TTS."}],
    }
]
inputs = processor.apply_chat_template(
    conversation, tokenize=True, return_dict=True, add_generation_prompt=True
).to(model.device)

outputs = model.generate(**inputs, past_key_values=voice_cache)
audio = processor.decode(outputs.audio_latents, outputs.audio_latents_mask)
processor.save_audio(audio, "cached.wav")
```

### Lotes y texto largo

Lote varios textos y voces, con el texto largo dividido en fragmentos:

```python
import torch
from huggingface_hub import hf_hub_download
from safetensors.torch import load_file
from transformers import AutoModelForTextToWaveform, AutoProcessor, DynamicCache

model_id = "eustlb/pocket-tts"
processor = AutoProcessor.from_pretrained(model_id, device_map="auto")
model = AutoModelForTextToWaveform.from_pretrained(model_id, device_map="auto")

def load_voices(names):
    """The shipped voices, one per conversation, as one cache, left-padded to the
    longest voice, and the mask of their positions.

    `generate` extends the cache: load it for every call.
    """
    voices = [
        load_file(hf_hub_download(model_id, f"voices/{name}.safetensors"))
        for name in names
    ]
    lengths = [voice["layers.0.keys"].shape[2] for voice in voices]
    length = max(lengths)
    layers = []
    for i, layer in enumerate(model.model.layers):
        device = layer.self_attn.k_proj.weight.device
        keys, values = (
            torch.cat(
                [
                    torch.nn.functional.pad(voice[f"layers.{i}.{kind}"], (0, 0, length - n, 0))
                    for voice, n in zip(voices, lengths)
                ]
            ).to(device)
            for kind in ("keys", "values")
        )
        layers.append((keys, values))
    mask = torch.tensor([[0] * (length - n) + [1] * n for n in lengths])
    return DynamicCache(layers, config=model.config), mask

text = (
    "A first sentence that is long enough to be worth splitting. "
    "Then a second one, and a third one for good measure."
)
chunks = processor.split_text(text)
conversations = [
    [{"role": "user", "content": [{"type": "text", "text": chunk}]}]
    for chunk in chunks + ["Hello world"]
]
inputs = processor.apply_chat_template(
    conversations, tokenize=True, return_dict=True, add_generation_prompt=True
).to(model.device)

voice_cache, voice_mask = load_voices(["alba"] * len(chunks) + ["jean"])
# the mask covers the cached voices too
inputs["attention_mask"] = torch.cat(
    [voice_mask.to(inputs["attention_mask"]), inputs["attention_mask"]], dim=-1
)
outputs = model.generate(**inputs, past_key_values=voice_cache)
audio = processor.decode(outputs.audio_latents, outputs.audio_latents_mask)
processor.save_audio(
    [torch.cat(audio[: len(chunks)]), audio[-1]], ["long.wav", "hello.wav"]
)
```

### Punto de control desviado

Mismo uso, con las voces propias del punto de control:

```python
from huggingface_hub import hf_hub_download
from safetensors.torch import load_file
from transformers import AutoModelForTextToWaveform, AutoProcessor, DynamicCache

model_id = "eustlb/pocket-tts-english-drifting"
processor = AutoProcessor.from_pretrained(model_id, device_map="auto")
model = AutoModelForTextToWaveform.from_pretrained(model_id, device_map="auto")

voice = load_file(hf_hub_download(model_id, "voices/alba.safetensors"))
layers = []
for i, layer in enumerate(model.model.layers):
    device = layer.self_attn.k_proj.weight.device
    layers.append(
        (voice[f"layers.{i}.keys"].to(device), voice[f"layers.{i}.values"].to(device))
    )

conversation = [
    {
        "role": "user",
        "content": [{"type": "text", "text": "Hello world. I am Kyutai's Pocket TTS."}],
    }
]
inputs = processor.apply_chat_template(
    conversation, tokenize=True, return_dict=True, add_generation_prompt=True
).to(model.device)

outputs = model.generate(
    **inputs, past_key_values=DynamicCache(layers, config=model.config)
)
audio = processor.decode(outputs.audio_latents, outputs.audio_latents_mask)
processor.save_audio(audio, "drifting.wav")
```

## Entrenamiento

Coloca el audio objetivo en el turno de `assistant`. El procesador devuelve sus latentes como `labels`, y el modelo devuelve la pérdida original (pérdida de flujo LSD más `config.eos_loss_weight` veces la pérdida de fin de habla). El prompt de voz suele ser el inicio del mismo enunciado.

```python
import torch
from transformers import AutoModelForTextToWaveform, AutoProcessor

model_id = "eustlb/pocket-tts"
processor = AutoProcessor.from_pretrained(model_id, device_map="auto")
model = AutoModelForTextToWaveform.from_pretrained(model_id, device_map="auto")
model.train()

conversation = [
    {
        "role": "user",
        "content": [
            {"type": "audio", "audio": voice_prompt},
            {"type": "text", "text": target_text},
        ],
    },
    {"role": "assistant", "content": [{"type": "audio", "audio": target_audio}]},
]
inputs = processor.apply_chat_template(
    conversation, tokenize=True, return_dict=True
).to(model.device)
loss = model(**inputs).loss
loss.backward()
```

- Proporciona la voz como una grabación o latentes, no como una caché.
- Para la guía sin clasificador, elimine el elemento `audio` o `text` del turno de `user` (el original elimina cada uno con una probabilidad de 0.2).
- Los latentes precalculados se incluyen en `processor_kwargs={"audio_prompt_latents": [...], "labels": [...]}`, con elementos vacíos de `{"type": "audio"}` como marcadores de posición.
- Receta original: AdamW, `learning_rate=2e-5` (2e-4 para un nuevo idioma), `adam_beta2=0.95`, `weight_decay=0.1`, `max_grad_norm=1.0`, 1000 pasos de calentamiento y luego constante, EMA de los pesos (decaimiento 0.999).

## PocketTTSConfig[[transformers.PocketTTSConfig]]

#### transformers.PocketTTSConfig[[transformers.PocketTTSConfig]]

```python
transformers.PocketTTSConfig(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, flow_head_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, vocab_size: int = 4004, hidden_size: int = 1024, num_hidden_layers: int = 6, num_attention_heads: int = 16, num_key_value_heads: int | None = None, head_dim: int | None = None, intermediate_size: int = 4096, hidden_act: str = 'gelu_pytorch_tanh', layer_norm_eps: float = 1e-05, attention_bias: bool = False, attention_dropout: float = 0.0, max_position_embeddings: int = 8192, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, latent_dim: int = 32, pad_token_id: int = 3, bos_token_id: int | None = None, eos_token_id: int | None = None, audio_prompt_token_id: int = 4000, audio_latent_token_id: int = 4001, audio_prompt_bos_token_id: int = 4002, audio_bos_token_id: int = 4003, frame_rate: float = 12.5, initializer_range: float = 0.02, use_cache: bool = True, eos_loss_weight: float = 0.1, flow_loss_num_samples: int = 4, lsd_distill_probability: float = 0.25, lsd_diagonal_weight: float = 0.75, lsd_time_logit_mean: float = 0.4, lsd_time_logit_std: float = 1.0, latent_stats_ema_steps: int = 1000, latent_stats_ema_decay: float = 0.999)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pocket_tts/configuration_pocket_tts.py#L75)

**Parámetros:**

flow_head_config (`Union[PocketTTSFlowHeadConfig, dict]`, *opcional*) : La configuración de la cabecera de flujo que muestrea cada latente a partir del estado oculto del backbone.

vocab_size (`int`, *opcional*, valor predeterminado `4004`) : Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse mediante `input_ids`.

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

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

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

num_key_value_heads (`int`, *opcional*) : Este es el número de cabezas de key_value que deben usarse para implementar Grouped Query Attention. Si `num_key_value_heads=num_attention_heads`, el modelo usará Multi Head Attention (MHA); si `num_key_value_heads=1`, el modelo usará Multi Query Attention (MQA); en caso contrario, se usará GQA. Al convertir un checkpoint multi-head a un checkpoint GQA, cada cabeza de key y value del grupo debe construirse mediante 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

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

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.

layer_norm_eps (`float`, *opcional*, valor predeterminado 1e-05) : Epsilon de las normalizaciones de capa del backbone.

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.

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

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

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.

latent_dim (`int`, *opcional*, valor predeterminado 32) : Dimensión de los latentes de audio que el backbone toma como entrada (`audio_prompt_latents`, `audio_latents`); equivale al `latent_dim` de la cabecera de flujo y del tokenizador de audio.

pad_token_id (`int`, *opcional*, valor predeterminado `3`) : Id de token utilizado para el relleno en el vocabulario.

bos_token_id (`int`, *opcional*) : Id de token utilizado para el inicio de la secuencia en el vocabulario.

eos_token_id (`int`, *opcional*) : Identificador de token utilizado para el fin de la secuencia en el vocabulario.

audio_prompt_token_id (`int`, *opcional*, valor predeterminado 4000) : Id del token de marcador de posición de los fotogramas de la voz-prompt en `input_ids`.

audio_latent_token_id (`int`, *opcional*, valor predeterminado 4001) : ID del token de marcador de posición de las posiciones latentes de audio en `input_ids`.

audio_prompt_bos_token_id (`int`, *opcional*, valor predeterminado 4002) : Id del token colocado antes del prompt de voz; su embedding es el vector aprendido que el original antepone a la voz.

audio_bos_token_id (`int`, *opcional*, valor predeterminado 4003) : Id del token de la primera posición de audio, que cierra el prompt: contiene el latente BOS aprendido, a partir del cual se genera el primer fotograma.

frame_rate (`float`, *opcional*, valor predeterminado 12.5) : Número de latentes de audio por segundo de audio: `generate` deriva su presupuesto de fotogramas predeterminado a partir de este valor.

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

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

eos_loss_weight (`float`, *opcional*, valor predeterminado 0.1) : Peso de la pérdida de fin de habla en la pérdida de entrenamiento.

flow_loss_num_samples (`int`, *opcional*, valor predeterminado 4) : Número de extracciones de ruido por cuadro objetivo en la pérdida de flujo.

lsd_distill_probability (`float`, *opcional*, valor predeterminado 0.25) : Probabilidad, por paso de entrenamiento, de calcular el término de autodistilación de la pérdida LSD (recalculado para mantener la pérdida esperada); 1 lo calcula en cada paso.

lsd_diagonal_weight (`float`, *opcional*, valor predeterminado 0.75) : Peso del término diagonal (flujo instantáneo) de la pérdida LSD; el término de autodistilación pondera el resto.

lsd_time_logit_mean (`float`, *opcional*, valor predeterminado 0.4) : Media de la distribución logit-normal de los tiempos de flujo extraídos por la pérdida LSD.

lsd_time_logit_std (`float`, *opcional*, valor predeterminado 1.0) : Desviación estándar de la distribución logit-normal de los tiempos de flujo extraídos por la pérdida LSD.

latent_stats_ema_steps (`int`, *opcional*, valor predeterminado 1000) : Número de primeros pasos de entrenamiento durante los cuales `latent_mean` y `latent_std` siguen una media móvil exponencial de los latentes objetivo; 0 los mantiene congelados.

latent_stats_ema_decay (`float`, *opcional*, valor predeterminado 0.999) : Decaimiento de esa media móvil.

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

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.

## PocketTTSFlowHeadConfig[[transformers.PocketTTSFlowHeadConfig]]

#### transformers.PocketTTSFlowHeadConfig[[transformers.PocketTTSFlowHeadConfig]]

```python
transformers.PocketTTSFlowHeadConfig(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, hidden_size: int = 512, num_hidden_layers: int = 6, latent_dim: int = 32, condition_dim: int = 1024, frequency_embedding_size: int = 256, hidden_act: str = 'silu', layer_norm_eps: float = 1e-06, rms_norm_eps: float = 1e-05, max_period: float = 10000.0, flow_type: typing.Literal['lsd', 'drifting'] = 'lsd', loss_weighting_hidden_size: int = 32, loss_weighting_num_layers: int = 3)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pocket_tts/configuration_pocket_tts.py#L27)

**Parámetros:**

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

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

latent_dim (`int`, *opcional*, valor predeterminado 32) : Dimensión de los latentes de audio continuo que predice la cabeza (la dimensión latente del tokenizador de audio).

condition_dim (`int`, *opcional*, valor predeterminado 1024) : Dimensión del estado oculto del backbone en el que se condiciona la cabeza (el `hidden_size` del backbone).

frequency_embedding_size (`int`, *opcional*, valor predeterminado 256) : Tamaño del embebido sinusoidal de los tiempos de flujo.

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

layer_norm_eps (`float`, *opcional*, valor predeterminado 1e-06) : Epsilon de las normalizaciones de capa dentro de los bloques residuales y de la capa final.

rms_norm_eps (`float`, *opcional*, valor predeterminado 1e-05) : Epsilon de la normalización que cierra los embeddings temporales.

max_period (`float`, *opcional*, valor predeterminado 10000.0) : Periodo máximo del incrustado temporal sinusoidal, que el punto de control almacena como `freqs`.

flow_type (`str`, *opcional*, valor predeterminado `"lsd"`) : Objetivo con el que se entrenó la cabeza, que determina cómo se condiciona y muestrea. `"lsd"` (auto-distilación lagrangiana): condicionada en los tiempos de inicio y fin de un paso de flujo, muestreada mediante pasos de Euler desde ruido gaussiano. `"drifting"`: sin condicionamiento temporal, la cabeza mapea el ruido al latente en una sola llamada.

loss_weighting_hidden_size (`int`, *opcional*, valor predeterminado 32) : Ancho del MLP que aprende el ponderado de incertidumbre de los términos de la pérdida LSD a partir de sus tiempos de flujo (solo entrenamiento).

loss_weighting_num_layers (`int`, *opcional*, valor predeterminado 3) : Número de capas ocultas de ese MLP.

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

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.

## PocketTTSFeatureExtractor[[transformers.PocketTTSFeatureExtractor]]

#### transformers.PocketTTSFeatureExtractor[[transformers.PocketTTSFeatureExtractor]]

```python
transformers.PocketTTSFeatureExtractor(feature_size = 1, sampling_rate = 24000, padding_value = 0.0, frame_size = 1920, pad_to_multiple_of = 1920, end_on_pause = True, pause_duration = 0.08, fade_out_duration = 0.02, silence_floor_db = 35.0, analysis_frame_duration = 0.02, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pocket_tts/feature_extraction_pocket_tts.py#L29)

**Parámetros:**

feature_size (`int`, *opcional*, valor predeterminado 1) : El número de canales.

sampling_rate (`int`, *opcional*, valor predeterminado 24000) : La frecuencia de muestreo a la que se debe digitalizar la forma de onda de audio, expresada en hercios (Hz).

padding_value (`float`, *opcional*, valor predeterminado 0.0) : El valor que se utiliza para el relleno.

frame_size (`int`, *opcional*, valor predeterminado 1920) : Número de muestras de audio por marco latente del tokenizador de audio (su `frame_size`).

pad_to_multiple_of (`int`, *opcional*, valor predeterminado 1920) : Rellena el audio hasta un múltiplo de este valor; un múltiplo de `frame_size` mantiene cada cuadro latente completo.

end_on_pause (`bool`, *opcional*, valor predeterminado `True`) : Si se debe finalizar cada forma de onda con exactamente `pause_duration` segundos de silencio: se recorta el silencio final (los fotogramas de `analysis_frame_duration` segundos que están más de `silence_floor_db` por debajo del más fuerte), se aplica un fundido de salida a los últimos `fade_out_duration` segundos de lo que queda y se añaden `pause_duration` segundos de ceros.

pause_duration (`float`, *opcional*, valor predeterminado 0.08) : Duración del silencio que añade `end_on_pause`, en segundos.

fade_out_duration (`float`, *opcional*, valor predeterminado 0.02) : Duración del fundido a negro aplicado por `end_on_pause` antes de la pausa, en segundos.

silence_floor_db (`float`, *opcional*, valor predeterminado 35.0) : Nivel por debajo del cuadro de análisis más fuerte, en dB, bajo el cual `end_on_pause` trata los cuadros finales como silencio.

analysis_frame_duration (`float`, *opcional*, valor predeterminado 0.02) : Duración, en segundos, de los fotogramas sobre los que `end_on_pause` mide el nivel.

Construye un extractor de características de Pocket TTS, que prepara las formas de onda de voz de la indicación para el codificador del tokenizador de audio.

Cada forma de onda termina opcionalmente en una breve pausa (el `end_on_pause` original: los prompts de entrenamiento terminan dentro de la pausa entre dos palabras, un prompt que se detiene en el habla hace que el modelo la continúe y uno que termina en un silencio largo retrasa el inicio), y luego el lote se rellena a la derecha hasta un múltiplo del tamaño de cuadro del tokenizador.

#### __llamada__[[transformers.PocketTTSFeatureExtractor.__call__]]

```python
__call__(audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor']], sampling_rate: int | None = None, end_on_pause: bool | None = None, padding: bool | str | transformers.utils.generic.PaddingStrategy | None = True, pad_to_multiple_of: int | None = None, max_length: int | None = None, return_attention_mask: bool | None = True, return_tensors: str | None = 'pt', **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pocket_tts/feature_extraction_pocket_tts.py#L106)

**Parámetros:**

audio (`np.ndarray`, `torch.Tensor`, `list[np.ndarray]`, `list[torch.Tensor]`) : La forma de onda mono o el lote de formas de onda mono de los prompts de voz.

sampling_rate (`int`, *opcional*) : La tasa de muestreo a la que se muestreó la entrada de `audio`. Se recomienda encarecidamente pasar `sampling_rate` en la llamada forward para evitar errores silenciosos.

end_on_pause (`bool`, *opcional*) : Indica si se debe finalizar cada forma de onda con una pausa breve; consulte la docstring de la clase. El valor predeterminado es `self.end_on_pause`.

padding (`bool`, `str` o [PaddingStrategy](/docs/transformers/v5.23.0/es/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, valor predeterminado `True`) : Estrategia de relleno del lote, ver [pad()](/docs/transformers/v5.23.0/es/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad).

pad_to_multiple_of (`int`, *opcional*) : Rellena el lote hasta un múltiplo de este valor. El valor predeterminado es `self.pad_to_multiple_of`.

## PocketTTSProcessor[[transformers.PocketTTSProcessor]]

#### transformers.PocketTTSProcessor[[transformers.PocketTTSProcessor]]

```python
transformers.PocketTTSProcessor(feature_extractor, tokenizer, audio_tokenizer = None, chat_template = None, short_text_max_words: int = 4, frames_after_eos_short_text: int = 4, frames_after_eos: int = 2, fade_in_duration: float = 0.005)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pocket_tts/processing_pocket_tts.py#L49)

**Parámetros:**

feature_extractor (`PocketTTSFeatureExtractor`) : El extractor de características es una entrada obligatoria.

tokenizer (`TokenizersBackend`) : El tokenizador es una entrada obligatoria.

audio_tokenizer (`PocketTTSAudioTokenizerModel`, *opcional*) : El códec: codifica el audio en latentes y decodifica los latentes generados en audio.

chat_template (`str`) : Una plantilla de Jinja para convertir listas de mensajes de un chat en una cadena tokenizable.

short_text_max_words (`int`, *opcional*, valor predeterminado 4) : Los textos de como máximo esta cantidad de palabras reciben `frames_after_eos_short_text` fotogramas después del fotograma de fin de habla.

frames_after_eos_short_text (`int`, *opcional*, valor predeterminado 4) : Número de fotogramas generados después del fotograma de fin de habla para textos cortos.

frames_after_eos (`int`, *opcional*, valor predeterminado: 2) : Número de fotogramas generados después del fotograma de fin de habla para textos más largos.

fade_in_duration (`float`, *opcional*, valor predeterminado 0.005) : Duración en segundos del fundido lineal aplicado al inicio de cada forma de onda decodificada: un estado de decodificador nuevo comienza con un pequeño paso, que se percibe como un clic.

Construye un PocketTTSProcessor que envuelve un extractor de características y un tokenizador en un único procesador.

[PocketTTSProcessor](/docs/transformers/v5.23.0/es/model_doc/pocket_tts#transformers.PocketTTSProcessor) ofrece todas las funcionalidades de [PocketTTSFeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/pocket_tts#transformers.PocketTTSFeatureExtractor) y [TokenizersBackend](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.TokenizersBackend). Consulte [~PocketTTSFeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/pocket_tts#transformers.PocketTTSFeatureExtractor) y [~TokenizersBackend](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.TokenizersBackend) para obtener más información.

#### __llamada__[[transformers.PocketTTSProcessor.__call__]]

```python
__call__(text: str | list[str] | None = None, audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, audio_prompt_latents: list[torch.Tensor] | None = None, labels: list[torch.Tensor] | None = None, **kwargs: *<class 'transformers.models.pocket_tts.processing_pocket_tts.PocketTTSProcessorKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pocket_tts/processing_pocket_tts.py#L107)

**Parámetros:**

text (`str` o `list[str]`) : El o los prompts renderizados por [apply_chat_template()](/docs/transformers/v5.23.0/es/main_classes/processors#transformers.ProcessorMixin.apply_chat_template).

audio (`np.ndarray`, `torch.Tensor` o una lista de estos, *opcional*) : Las formas de onda de las conversaciones, en mono a 24 kHz, en el orden de la conversación: cada voz y, en entrenamiento, cada objetivo.

audio_prompt_latents (`list[torch.Tensor]`, *opcional*) : Voces precalculadas, un tensor `(num_frames, latent_dim)` por marcador de posición de voz, en lugar de formas de onda.

labels (`list[torch.Tensor]`, *opcional*) : Objetivos precalculados (entrenamiento), un tensor `(num_frames, latent_dim)` por marcador de posición de objetivo, en lugar de formas de onda.

end_on_pause (`bool`, *kwargs*, *opcional*) : Indica si se debe finalizar cada forma de onda de voz-prompt con una pausa breve, tal como hace el original antes de clonar una voz. El valor predeterminado es `end_on_pause` del extractor de características.

return_mm_token_type_ids (`bool`, *kwargs*) : Si se deben devolver los ids de tipo de token multimodal que indican las posiciones de los tokens de marcador multimodal.

return_text_replacement_offsets (`bool`, *kwargs*) : Si se deben devolver los desplazamientos de caracteres para cada marcador de posición multimodal y su reemplazo.

return_tensors (`str` o [TensorType](/docs/transformers/v5.23.0/es/internal/file_utils#transformers.TensorType), *opcional*) : Si se establece, devolverá tensores de un marco de trabajo específico. Los valores aceptables son:  - `'pt'`: Devuelve objetos `torch.Tensor` de PyTorch. - `'np'`: Devuelve objetos `np.ndarray` de NumPy.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/v5.23.0/es/main_classes/processors#transformers.ProcessingKwargs), *opcional*) : Opciones de procesamiento adicionales para cada modalidad (texto, imágenes, vídeos, audio). Los parámetros específicos del modelo se enumeran arriba; consulte la clase TypedDict para obtener la lista completa de argumentos admitidos.

**Devuelve:**

[BatchFeature](/docs/transformers/v5.23.0/es/main_classes/feature_extractor#transformers.BatchFeature) con `input_ids`, `attention_mask`, `audio_prompt_latents` y `audio_prompt_latents_mask`; para la generación `frames_after_eos` (fotogramas generados después de la fotograma de fin de habla, según la longitud del texto), y para el entrenamiento `labels` y `labels_mask`.

#### split_text[[transformers.PocketTTSProcessor.split_text]]

```python
split_text(text: str, max_tokens: int = 50)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pocket_tts/processing_pocket_tts.py#L281)

**Parámetros:**

text (`str`) : El texto que se va a dividir.

max_tokens (`int`, *opcional*, valor predeterminado 50) : Número máximo de tokens por bloque.

Divide `text` en fragmentos alineados por oraciones de como máximo `max_tokens` tokens, al igual que `split_into_best_sentences` del original: el texto preparado se corta al final de las oraciones (no en puntos decimales), las oraciones más largas que `max_tokens` se cortan al final de las cláusulas, y las piezas se agrupan de forma voraz. Cada fragmento está destinado a ser una conversación de un lote.

#### decode[[transformers.PocketTTSProcessor.decode]]

```python
decode(audio_latents: torch.Tensor, audio_latents_mask: torch.Tensor | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pocket_tts/processing_pocket_tts.py#L339)

**Parámetros:**

audio_latents (`torch.Tensor` de forma `(batch_size, num_frames, latent_dim)` o `(num_frames, latent_dim)`) : Los latentes que devuelve `generate` (`PocketTTSGenerateOutput.audio_latents`), decodificados como un solo lote, o los latentes de una muestra.

audio_latents_mask (`torch.Tensor` de forma `(batch_size, num_frames)`, *opcional*) : Máscara de los fotogramas de cada muestra (`PocketTTSGenerateOutput.audio_latents_mask`). Sin ella, cada fila se decodifica a longitud completa.

**Devuelve:**

`list[torch.Tensor]` de formas de onda unidimensionales en CPU, una por fila, o una forma de onda para los latentes de una muestra.

Decodifica los latentes generados en formas de onda con el tokenizador de audio y aplica un fundido de entrada a los primeros `fade_in_duration` segundos de cada una, tal como hace el original.

#### save_audio[[transformers.PocketTTSProcessor.save_audio]]

```python
save_audio(audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor']], saving_path: str | pathlib.Path | list[str | pathlib.Path], sampling_rate: int | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pocket_tts/processing_pocket_tts.py#L388)

Escribe las formas de onda generadas en archivos WAV.

audio (`torch.Tensor`, `np.ndarray` o una lista de ellos): la(s) forma(s) de onda, tal como las devuelve [decode()](/docs/transformers/v5.23.0/es/model_doc/pocket_tts#transformers.PocketTTSProcessor.decode). saving_path (`str`, `Path` o una lista de ellos): una ruta por cada forma de onda. sampling_rate (`int`, *opcional*): tasa de muestreo de las formas de onda, por defecto la del extractor de características (la del tokenizador de audio).

## PocketTTSModel[[transformers.PocketTTSModel]]

#### transformers.PocketTTSModel[[transformers.PocketTTSModel]]

```python
transformers.PocketTTSModel(config: PocketTTSConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pocket_tts/modeling_pocket_tts.py#L498)

**Parámetros:**

config ([PocketTTSConfig](/docs/transformers/v5.23.0/es/model_doc/pocket_tts#transformers.PocketTTSConfig)) : 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 backbone de Pocket TTS: un transformer causal sobre un único flujo compuesto por el prompt de voz, los tokens de texto y los latentes de audio, que devuelve los estados ocultos normalizados. El prompt de voz y los latentes de audio son latentes del tokenizador de audio, que el procesador mantiene.

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.PocketTTSModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, audio_prompt_latents: typing.Optional[torch.Tensor] = None, audio_prompt_latents_mask: typing.Optional[torch.Tensor] = None, audio_latents: typing.Optional[torch.Tensor] = None, audio_latents_mask: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pocket_tts/modeling_pocket_tts.py#L518)

**Parámetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada. Los índices se pueden obtener mediante [AutoTokenizer](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids)

audio_prompt_latents (`torch.Tensor` de forma `(batch_size, num_prompt_frames, latent_dim)`, *opcional*) : Latentes de voz de la entrada del tokenizador de audio (codificados por el procesador o por un `voices/` de un checkpoint), rellenos a la derecha hasta la longitud de la voz más larga del lote, distribuidos en las posiciones de `audio_prompt_token_id`.

audio_prompt_latents_mask (`torch.Tensor` de forma `(batch_size, num_prompt_frames)`, *opcional*) : Máscara de los fotogramas de voz (`1`) en contraposición al relleno (`0`) en `audio_prompt_latents`.

audio_latents (`torch.Tensor` de forma `(batch_size, num_latents, latent_dim)`, *opcional*) : Latentes de audio normalizados, distribuidos en las posiciones de `audio_latent_token_id`. La posición de `audio_bos_token_id` que los precede, la cual cierra el prompt y desde la cual se genera el primer fotograma, siempre recibe el latente de BOS aprendido.

audio_latents_mask (`torch.Tensor` de forma `(batch_size, num_latents)`, *opcional*) : Máscara de los latentes de cada fila (`1`) en contraposición al relleno (`0`) en `audio_latents`, cuando las filas contienen un número diferente de posiciones latentes (entrenamiento).

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de las posiciones de los tokens de cada secuencia de entrada en las incrustaciones de posición. Seleccionados en el rango `[0, config.n_positions - 1]`.  [¿Qué son los IDs de posición?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *opcional*) : Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden utilizar para acelerar la decodificación secuencial. 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`.  Solo se permite una instancia de [Cache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada.  El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada.  Si se utilizan `past_key_values`, se espera que el usuario introduzca solo los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados a este modelo) con forma `(batch_size, unprocessed_length)` en lugar de todos los `input_ids` con forma `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, en lugar de pasar `input_ids`, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de `input_ids` en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.

use_cache (`bool`, *opcional*) : Si se establece en `True`, se devuelven los estados de valores clave `past_key_values` y pueden usarse para acelerar la decodificación (ver `past_key_values`).

**Devuelve:** [BaseModelOutputWithPast](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) o `tuple(torch.Tensor)`

Un [BaseModelOutputWithPast](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) 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 ([PocketTTSConfig](/docs/transformers/v5.23.0/es/model_doc/pocket_tts#transformers.PocketTTSConfig)) y las entradas.

El método forward de [PocketTTSModel](/docs/transformers/v5.23.0/es/model_doc/pocket_tts#transformers.PocketTTSModel) 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.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Secuencia de estados ocultos en la salida de la última capa del modelo.

  Si se utiliza `past_key_values`, solo se genera el último hidden-state de las secuencias con forma `(batch_size, 1, hidden_size)`.
- **past_key_values** (`Cache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) -- Es una instancia de [Cache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y, opcionalmente, si `config.is_encoder_decoder=True`, en los bloques de atención cruzada) que pueden utilizarse (véase la entrada `past_key_values`) para acelerar la decodificación secuencial.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

## PocketTTSForConditionalGeneration[[transformers.PocketTTSForConditionalGeneration]]

#### transformers.PocketTTSForConditionalGeneration[[transformers.PocketTTSForConditionalGeneration]]

```python
transformers.PocketTTSForConditionalGeneration(config: PocketTTSConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pocket_tts/modeling_pocket_tts.py#L672)

**Parámetros:**

config ([PocketTTSConfig](/docs/transformers/v5.23.0/es/model_doc/pocket_tts#transformers.PocketTTSConfig)) : 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 texto a voz Pocket TTS: el backbone, la cabeza de flujo que muestrea un latente de audio por paso y la cabeza de fin de habla. Genera latentes del tokenizador de audio, que el procesador decodifica en audio de 24 kHz.

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.PocketTTSForConditionalGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, audio_prompt_latents: typing.Optional[torch.Tensor] = None, audio_prompt_latents_mask: typing.Optional[torch.Tensor] = None, audio_latents: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, labels_mask: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pocket_tts/modeling_pocket_tts.py#L702)

**Parámetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada. Los índices se pueden obtener mediante [AutoTokenizer](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids)

audio_prompt_latents (`torch.Tensor` de forma `(batch_size, num_prompt_frames, latent_dim)`, *opcional*) : Latentes de voz de la entrada del tokenizador de audio, rellenos a la derecha, distribuidos en las posiciones de `audio_prompt_token_id`.

audio_prompt_latents_mask (`torch.Tensor` de forma `(batch_size, num_prompt_frames)`, *opcional*) : Máscara de los fotogramas de voz (`1`) en contraposición al relleno (`0`) en `audio_prompt_latents`.

audio_latents (`torch.Tensor` de forma `(batch_size, num_latents, latent_dim)`, *opcional*) : Latentes de audio normalizados, distribuidos en las posiciones de `audio_latent_token_id`.

labels (`torch.Tensor` de forma `(batch_size, num_frames, latent_dim)`, *opcional*) : Latentes objetivo del tokenizador de audio (entrenamiento), con relleno a la derecha. El prompt de cada fila termina en la posición `audio_bos_token_id` seguido de una posición `audio_latent_token_id` por cada frame: el modelo alimenta los objetivos normalizados (teacher forcing), aplica la pérdida de flujo a las salidas del BOS y de todos los frames excepto el último, que predicen los frames, y la pérdida de fin de habla a todos ellos, siendo el último el fin de la habla.

labels_mask (`torch.Tensor` de forma `(batch_size, num_frames)`, *opcional*) : Máscara de los cuadros objetivo de cada fila (`1`) en contraposición al relleno (`0`) en `labels`.

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de las posiciones de los tokens de cada secuencia de entrada en las incrustaciones de posición. Seleccionados en el rango `[0, config.n_positions - 1]`.  [¿Qué son los IDs de posición?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *opcional*) : Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden utilizar para acelerar la decodificación secuencial. 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`.  Solo se permite una instancia de [Cache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada.  El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada.  Si se utilizan `past_key_values`, se espera que el usuario introduzca solo los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados a este modelo) con forma `(batch_size, unprocessed_length)` en lugar de todos los `input_ids` con forma `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, en lugar de pasar `input_ids`, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de `input_ids` en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.

use_cache (`bool`, *opcional*) : Si se establece en `True`, se devuelven los estados de valores clave `past_key_values` y pueden usarse para acelerar la decodificación (ver `past_key_values`).

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

Un `PocketTTSOutputWithPast` 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 ([PocketTTSConfig](/docs/transformers/v5.23.0/es/model_doc/pocket_tts#transformers.PocketTTSConfig)) y las entradas.

El método forward de [PocketTTSForConditionalGeneration](/docs/transformers/v5.23.0/es/model_doc/pocket_tts#transformers.PocketTTSForConditionalGeneration) 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.

- **loss** (`torch.Tensor` de forma `()`, *opcional*, devuelto cuando se pasa `labels`) -- Pérdida de entrenamiento: la pérdida de flujo LSD de los latentes objetivo más `config.eos_loss_weight` veces la pérdida de fin de habla.
- **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, 1)`) -- Logits de fin de habla, uno por posición.
- **past_key_values** (`Cache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) -- Es una instancia de [Cache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención) que pueden utilizarse (véase la entrada `past_key_values`) para acelerar la decodificación secuencial.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Estados ocultos normalizados del backbone, que condicionan la cabeza de flujo.

Ejemplo:

```python
>>> from transformers import AutoProcessor, PocketTTSForConditionalGeneration

>>> model = PocketTTSForConditionalGeneration.from_pretrained("eustlb/pocket-tts")

>>> processor = AutoProcessor.from_pretrained("eustlb/pocket-tts")
>>> inputs = processor(text="Hello, my dog is cute", return_tensors="pt")

>>> # generate speech
>>> speech = model(inputs["input_ids"])
```

#### generate[[transformers.PocketTTSForConditionalGeneration.generate]]

```python
generate(inputs: typing.Optional[torch.Tensor] = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pocket_tts/generation_pocket_tts.py#L122)

**Parámetros:**

inputs (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Los `input_ids` preparados por [PocketTTSProcessor](/docs/transformers/v5.23.0/es/model_doc/pocket_tts#transformers.PocketTTSProcessor). También se pueden pasar como `input_ids=`.

kwargs (`dict[str, Any]`, *opcional*) : `attention_mask`, el prompt de voz (`audio_prompt_latents` y `audio_prompt_latents_mask`, o la caché de un prefijo de voz como `past_key_values`, las voces incluidas, con prompts solo de texto), `frames_after_eos` del procesador, los parámetros de generación (`do_sample`, `temperature`, `max_new_tokens`, ...) y los específicos de Pocket TTS `num_flow_steps`, `eos_threshold` y `min_frames_before_eos`, que por defecto se toman de la configuración de generación.

**Devuelve:**

[PocketTTSGenerateOutput](/docs/transformers/v5.23.0/es/model_doc/pocket_tts#transformers.models.pocket_tts.generation_pocket_tts.PocketTTSGenerateOutput) cuando `return_dict_in_generate=True` (la configuración de generación de los checkpoints): los `audio_latents` rellenos y su `audio_latents_mask`, que [PocketTTSProcessor.decode()](/docs/transformers/v5.23.0/es/model_doc/pocket_tts#transformers.PocketTTSProcessor.decode) decodifica como un solo lote. En caso contrario, la lista de latentes generados, con un tensor `(num_frames, latent_dim)` por muestra, cada uno decodificado por separado.

Genera audio. Este método reescribe [generate()](/docs/transformers/v5.23.0/es/main_classes/text_generation#transformers.GenerationMixin.generate) para establecer `max_new_tokens` de forma predeterminada al presupuesto de fotogramas del tiempo de ejecución original, `ceil((num_text_tokens / 3 + 2) * frame_rate)` para el texto más largo del lote. Todo lo demás pasa por los ganchos de generación habituales.

#### sample_latent[[transformers.PocketTTSForConditionalGeneration.sample_latent]]

```python
sample_latent(condition: Tensor, noise: Tensor, num_flow_steps: int)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pocket_tts/modeling_pocket_tts.py#L807)

**Parámetros:**

condition (`torch.Tensor` de forma `(batch_size, hidden_size)`) : Estado oculto del backbone de la posición que se está generando.

noise (`torch.Tensor` de forma `(batch_size, latent_dim)`) : Ruido gaussiano escalado por `sqrt(temperature)`, o ceros.

num_flow_steps (`int`) : Número de pasos de Euler del muestreador LSD (ignorado por la cabeza de deriva, que realiza una sola llamada).

**Devuelve:** `torch.Tensor` de forma `(batch_size, latent_dim)`

el latente muestreado, en el espacio normalizado.

Muestrea el siguiente latente desde `noise` con la cabeza de flujo.

#### denormalize_latents[[transformers.PocketTTSForConditionalGeneration.denormalize_latents]]

```python
denormalize_latents(audio_latents: Tensor)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pocket_tts/modeling_pocket_tts.py#L854)

Mapea los latentes del espacio normalizado de la cabecera de flujo al del tokenizador de audio.

## PocketTTSGenerateOutput[[transformers.models.pocket_tts.generation_pocket_tts.PocketTTSGenerateOutput]]

#### transformers.models.pocket_tts.generation_pocket_tts.PocketTTSGenerateOutput[[transformers.models.pocket_tts.generation_pocket_tts.PocketTTSGenerateOutput]]

```python
transformers.models.pocket_tts.generation_pocket_tts.PocketTTSGenerateOutput(sequences: LongTensor, scores: tuple[torch.Tensor] | None = None, logits: tuple[torch.Tensor] | None = None, attentions: tuple[tuple[torch.Tensor]] | None = None, hidden_states: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, audio_latents: typing.Optional[torch.Tensor] = None, audio_latents_mask: typing.Optional[torch.LongTensor] = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pocket_tts/generation_pocket_tts.py#L40)

**Parámetros:**

sequences (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Los ids de tokens del prompt seguidos de un `audio_latent_token_id` por cada frame generado. El audio en sí está en `audio_latents`.

scores (`tuple(torch.Tensor)` *opcional*, devuelto cuando `output_scores=True`) : El logit de fin de habla de cada cuadro generado, un tensor de forma `(batch_size,)` por cuadro.

logits (`tuple(torch.Tensor)` *opcional*, devuelto cuando `output_logits=True`) : Igual que `scores`: Pocket TTS no tiene vocabulario, por lo que no hay nada que procesar entre ambos.

attentions (`tuple(tuple(torch.Tensor))`, *opcional*, se devuelve cuando `output_attentions=True`) : Tupla (un elemento por cada cuadro generado) de tuplas (un elemento por cada capa) de `torch.Tensor` de forma `(batch_size, num_heads, generated_length, sequence_length)`.

hidden_states (`tuple(tuple(torch.Tensor))`, *opcional*, se devuelve cuando `output_hidden_states=True`) : Tupla (un elemento por cada cuadro generado) de tuplas (un elemento por cada capa) de `torch.Tensor` de forma `(batch_size, generated_length, hidden_size)`.

past_key_values (`Cache`, *opcional*, se devuelve cuando `use_cache=True`) : La caché de claves/valores del backbone al final de la generación.

audio_latents (`torch.Tensor` de forma `(batch_size, num_frames, latent_dim)`) : Los latentes generados, en el espacio latente del tokenizador de audio, rellenos a la derecha con ceros más allá de los propios fotogramas de cada muestra. [PocketTTSProcessor.decode()](/docs/transformers/v5.23.0/es/model_doc/pocket_tts#transformers.PocketTTSProcessor.decode) los convierte en formas de onda.

audio_latents_mask (`torch.LongTensor` de forma `(batch_size, num_frames)`) : Máscara de los fotogramas de cada muestra (`1`), que incluye el fotograma de fin de habla y los fotogramas posteriores, en contraposición al relleno (`0`).

Salidas de `PocketTTSForConditionalGeneration.generate`.

