# Gradium Phonon TTS

## Visão geral

Gradium Phonon TTS é a família de modelos de texto para fala em dispositivo da [Gradium](https://gradium.ai), treinada com a receita do [Pocket TTS](./pocket_tts): um transformer causal lê um prompt de voz e o texto, emite um latente de áudio contínuo de 32 dimensões por passo a 12,5 Hz por meio de uma cabeça de fluxo de um passo, e uma cabeça de fim de fala decide quando a fala termina. Os latentes são decodificados para áudio de 24 kHz por um [Pocket TTS audio tokenizer](./pocket_tts_audio_tokenizer) mantido pelo processador, o [PocketTTSProcessor](/docs/transformers/main/pt/model_doc/pocket_tts#transformers.PocketTTSProcessor) do Pocket TTS.

Ele difere do Pocket TTS em seu condicionamento de voz: o prompt de voz é composto por latentes de 512 dimensões de um codec de falante separado, e um vetor de falante aprendido é adicionado a cada posição de latente de áudio. O codec de falante não foi liberado, portanto, as vozes são fornecidas como latentes pré-computados (o `default-voice.safetensors` de cada checkpoint e o catálogo de [gradium/phonon-voices](https://huggingface.co/gradium/phonon-voices)) e o tokenizador de áudio é apenas um decodificador: as vozes não podem ser clonadas a partir de uma gravação.

| Checkpoint | Parâmetros | Idiomas | Licença |
|---|---|---|---|
| [gradium/phonon-31m-en](https://huggingface.co/gradium/phonon-31m-en) | 31M | Inglês | Apache 2.0 |
| [gradium/phonon-40m-en](https://huggingface.co/gradium/phonon-40m-en) | 40M | Inglês | CC BY-NC 4.0 |
| [gradium/phonon-40m-fr](https://huggingface.co/gradium/phonon-40m-fr) | 40M | Francês | CC BY-NC 4.0 |
| [gradium/phonon-40m-de](https://huggingface.co/gradium/phonon-40m-de) | 40M | Alemão | CC BY-NC 4.0 |
| [gradium/phonon-40m-es](https://huggingface.co/gradium/phonon-40m-es) | 40M | Espanhol | CC BY-NC 4.0 |
| [gradium/phonon-40m-pt](https://huggingface.co/gradium/phonon-40m-pt) | 40M | Português | CC BY-NC 4.0 |
| [gradium/phonon-40m-multilingual](https://huggingface.co/gradium/phonon-40m-multilingual) | 40M | Inglês, Francês, Alemão, Espanhol, Português | CC BY-NC 4.0 |

Todos eles são carregados da mesma forma: alternar entre checkpoints significa alterar o id do repositório.

Este modelo foi contribuído por [Eustache Le Bihan](https://huggingface.co/eustlb). O código original é [gradium-ai/xn-ptts](https://github.com/gradium-ai/xn-ptts).

## Dicas de uso

- Prepare as entradas com [apply_chat_template()](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin.apply_chat_template): uma mensagem `user` por texto, um item vazio `{"type": "audio"}` onde a voz será inserida, os latentes da voz em `processor_kwargs={"audio_prompt_latents": [...]}` e `add_generation_prompt=True`.
- O tokenizer não expande números, quantidades, símbolos ou endereços, consulte [Normalização de texto](#text-normalization).
- `generate` retorna `audio_latents` e `audio_latents_mask`; decodifique-os com [PocketTTSProcessor.decode()](/docs/transformers/main/pt/model_doc/pocket_tts#transformers.PocketTTSProcessor.decode).
- Amostras de geração como o runtime do Gradium faz: `temperature` 0,3 (a variância do ruído inicial do fluxo), e ele para pouco depois que o logit de fim de fala ultrapassa `eos_threshold`. `do_sample=False` inicia o fluxo a partir de ruído zero.
- O modelo é carregado em bf16, o dtype em que seus pesos são armazenados; passe `dtype=torch.float32` na CPU para corresponder ao runtime do Gradium ali.
- 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

Uma voz é um tensor de latentes `(num_frames, 512)`. Cada checkpoint inclui uma (`default-voice.safetensors`), e o [gradium/phonon-voices](https://huggingface.co/gradium/phonon-voices) possui cerca de cem outras, em todos os idiomas, cada uma sob seu ID de voz (`voices.jsonl` lista seus nomes, idiomas e descrições). Qualquer voz funciona com qualquer checkpoint.

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

model_id = "gradium/phonon-31m-en"
processor = AutoProcessor.from_pretrained(model_id, device_map="auto")
model = GradiumPhononTTSForConditionalGeneration.from_pretrained(model_id, device_map="auto")

def load_voice(voice_id):
    """A voice of gradium/phonon-voices, as latents of shape (num_frames, 512)."""
    path = hf_hub_download("gradium/phonon-voices", f"voices/{voice_id}.safetensors")
    return load_file(path)["speaker_wavs"][0].T.float()

# Easton (en-us); the checkpoint's own voice: hf_hub_download(model_id, "default-voice.safetensors")
voice = load_voice("LMDIYE0Oa377Qh6Z")
# an empty `audio` item marks the voice
conversation = [
    {"role": "user", "content": [{"type": "audio"}, {"type": "text", "text": "Hello from Phonon."}]}
]
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, "phonon.wav")
```

### Lotes e texto longo

Lote vários textos, cada um com sua própria voz, com o texto longo dividido em blocos:

```python
text = (
    "Phonon is a small text-to-speech model that runs on your device. "
    "Long texts are split into sentences, and each chunk is one conversation of the batch."
)
chunks = processor.split_text(text)
texts = chunks + ["And this one is said by another voice."]
voices = [load_voice("LMDIYE0Oa377Qh6Z")] * len(chunks) + [load_voice("NbpkqMVS3CJeq2j8")]
conversations = [
    [{"role": "user", "content": [{"type": "audio"}, {"type": "text", "text": text}]}] for text in texts
]
inputs = processor.apply_chat_template(
    conversations,
    tokenize=True,
    return_dict=True,
    add_generation_prompt=True,
    processor_kwargs={"audio_prompt_latents": voices},
).to(model.device)

outputs = model.generate(**inputs)
audio = processor.decode(outputs.audio_latents, outputs.audio_latents_mask)
processor.save_audio([torch.cat(audio[: len(chunks)]), audio[-1]], ["long.wav", "other.wav"])
```

### Normalização de texto

O tokenizer normaliza o que não depende do idioma, assim como o runtime do Gradium:

| Texto | Tokenizer |
|---|---|
| `“Hello” — it’s here…` | `"Hello" it's here.` |
| `hello (world); see you 🚀` | `Hello, world, see you.` |

Ele não descreve números, quantidades, símbolos ou endereços, que dependem do idioma:

| Texto | Tokenizer | Runtime do Gradium |
|---|---|---|
| `It costs $1,234.56.` | `It costs $1,234.56.` | `It costs 1 thousand 234 dollars and 56 cents.` |
| `Write to jean@gradium.ai` | `Write to jean@gradium.ai.` | `Write to jean at gradium dot A-I.` |
| `It is 21°C` | `It is 21°C.` | `It is 21 degrees Celsius.` |

Para esses, use a normalização de texto do runtime do Gradium, [ptts](https://github.com/gradium-ai/xn-ptts), ou escreva-os por extenso.

## GradiumPhononTTSConfig[[transformers.GradiumPhononTTSConfig]]

#### transformers.GradiumPhononTTSConfig[[transformers.GradiumPhononTTSConfig]]

```python
transformers.GradiumPhononTTSConfig(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 = 4001, hidden_size: int = 768, num_hidden_layers: int = 6, num_attention_heads: int = 12, num_key_value_heads: int | None = None, head_dim: int | None = None, intermediate_size: int = 3072, hidden_act: str = 'gelu', 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 = 5, audio_latent_token_id: int = 6, audio_bos_token_id: int = 4, 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, audio_prompt_dim: int = 512, num_speakers: int = 1, num_speakers_vocab_size: int = 32, num_speakers_embedding_dim: int = 16, duration_delta: float = 0.0, duration_delta_embedding_dim: int = 128, duration_delta_scale: float = 1000.0, duration_delta_max_period: float = 10000.0)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gradium_phonon_tts/configuration_gradium_phonon_tts.py#L82)

**Parâmetros:**

flow_head_config (`Union[GradiumPhononTTSFlowHeadConfig, 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 `4001`) : 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 `768`) : 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 `12`) : 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 `3072`) : Dimensão das representações do MLP.

hidden_act (`str`, *opcional*, padrão `gelu`) : 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_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 5) : ID do token placeholder dos frames de voice-prompt em `input_ids` (`<|audio_prompt|>`).

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

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

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.

audio_prompt_dim (`int`, *opcional*, padrão 512) : Dimensão dos latentes do prompt de voz (`audio_prompt_latents`), os latentes não quantizados do codec de falante do Gradium (um codificador Mimi, não o do tokenizador de áudio), que o backbone projeta para `hidden_size`.

num_speakers (`int`, *opcional*, padrão 1) : Valor da condição `num_speakers`: a linha da sua tabela de consulta adicionada a cada posição latente de áudio.

num_speakers_vocab_size (`int`, *opcional*, padrão 32) : Número de linhas da tabela de consulta `num_speakers`.

num_speakers_embedding_dim (`int`, *opcional*, padrão 16) : Largura da tabela de consulta `num_speakers`, projetada para `hidden_size`.

duration_delta (`float`, *opcional*, padrão 0.0) : Valor da condição `duration_delta`, incorporado sinusoidalmente e adicionado a cada posição latente de áudio.

duration_delta_embedding_dim (`int`, *opcional*, padrão 128) : Tamanho do embedding senoidal de `duration_delta`, projetado para `hidden_size`.

duration_delta_scale (`float`, *opcional*, padrão 1000.0) : Fator aplicado a `duration_delta` antes de sua incorporação senoidal.

duration_delta_max_period (`float`, *opcional*, padrão 10000.0) : Período máximo do embedding senoidal de `duration_delta`.

Esta é a classe de configuração para armazenar a configuração de um GradiumPhononTTSModel. Ela é usada para instanciar um modelo Gradium Phonon 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 [gradium/phonon-31m-en](https://huggingface.co/gradium/phonon-31m-en)

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.

## GradiumPhononTTSFlowHeadConfig[[transformers.GradiumPhononTTSFlowHeadConfig]]

#### transformers.GradiumPhononTTSFlowHeadConfig[[transformers.GradiumPhononTTSFlowHeadConfig]]

```python
transformers.GradiumPhononTTSFlowHeadConfig(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 = 768, 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/gradium_phonon_tts/configuration_gradium_phonon_tts.py#L33)

**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 768) : Dimensão do estado oculto do backbone em que a head é 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 GradiumPhononTTSModel. Ela é usada para instanciar um modelo Gradium Phonon 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 [gradium/phonon-31m-en](https://huggingface.co/gradium/phonon-31m-en)

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.

## GradiumPhononTTSModel[[transformers.GradiumPhononTTSModel]]

#### transformers.GradiumPhononTTSModel[[transformers.GradiumPhononTTSModel]]

```python
transformers.GradiumPhononTTSModel(config: GradiumPhononTTSConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gradium_phonon_tts/modeling_gradium_phonon_tts.py#L393)

**Parâmetros:**

config ([GradiumPhononTTSConfig](/docs/transformers/main/pt/model_doc/gradium_phonon_tts#transformers.GradiumPhononTTSConfig)) : 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 Gradium Phonon TTS: um transformer causal sobre um único fluxo composto pelo prompt de voz (latentes do codec do falante), os tokens de texto e os latentes de áudio, retornando os estados ocultos normalizados.

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

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, audio_prompt_latents: typing.Optional[torch.FloatTensor] = None, audio_prompt_latents_mask: typing.Optional[torch.Tensor] = None, audio_latents: typing.Optional[torch.FloatTensor] = 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.FloatTensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gradium_phonon_tts/modeling_gradium_phonon_tts.py#L417)

**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.FloatTensor` de forma `(batch_size, num_prompt_frames, latent_dim)`, *opcional*) : Latentes de prompt de voz do tokenizer de áudio (codificados pelo processor, ou do `voices/` de um checkpoint), com padding à direita até a voz mais longa do batch, 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.FloatTensor` 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 encerra o prompt e a partir da qual o primeiro frame é gerado, sempre recebe o latente de 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.FloatTensor` 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.FloatTensor)`

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

O método forward do [GradiumPhononTTSModel](/docs/transformers/main/pt/model_doc/gradium_phonon_tts#transformers.GradiumPhononTTSModel) sobrescreve 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.FloatTensor` 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.FloatTensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.FloatTensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de 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.FloatTensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.FloatTensor` (uma 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.

## GradiumPhononTTSForConditionalGeneration[[transformers.GradiumPhononTTSForConditionalGeneration]]

#### transformers.GradiumPhononTTSForConditionalGeneration[[transformers.GradiumPhononTTSForConditionalGeneration]]

```python
transformers.GradiumPhononTTSForConditionalGeneration(config: GradiumPhononTTSConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gradium_phonon_tts/modeling_gradium_phonon_tts.py#L693)

**Parâmetros:**

config ([GradiumPhononTTSConfig](/docs/transformers/main/pt/model_doc/gradium_phonon_tts#transformers.GradiumPhononTTSConfig)) : 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 Gradium Phonon TTS: o backbone, o flow head que amostra um latente de áudio por etapa 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.GradiumPhononTTSForConditionalGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, audio_prompt_latents: typing.Optional[torch.FloatTensor] = None, audio_prompt_latents_mask: typing.Optional[torch.Tensor] = None, audio_latents: typing.Optional[torch.FloatTensor] = None, labels: typing.Optional[torch.FloatTensor] = 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.FloatTensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gradium_phonon_tts/modeling_gradium_phonon_tts.py#L725)

**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.FloatTensor` de forma `(batch_size, num_prompt_frames, latent_dim)`, *opcional*) : Latentes de prompt de voz do tokenizer 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.FloatTensor` 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.FloatTensor` de forma `(batch_size, num_frames, latent_dim)`, *opcional*) : Latentes-alvo do tokenizador de áudio (treinamento), com preenchimento à direita. O prompt de cada linha termina na posição `audio_bos_token_id`, seguido por uma posição `audio_latent_token_id` por quadro: o modelo fornece os alvos 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 de 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.FloatTensor` 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:** `GradiumPhononTTSOutputWithPast` ou `tuple(torch.FloatTensor)`

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

O método forward de [GradiumPhononTTSForConditionalGeneration](/docs/transformers/main/pt/model_doc/gradium_phonon_tts#transformers.GradiumPhononTTSForConditionalGeneration) 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.FloatTensor` de forma `()`, *opcional*, retornado quando `labels` é passado) -- Perda de treinamento: a perda de fluxo LSD dos latentes-alvo mais `config.eos_loss_weight` vezes a perda de fim de fala.
- **logits** (`torch.FloatTensor` 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.FloatTensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.FloatTensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de 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.FloatTensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.FloatTensor` (uma 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.FloatTensor` 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, GradiumPhononTTSForConditionalGeneration

>>> model = GradiumPhononTTSForConditionalGeneration.from_pretrained("gradium/phonon-31m-en")

>>> processor = AutoProcessor.from_pretrained("gradium/phonon-31m-en")
>>> inputs = processor(text="Hello, my dog is cute", return_tensors="pt")

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

#### generate[[transformers.GradiumPhononTTSForConditionalGeneration.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.