# Pocket TTS

## Visão geral

O Pocket TTS é o modelo de texto para fala de 100M de parâmetros da [Kyutai](https://kyutai.org), um [Continuous Audio Language Model](https://huggingface.co/papers/2509.06926) que roda mais rápido que o tempo real em CPU. Um transformer causal emite um latente de áudio contínuo por quadro (12,5 Hz) por meio de uma cabeça de fluxo de um passo, e uma cabeça de fim de fala decide quando parar.

O processador contém o [tokenizador de áudio do Pocket TTS](./pocket_tts_audio_tokenizer), um codec baseado no Mimi que codifica prompts de voz e decodifica os latentes gerados em áudio de 24 kHz. As vozes predefinidas são fornecidas como caches de KV (`voices/`).

Duas cabeças de fluxo são disponibilizadas: auto-destilação lagrangiana (`flow_type="lsd"`, padrão) e em deriva (`flow_type="drifting"`, `english_drifting_26-09`). O ajuste fino é suportado, consulte [Training](#training).

Este modelo foi contribuído por [Eustache Le Bihan](https://huggingface.co/eustlb). O código original é [kyutai-labs/pocket-tts](https://github.com/kyutai-labs/pocket-tts).

## Dicas de uso

- Prepare os inputs com [apply_chat_template()](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin.apply_chat_template) (uma mensagem `user` por texto, `add_generation_prompt=True`). O normalizador do tokenizer prepara o texto como o original, com as configurações do idioma do checkpoint.
- `generate` retorna `audio_latents` e `audio_latents_mask`; decodifique-os com [PocketTTSProcessor.decode()](/docs/transformers/main/pt/model_doc/pocket_tts#transformers.PocketTTSProcessor.decode).
- `max_new_tokens` tem como padrão um orçamento baseado no comprimento do texto, e a geração é interrompida pouco depois que o logit de fim de fala ultrapassa `eos_threshold`.
- `do_sample=False` corresponde ao original em temperatura 0. Com amostragem, `temperature` (padrão 0.3) é a variância do ruído inicial do fluxo.
- Divida textos longos com [PocketTTSProcessor.split_text()](/docs/transformers/main/pt/model_doc/pocket_tts#transformers.PocketTTSProcessor.split_text), uma conversa por bloco.

## Uso

### Voz

A voz pode ser fornecida de três maneiras.

**1. Clonando uma gravação**: um item `audio` na conversa.

```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 pré-computados**: um item `audio` vazio, com os latentes passados para o processador.

```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 em cache**: o cache de KV do prompt de voz, passado como `past_key_values`. As vozes incluídas (`voices/`) usam esse formato.

```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 e texto longo

Lote vários textos e vozes, com texto longo dividido em blocos:

```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"]
)
```

### Checkpoint em deriva

Mesmo uso, com as próprias vozes do checkpoint:

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

## Treinamento

Coloque o áudio alvo no turno `assistant`. O processador retorna seus latentes como `labels`, e o modelo retorna a perda original (perda de fluxo LSD mais `config.eos_loss_weight` vezes a perda de fim de fala). O prompt de voz é tipicamente o início da mesma fala.

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

- Forneça a voz como uma gravação ou latentes, não como um cache.
- Para o classifier-free guidance, remova o item `audio` ou `text` da vez do `user` (o original remove cada um com probabilidade 0,2).
- Os latentes pré-computados ficam em `processor_kwargs={"audio_prompt_latents": [...], "labels": [...]}`, com itens vazios `{"type": "audio"}` como marcadores de posição.
- Receita original: AdamW, `learning_rate=2e-5` (2e-4 para um novo idioma), `adam_beta2=0.95`, `weight_decay=0.1`, `max_grad_norm=1.0`, 1000 passos de aquecimento e depois constante, EMA dos pesos (decay 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)
```

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

**Parâmetros:**

flow_head_config (`Union[PocketTTSFlowHeadConfig, dict]`, *opcional*) : A configuração do flow head que amostra cada latente a partir do estado oculto do backbone.

vocab_size (`int`, *opcional*, padrão `4004`) : Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos `input_ids`.

hidden_size (`int`, *opcional*, padrão `1024`) : Dimensão das representações ocultas.

num_hidden_layers (`int`, *opcional*, padrão `6`) : Número de camadas ocultas no decodificador do Transformer.

num_attention_heads (`int`, *opcional*, padrão `16`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.

num_key_value_heads (`int`, *opcional*) : Este é o número de cabeças de key_value que devem ser usadas para implementar Grouped Query Attention. Se `num_key_value_heads=num_attention_heads`, o modelo usará Multi Head Attention (MHA); se `num_key_value_heads=1`, o modelo usará Multi Query Attention (MQA); caso contrário, será usado GQA. Ao converter um checkpoint multi-head para um checkpoint GQA, cada cabeça de chave e valor do grupo deve ser construída pela média (meanpooling) de todas as cabeças originais dentro desse grupo. Para mais detalhes, consulte [este artigo](https://huggingface.co/papers/2305.13245). Se não for especificado, o valor padrão será `num_attention_heads`.

head_dim (`int`, *opcional*) : A dimensão da cabeça de atenção. Se for None, o valor padrão será hidden_size // num_attention_heads

intermediate_size (`int`, *opcional*, padrão `4096`) : Dimensão das representações do MLP.

hidden_act (`str`, *opcional*, padrão `gelu_pytorch_tanh`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

layer_norm_eps (`float`, *opcional*, padrão 1e-05) : Epsilon das normalizações de camada do backbone.

attention_bias (`bool`, *opcional*, padrão `False`) : Se deve usar um viés nas camadas de projeção de query, key, value e output durante a autoatenção.

attention_dropout (`float`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção.

max_position_embeddings (`int`, *opcional*, padrão `8192`) : O comprimento máximo de sequência com o qual este modelo pode ser usado.

rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *opcional*) : Dicionário contendo os parâmetros de configuração para os embeddings RoPE. O dicionário deve conter um valor para `rope_theta` e, opcionalmente, parâmetros usados para escalonamento, caso você queira usar RoPE com `max_position_embeddings` maiores.

latent_dim (`int`, *opcional*, padrão 32) : Dimensão dos latentes de áudio que o backbone recebe como entrada (`audio_prompt_latents`, `audio_latents`); igual ao `latent_dim` do flow head e do tokenizer de áudio.

pad_token_id (`int`, *opcional*, padrão `3`) : ID do token usado para preenchimento no vocabulário.

bos_token_id (`int`, *opcional*) : ID do token usado para o início do fluxo no vocabulário.

eos_token_id (`int`, *opcional*) : ID do token usado para o fim do fluxo no vocabulário.

audio_prompt_token_id (`int`, *opcional*, padrão 4000) : ID do token placeholder dos quadros de prompt de voz em `input_ids`.

audio_latent_token_id (`int`, *opcional*, padrão 4001) : ID do token placeholder das posições latentes de áudio em `input_ids`.

audio_prompt_bos_token_id (`int`, *opcional*, padrão 4002) : ID do token colocado antes do prompt de voz; seu embedding é o vetor aprendido que o original adiciona antes da voz.

audio_bos_token_id (`int`, *opcional*, padrão 4003) : ID do token da primeira posição de áudio, fechando o prompt: ele contém o latente BOS aprendido, a partir do qual o primeiro frame é gerado.

frame_rate (`float`, *opcional*, padrão 12.5) : Número de latentes de áudio por segundo de áudio: `generate` deriva seu orçamento de quadros padrão a partir dele.

initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

use_cache (`bool`, *opcional*, padrão `True`) : Indica se o modelo deve retornar as últimas atenções de chave/valor (não utilizado por todos os modelos). Relevante apenas se `config.is_decoder=True` ou quando o modelo for um modelo generativo somente de decodificador.

eos_loss_weight (`float`, *opcional*, padrão 0.1) : Peso da perda de fim de fala na perda de treinamento.

flow_loss_num_samples (`int`, *opcional*, padrão 4) : Número de extrações de ruído por quadro alvo na perda de fluxo.

lsd_distill_probability (`float`, *opcional*, padrão 0.25) : Probabilidade, a cada passo de treinamento, de calcular o termo de auto-destilação da perda LSD (reponderado para manter a perda esperada); 1 o calcula em todos os passos.

lsd_diagonal_weight (`float`, *opcional*, padrão 0.75) : Peso do termo diagonal (fluxo instantâneo) da perda LSD; o termo de auto-destilação pondera o restante.

lsd_time_logit_mean (`float`, *opcional*, padrão 0.4) : Média da distribuição logit-normal dos tempos de fluxo extraídos pela perda LSD.

lsd_time_logit_std (`float`, *opcional*, padrão 1.0) : Desvio padrão da distribuição logit-normal dos tempos de fluxo extraídos pela perda LSD.

latent_stats_ema_steps (`int`, *opcional*, padrão 1000) : Número dos primeiros passos de treinamento durante os quais `latent_mean` e `latent_std` seguem uma média móvel exponencial dos latentes-alvo; 0 os mantém congelados.

latent_stats_ema_decay (`float`, *opcional*, padrão 0.999) : Decaimento dessa média móvel.

Esta é a classe de configuração para armazenar a configuração de um PocketTTSModel. Ela é usada para instanciar um modelo Pocket Tts de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [eustlb/pocket-tts](https://huggingface.co/eustlb/pocket-tts)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

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

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

**Parâmetros:**

hidden_size (`int`, *opcional*, padrão `512`) : Dimensão das representações ocultas.

num_hidden_layers (`int`, *opcional*, padrão `6`) : Número de camadas ocultas no decodificador do Transformer.

latent_dim (`int`, *opcional*, padrão 32) : Dimensão dos latentes de áudio contínuos que a head prevê (a dimensão latente do tokenizer de áudio).

condition_dim (`int`, *opcional*, padrão 1024) : Dimensão do estado oculto do backbone em que a cabeça é condicionada (o `hidden_size` do backbone).

frequency_embedding_size (`int`, *opcional*, padrão 256) : Tamanho do embedding sinusoidal dos tempos do fluxo.

hidden_act (`str`, *opcional*, padrão `silu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

layer_norm_eps (`float`, *opcional*, padrão 1e-06) : Epsilon das normalizações de camada dentro dos blocos residuais e da camada final.

rms_norm_eps (`float`, *opcional*, padrão 1e-05) : Epsilon da normalização que fecha os embeddings de tempo.

max_period (`float`, *opcional*, padrão 10000.0) : Período máximo do embedding temporal sinusoidal, que o checkpoint armazena como `freqs`.

flow_type (`str`, *opcional*, padrão `"lsd"`) : Objetivo com o qual a cabeça foi treinada, que define como ela é condicionada e amostrada. `"lsd"` (auto-distilação lagrangiana): condicionada nos tempos inicial e final de um passo de fluxo, amostrada por passos de Euler a partir de ruído gaussiano. `"drifting"`: sem condicionamento temporal, a cabeça mapeia o ruído para o latente em uma única chamada.

loss_weighting_hidden_size (`int`, *opcional*, padrão 32) : Largura do MLP que aprende o ponderamento da incerteza dos termos de perda do LSD a partir de seus tempos de fluxo (apenas durante o treinamento).

loss_weighting_num_layers (`int`, *opcional*, padrão 3) : Número de camadas ocultas desse MLP.

Esta é a classe de configuração para armazenar a configuração de um PocketTTSModel. Ela é usada para instanciar um modelo Pocket Tts de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [eustlb/pocket-tts](https://huggingface.co/eustlb/pocket-tts)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

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

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

**Parâmetros:**

feature_size (`int`, *opcional*, padrão 1) : O número de canais.

sampling_rate (`int`, *opcional*, padrão 24000) : A taxa de amostragem na qual a forma de onda de áudio deve ser digitalizada, expressa em hertz (Hz).

padding_value (`float`, *opcional*, padrão 0.0) : O valor usado para preenchimento.

frame_size (`int`, *opcional*, padrão 1920) : Número de amostras de áudio por quadro latente do tokenizador de áudio (seu `frame_size`).

pad_to_multiple_of (`int`, *opcional*, padrão 1920) : Preenche o áudio até um múltiplo deste valor; um múltiplo de `frame_size` mantém todos os quadros latentes inteiros.

end_on_pause (`bool`, *opcional*, padrão `True`) : Se cada forma de onda deve terminar exatamente com `pause_duration` segundos de silêncio: o silêncio final (quadros de `analysis_frame_duration` segundos mais baixos que `silence_floor_db` em relação ao mais alto) é cortado, os últimos `fade_out_duration` segundos do que permanece são atenuados e `pause_duration` segundos de zeros são adicionados.

pause_duration (`float`, *opcional*, padrão 0.08) : Duração do silêncio adicionado por `end_on_pause`, em segundos.

fade_out_duration (`float`, *opcional*, padrão 0.02) : Duração do fade-out aplicado por `end_on_pause` antes da pausa, em segundos.

silence_floor_db (`float`, *opcional*, padrão 35.0) : Nível abaixo do quadro de análise mais alto, em dB, abaixo do qual `end_on_pause` trata os quadros finais como silêncio.

analysis_frame_duration (`float`, *opcional*, padrão 0.02) : Duração, em segundos, dos quadros que `end_on_pause` mede o nível.

Constrói um extrator de recursos do Pocket TTS, que prepara as formas de onda de prompts de voz para o codificador do tokenizador de áudio.

Cada forma de onda termina opcionalmente em uma breve pausa (o `end_on_pause` original: os prompts de treinamento terminam dentro da pausa entre duas palavras, um prompt que para na fala faz o modelo continuar e um que termina em um silêncio longo atrasa o início), em seguida o lote é preenchido à direita até um múltiplo do tamanho de quadro do tokenizer.

#### __call__[[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)
```

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

**Parâmetros:**

audio (`np.ndarray`, `torch.Tensor`, `list[np.ndarray]`, `list[torch.Tensor]`) : A forma de onda mono ou o lote de formas de onda mono dos prompts de voz.

sampling_rate (`int`, *opcional*) : A taxa de amostragem na qual a entrada `audio` foi amostrada. É fortemente recomendável passar `sampling_rate` na chamada de forward para evitar erros silenciosos.

end_on_pause (`bool`, *opcional*) : Se deve encerrar cada forma de onda com uma breve pausa, consulte a docstring da classe. O valor padrão é `self.end_on_pause`.

padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/main/pt/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, padrão `True`) : Estratégia de padding do lote, veja [pad()](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad).

pad_to_multiple_of (`int`, *opcional*) : Preenche o lote até um múltiplo deste valor. O padrão é `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)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/processing_pocket_tts.py#L51)

**Parâmetros:**

feature_extractor (`PocketTTSFeatureExtractor`) : O extrator de recursos é uma entrada obrigatória.

tokenizer (`TokenizersBackend`) : O tokenizer é uma entrada obrigatória.

audio_tokenizer (`PocketTTSAudioTokenizerModel`, *opcional*) : O codec: ele codifica o áudio em latentes e decodifica os latentes gerados em áudio.

chat_template (`str`) : Um modelo Jinja para converter listas de mensagens em um chat em uma string tokenizável.

short_text_max_words (`int`, *opcional*, padrão 4) : Textos com no máximo essa quantidade de palavras recebem `frames_after_eos_short_text` frames após o frame de fim de fala.

frames_after_eos_short_text (`int`, *opcional*, padrão 4) : Número de quadros gerados após o quadro de fim de fala para textos curtos.

frames_after_eos (`int`, *opcional*, padrão 2) : Número de quadros gerados após o quadro de fim de fala para textos mais longos.

fade_in_duration (`float`, *opcional*, padrão 0.005) : Duração, em segundos, do fade-in linear aplicado ao início de cada forma de onda decodificada: um novo estado do decodificador começa com um pequeno passo, ouvido como um clique.

Constrói um PocketTTSProcessor que encapsula um extrator de recursos e um tokenizador em um único processador.

[PocketTTSProcessor](/docs/transformers/main/pt/model_doc/pocket_tts#transformers.PocketTTSProcessor) oferece todas as funcionalidades de [PocketTTSFeatureExtractor](/docs/transformers/main/pt/model_doc/pocket_tts#transformers.PocketTTSFeatureExtractor) e [TokenizersBackend](/docs/transformers/main/pt/main_classes/tokenizer#transformers.TokenizersBackend). Consulte [~PocketTTSFeatureExtractor](/docs/transformers/main/pt/model_doc/pocket_tts#transformers.PocketTTSFeatureExtractor) e [~TokenizersBackend](/docs/transformers/main/pt/main_classes/tokenizer#transformers.TokenizersBackend) para mais informações.

#### __call__[[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'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/processing_pocket_tts.py#L109)

**Parâmetros:**

text (`str` ou `list[str]`) : O(s) prompt(s) renderizado(s) por [apply_chat_template()](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin.apply_chat_template).

audio (`np.ndarray`, `torch.Tensor` ou uma lista deles, *opcional*) : As formas de onda das conversas, mono em 24 kHz, na ordem da conversa: cada voz e, no treinamento, cada alvo.

audio_prompt_latents (`list[torch.Tensor]`, *opcional*) : Vozes pré-computadas, um tensor `(num_frames, latent_dim)` por marcador de voz, em vez de formas de onda.

labels (`list[torch.Tensor]`, *opcional*) : Alvos pré-computados (treinamento), um tensor `(num_frames, latent_dim)` por placeholder de alvo, em vez de formas de onda.

end_on_pause (`bool`, *kwargs*, *opcional*) : Se deve encerrar cada forma de onda de prompt de voz com uma breve pausa, como o original faz antes de clonar uma voz. O padrão é o `end_on_pause` do extrator de recursos.

return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores de um framework específico. Os valores aceitos são:  - `'pt'`: Retorna objetos `torch.Tensor` do PyTorch. - `'np'`: Retorna objetos `np.ndarray` do NumPy.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessingKwargs), *opcional*) : Opções de processamento adicionais para cada modalidade (texto, imagens, vídeos, áudio). Os parâmetros específicos do modelo estão listados acima; consulte a classe TypedDict para a lista completa de argumentos suportados.

**Retorna:**

[BatchFeature](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.BatchFeature) com `input_ids`, `attention_mask`, `audio_prompt_latents` e `audio_prompt_latents_mask`; para geração `frames_after_eos` (frames gerados após o frame de fim de fala, pelo comprimento do texto), para treinamento `labels` e `labels_mask`.

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

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/processing_pocket_tts.py#L285)

**Parâmetros:**

text (`str`) : O texto a ser dividido.

max_tokens (`int`, *opcional*, padrão 50) : Número máximo de tokens por bloco.

Divide `text` em blocos alinhados a frases, com no máximo `max_tokens` tokens, como no `split_into_best_sentences` original: o texto preparado é cortado após o fim das frases (não em pontos decimais), frases mais longas que `max_tokens` após o fim das orações, e as partes são agrupadas de forma gulosa. Cada bloco é destinado a ser uma conversa de um lote.

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

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/processing_pocket_tts.py#L343)

**Parâmetros:**

audio_latents (`torch.Tensor` de forma `(batch_size, num_frames, latent_dim)` ou `(num_frames, latent_dim)`) : Os latentes que `generate` retorna (`PocketTTSGenerateOutput.audio_latents`), decodificados como um lote, ou os latentes de uma amostra.

audio_latents_mask (`torch.Tensor` de forma `(batch_size, num_frames)`, *opcional*) : Máscara dos frames de cada amostra (`PocketTTSGenerateOutput.audio_latents_mask`). Sem ela, cada linha é decodificada em seu comprimento total.

**Retorna:**

`list[torch.Tensor]` de formas de onda 1D na CPU, uma por linha, ou uma forma de onda para os latentes de uma amostra.

Decodifica os latentes gerados em formas de onda com o tokenizador de áudio e aplica um fade-in nos primeiros `fade_in_duration` segundos de cada uma, assim como o 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)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pocket_tts/processing_pocket_tts.py#L392)

Grava a(s) forma(s) de onda gerada(s) em arquivo(s) WAV.

audio (`torch.Tensor`, `np.ndarray` ou uma lista deles): O(s) forma(s) de onda, conforme retornado por [decode()](/docs/transformers/main/pt/model_doc/pocket_tts#transformers.PocketTTSProcessor.decode). saving_path (`str`, `Path` ou uma lista deles): Um caminho por forma de onda. sampling_rate (`int`, *opcional*): Taxa de amostragem das formas de onda, padrão do extrator de recursos (do tokenizador de áudio).

## PocketTTSModel[[transformers.PocketTTSModel]]

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

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

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

**Parâmetros:**

config ([PocketTTSConfig](/docs/transformers/main/pt/model_doc/pocket_tts#transformers.PocketTTSConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O backbone do Pocket TTS: um transformer causal sobre um único fluxo composto pelo prompt de voz, os tokens de texto e os latentes de áudio, retornando os estados ocultos normalizados. O prompt de voz e os latentes de áudio são latentes do tokenizador de áudio, que o processador mantém.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

#### 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'>)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

audio_prompt_latents (`torch.Tensor` de forma `(batch_size, num_prompt_frames, latent_dim)`, *opcional*) : Latentes de prompt de voz do tokenizador de áudio (codificados pelo processador, ou do `voices/` de um checkpoint), com preenchimento à direita até a voz mais longa do lote, distribuídos nas posições de `audio_prompt_token_id`.

audio_prompt_latents_mask (`torch.Tensor` de forma `(batch_size, num_prompt_frames)`, *opcional*) : Máscara dos quadros de voz (`1`) em oposição ao preenchimento (`0`) em `audio_prompt_latents`.

audio_latents (`torch.Tensor` de forma `(batch_size, num_latents, latent_dim)`, *opcional*) : Latentes de áudio normalizados, distribuídos nas posições de `audio_latent_token_id`. A posição de `audio_bos_token_id` antes deles, que fecha o prompt e a partir da qual o primeiro quadro é gerado, sempre recebe o latente BOS aprendido.

audio_latents_mask (`torch.Tensor` de forma `(batch_size, num_latents)`, *opcional*) : Máscara dos latentes de cada linha (`1`) em oposição ao padding (`0`) em `audio_latents`, quando as linhas contêm diferentes números de posições latentes (treinamento).

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`.  Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão.  O modelo sairá no mesmo formato de cache que foi fornecido como entrada.  Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`).

**Retorna:** [BaseModelOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) ou `tuple(torch.Tensor)`

Um [BaseModelOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([PocketTTSConfig](/docs/transformers/main/pt/model_doc/pocket_tts#transformers.PocketTTSConfig)) e das entradas.

O método forward do [PocketTTSModel](/docs/transformers/main/pt/model_doc/pocket_tts#transformers.PocketTTSModel) substitui o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo.

  Se `past_key_values` for usado, apenas o último hidden-state das sequências, com forma `(batch_size, 1, hidden_size)`, é retornado.
- **past_key_values** (`Cache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e, opcionalmente, se `config.is_encoder_decoder=True`, nos blocos de atenção cruzada) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

## PocketTTSForConditionalGeneration[[transformers.PocketTTSForConditionalGeneration]]

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

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

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

**Parâmetros:**

config ([PocketTTSConfig](/docs/transformers/main/pt/model_doc/pocket_tts#transformers.PocketTTSConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O modelo de texto para fala Pocket TTS: o backbone, o flow head que amostra um latente de áudio por passo e o end-of-speech head. Ele gera latentes do tokenizer de áudio, que o processor decodifica em áudio de 24 kHz.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

#### 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'>)
```

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

**Parâmetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

audio_prompt_latents (`torch.Tensor` de forma `(batch_size, num_prompt_frames, latent_dim)`, *opcional*) : Latentes de prompt de voz do tokenizador de áudio, com preenchimento à direita, distribuídos nas posições de `audio_prompt_token_id`.

audio_prompt_latents_mask (`torch.Tensor` de forma `(batch_size, num_prompt_frames)`, *opcional*) : Máscara dos quadros de voz (`1`) em oposição ao preenchimento (`0`) em `audio_prompt_latents`.

audio_latents (`torch.Tensor` de forma `(batch_size, num_latents, latent_dim)`, *opcional*) : Latentes de áudio normalizados, distribuídos nas posições de `audio_latent_token_id`.

labels (`torch.Tensor` de forma `(batch_size, num_frames, latent_dim)`, *opcional*) : Latentes de destino do tokenizador de áudio (treinamento), com preenchimento à direita (right-padded). O prompt de cada linha termina na posição do `audio_bos_token_id`, seguido por uma posição do `audio_latent_token_id` por quadro: o modelo fornece os destinos normalizados (teacher forcing), aplica a perda de fluxo às saídas do BOS e de todos os quadros, exceto o último, que preveem os quadros, e a perda de fim de fala a todos eles, sendo o último o fim da fala.

labels_mask (`torch.Tensor` de forma `(batch_size, num_frames)`, *opcional*) : Máscara dos frames-alvo de cada linha (`1`) em oposição ao padding (`0`) em `labels`.

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`.  Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão.  O modelo sairá no mesmo formato de cache que foi fornecido como entrada.  Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`).

**Retorna:** `PocketTTSOutputWithPast` ou `tuple(torch.Tensor)`

Um `PocketTTSOutputWithPast` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([PocketTTSConfig](/docs/transformers/main/pt/model_doc/pocket_tts#transformers.PocketTTSConfig)) e das entradas.

O método forward de [PocketTTSForConditionalGeneration](/docs/transformers/main/pt/model_doc/pocket_tts#transformers.PocketTTSForConditionalGeneration) substitui o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **loss** (`torch.Tensor` de forma `()`, *opcional*, retornado quando `labels` é passado) -- Perda de treinamento: a perda de fluxo LSD dos latentes de destino mais `config.eos_loss_weight` vezes a perda de fim de fala.
- **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, 1)`) -- Logits de fim de fala, um por posição.
- **past_key_values** (`Cache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.
- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Estados ocultos normalizados do backbone, que condicionam a cabeça de fluxo.

Exemplo:

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

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

**Parâmetros:**

inputs (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Os `input_ids` preparados pelo [PocketTTSProcessor](/docs/transformers/main/pt/model_doc/pocket_tts#transformers.PocketTTSProcessor). Também pode ser passado como `input_ids=`.

kwargs (`dict[str, Any]`, *opcional*) : `attention_mask`, o prompt de voz (`audio_prompt_latents` e `audio_prompt_latents_mask`, ou o cache de um prefixo de voz como `past_key_values`, as vozes incluídas, com prompts apenas de texto), `frames_after_eos` do processador, os parâmetros de geração (`do_sample`, `temperature`, `max_new_tokens`, ...), e os parâmetros específicos do Pocket TTS `num_flow_steps`, `eos_threshold` e `min_frames_before_eos`, que por padrão seguem a configuração de geração.

**Retorna:**

[PocketTTSGenerateOutput](/docs/transformers/main/pt/model_doc/pocket_tts#transformers.models.pocket_tts.generation_pocket_tts.PocketTTSGenerateOutput) quando `return_dict_in_generate=True` (a configuração de geração dos checkpoints): os `audio_latents` com padding e sua `audio_latents_mask`, que o [PocketTTSProcessor.decode()](/docs/transformers/main/pt/model_doc/pocket_tts#transformers.PocketTTSProcessor.decode) decodifica como um único lote. Caso contrário, a lista de latentes gerados, com um tensor `(num_frames, latent_dim)` por amostra, cada um decodificado individualmente.

Gera fala. Este método substitui [generate()](/docs/transformers/main/pt/main_classes/text_generation#transformers.GenerationMixin.generate) para definir `max_new_tokens` como o orçamento de quadros do tempo de execução original, `ceil((num_text_tokens / 3 + 2) * frame_rate)` para o texto mais longo do lote. Todo o restante passa pelos ganchos de geração regulares.

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

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

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

**Parâmetros:**

condition (`torch.Tensor` de forma `(batch_size, hidden_size)`) : Estado oculto do backbone da posição sendo gerada.

noise (`torch.Tensor` de forma `(batch_size, latent_dim)`) : ruído gaussiano escalado por `sqrt(temperature)`, ou zeros.

num_flow_steps (`int`) : Número de passos de Euler do amostrador LSD (ignorado pela cabeça de derivação, que faz uma única chamada).

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

o latente amostrado, no espaço normalizado.

Amostra o próximo latente de `noise` com a flow head.

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

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

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

Mapeia os latentes do espaço normalizado da cabeça de fluxo para o do tokenizador de áudio.

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

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

**Parâmetros:**

sequences (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Os ids dos tokens do prompt seguidos por um `audio_latent_token_id` por quadro gerado. O áudio em si está em `audio_latents`.

scores (`tuple(torch.Tensor)` *opcional*, retornado quando `output_scores=True`) : O logit de fim de fala de cada quadro gerado, um tensor de forma `(batch_size,)` por quadro.

logits (`tuple(torch.Tensor)` *opcional*, retornado quando `output_logits=True`) : Igual a `scores`: o Pocket TTS não possui vocabulário, portanto não há nada para processar entre os dois.

attentions (`tuple(tuple(torch.Tensor))`, *opcional*, retornado quando `output_attentions=True`) : Tupla (um elemento para cada quadro gerado) de tuplas (um elemento para cada camada) de `torch.Tensor` com forma `(batch_size, num_heads, generated_length, sequence_length)`.

hidden_states (`tuple(tuple(torch.Tensor))`, *opcional*, retornado quando `output_hidden_states=True`) : Tupla (um elemento para cada quadro gerado) de tuplas (um elemento para cada camada) de `torch.Tensor` com forma `(batch_size, generated_length, hidden_size)`.

past_key_values (`Cache`, *opcional*, retornado quando `use_cache=True`) : O cache de chave/valor do backbone no final da geração.

audio_latents (`torch.Tensor` de forma `(batch_size, num_frames, latent_dim)`) : Os latentes gerados, no espaço latente do tokenizer de áudio, com preenchimento à direita com zeros além dos próprios frames de cada amostra. [PocketTTSProcessor.decode()](/docs/transformers/main/pt/model_doc/pocket_tts#transformers.PocketTTSProcessor.decode) os converte em formas de onda.

audio_latents_mask (`torch.LongTensor` de forma `(batch_size, num_frames)`) : Máscara dos quadros de cada amostra (`1`), incluindo o quadro de fim de fala e os quadros subsequentes, em oposição ao preenchimento (`0`).

Saídas de `PocketTTSForConditionalGeneration.generate`.