# Gradium Phonon TTS

## Aperçu

Gradium Phonon TTS est la famille de modèles de synthèse vocale sur appareil de [Gradium](https://gradium.ai), entraînée selon la recette de [Pocket TTS](./pocket_tts) : un transformeur causal lit un prompt vocal et le texte, puis émet un latent audio continu de 32 dimensions à chaque étape, à 12,5 Hz, via une tête de flux à une étape, tandis qu'une tête de fin de parole détermine quand l'énoncé est terminé. Les latents sont décodés en audio 24 kHz par un [Pocket TTS audio tokenizer](./pocket_tts_audio_tokenizer) détenu par le processeur, à savoir [PocketTTSProcessor](/docs/transformers/main/fr/model_doc/pocket_tts#transformers.PocketTTSProcessor) de Pocket TTS.

Il se distingue de Pocket TTS par son conditionnement vocal : le prompt vocal est constitué de latents de dimension 512 issus d'un codeur de locuteur distinct, et un vecteur de locuteur appris est ajouté à chaque position latente audio. Le codeur de locuteur n'étant pas publié, les voix sont fournies sous forme de latents précalculés (le fichier `default-voice.safetensors` de chaque point de contrôle, ainsi que le catalogue de [gradium/phonon-voices](https://huggingface.co/gradium/phonon-voices)) et le tokeniseur audio est un décodeur uniquement : il n'est pas possible de cloner une voix à partir d'un enregistrement.

| Point de contrôle | Paramètres | Langues | Licence |
|---|---|---|---|
| [gradium/phonon-31m-en](https://huggingface.co/gradium/phonon-31m-en) | 31M | Anglais | Apache 2.0 |
| [gradium/phonon-40m-en](https://huggingface.co/gradium/phonon-40m-en) | 40M | Anglais | CC BY-NC 4.0 |
| [gradium/phonon-40m-fr](https://huggingface.co/gradium/phonon-40m-fr) | 40M | French | CC BY-NC 4.0 |
| [gradium/phonon-40m-de](https://huggingface.co/gradium/phonon-40m-de) | 40M | Allemand | CC BY-NC 4.0 |
| [gradium/phonon-40m-es](https://huggingface.co/gradium/phonon-40m-es) | 40M | Espagnol | CC BY-NC 4.0 |
| [gradium/phonon-40m-pt](https://huggingface.co/gradium/phonon-40m-pt) | 40M | Portugais | CC BY-NC 4.0 |
| [gradium/phonon-40m-multilingual](https://huggingface.co/gradium/phonon-40m-multilingual) | 40M | Anglais, français, allemand, espagnol, portugais | CC BY-NC 4.0 |

Ils se chargent tous de la même manière : changer de point de contrôle revient à changer l’identifiant du dépôt.

Ce modèle a été contribué par [Eustache Le Bihan](https://huggingface.co/eustlb). Le code d'origine est [gradium-ai/xn-ptts](https://github.com/gradium-ai/xn-ptts).

## Conseils d'utilisation

- Préparez les entrées avec [apply_chat_template()](/docs/transformers/main/fr/main_classes/processors#transformers.ProcessorMixin.apply_chat_template) : un message `user` par texte, un élément vide `{"type": "audio"}` à l’endroit où se trouve la voix, les latents de la voix dans `processor_kwargs={"audio_prompt_latents": [...]}`, et `add_generation_prompt=True`.
- Le tokenizer n'écrit pas les nombres, les montants, les symboles ou les adresses en toutes lettres, voir [Normalisation du texte](#text-normalization).
- `generate` renvoie `audio_latents` et `audio_latents_mask` ; décodez-les avec [PocketTTSProcessor.decode()](/docs/transformers/main/fr/model_doc/pocket_tts#transformers.PocketTTSProcessor.decode).
- Génération d’échantillons comme le fait le runtime de Gradium : `temperature` 0,3 (la variance du bruit initial du flux), et l’arrêt intervient peu après que le logit de fin de parole dépasse `eos_threshold`. `do_sample=False` démarre le flux à partir d’un bruit nul.
- Le modèle est chargé en bf16, le dtype dans lequel ses poids sont stockés ; passez `dtype=torch.float32` sur CPU pour correspondre au runtime de Gradium sur cette plateforme.
- Découpez le long texte avec [PocketTTSProcessor.split_text()](/docs/transformers/main/fr/model_doc/pocket_tts#transformers.PocketTTSProcessor.split_text), une conversation par fragment.

## Utilisation

### Voix

Une voix est un tenseur de latents `(num_frames, 512)`. Chaque checkpoint en fournit un (`default-voice.safetensors`), et [gradium/phonon-voices](https://huggingface.co/gradium/phonon-voices) en propose environ une centaine de plus, dans toutes les langues, chacune sous son identifiant de voix (`voices.jsonl` répertorie leurs noms, langues et descriptions). Toute voix fonctionne avec n’importe quel 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")
```

### Lots et texte long

Traiter par lots plusieurs textes, chacun avec sa propre voix, en découpant les longs textes en segments :

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

### Normalisation du texte

Le tokenizer normalise ce qui ne dépend pas de la langue, tout comme le runtime de Gradium :

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

Il ne prononce pas les nombres, les montants, les symboles ou les adresses, qui dépendent de la langue :

| Texte | Tokenizer | Le runtime de 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.` |

Pour ceux-ci, utilisez la normalisation du texte du runtime de Gradium, [ptts](https://github.com/gradium-ai/xn-ptts), ou écrivez-les en toutes lettres.

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

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

**Paramètres :**

flow_head_config (`Union[GradiumPhononTTSFlowHeadConfig, dict]`, *facultatif*) : La configuration de la tête de flux qui échantillonne chaque latent à partir de l'état caché du backbone.

vocab_size (`int`, *facultatif*, valeur par défaut `4001`) : Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par `input_ids`.

hidden_size (`int`, *facultatif*, par défaut `768`) : Dimension des représentations cachées.

num_hidden_layers (`int`, *facultatif*, valeur par défaut `6`) : Nombre de couches cachées dans le décodeur Transformer.

num_attention_heads (`int`, *facultatif*, valeur par défaut `12`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.

num_key_value_heads (`int`, *facultatif*) : C'est le nombre de têtes de key_value à utiliser pour implémenter l'attention par requêtes groupées (Grouped Query Attention). Si `num_key_value_heads=num_attention_heads`, le modèle utilisera l'attention multi-têtes (Multi Head Attention, MHA) ; si `num_key_value_heads=1`, il utilisera l'attention multi-requête (Multi Query Attention, MQA) ; sinon, c'est la GQA qui est utilisée. Lors de la conversion d'un checkpoint multi-têtes en checkpoint GQA, chaque tête de clé et de valeur du groupe doit être construite en effectuant un meanpooling de toutes les têtes d'origine appartenant à ce groupe. Pour plus de détails, consultez [cet article](https://huggingface.co/papers/2305.13245). S'il n'est pas spécifié, la valeur par défaut est `num_attention_heads`.

head_dim (`int`, *facultatif*) : La dimension des têtes d'attention. Si None, elle est par défaut égale à hidden_size // num_attention_heads

intermediate_size (`int`, *facultatif*, par défaut `3072`) : Dimension des représentations MLP.

hidden_act (`str`, *facultatif*, par défaut `gelu`) : La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc.

layer_norm_eps (`float`, *facultatif*, valeur par défaut 1e-05) : Epsilon des normalisations de couche du backbone.

attention_bias (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut utiliser un biais dans les couches de projection de requête, de clé, de valeur et de sortie lors de l'auto-attention.

attention_dropout (`float`, *facultatif*, valeur par défaut `0.0`) : Le taux de dropout appliqué aux probabilités d'attention.

max_position_embeddings (`int`, *facultatif*, valeur par défaut `8192`) : La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé.

rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *facultatif*) : Dictionnaire contenant les paramètres de configuration pour les embeddings RoPE. Le dictionnaire doit contenir une valeur pour `rope_theta` et, le cas échéant, les paramètres utilisés pour le mise à l'échelle si vous souhaitez utiliser RoPE avec des `max_position_embeddings` plus longs.

latent_dim (`int`, *facultatif*, valeur par défaut 32) : Dimension des latents audio que le backbone reçoit en entrée (`audio_latents`) ; égale à `latent_dim` de la tête de flux et du tokeniseur audio.

pad_token_id (`int`, *facultatif*, valeur par défaut `3`) : Identifiant de jeton utilisé pour le bourrage dans le vocabulaire.

bos_token_id (`int`, *facultatif*) : Identifiant de jeton utilisé pour le début de flux dans le vocabulaire.

eos_token_id (`int`, *facultatif*) : Identifiant de jeton utilisé pour la fin de flux dans le vocabulaire.

audio_prompt_token_id (`int`, *facultatif*, valeur par défaut 5) : Identifiant du jeton de remplacement pour les images de l'invite vocale dans `input_ids` (`<|audio_prompt|>`).

audio_latent_token_id (`int`, *facultatif*, valeur par défaut 6) : Identifiant du jeton de remplacement pour les positions latentes audio dans `input_ids` (`<|audio_latent|>`).

audio_bos_token_id (`int`, *facultatif*, valeur par défaut 4) : Identifiant du jeton de la première position audio, qui clôt le prompt : il contient le latent BOS appris, à partir duquel la première image est générée (`<|audio_bos|>`).

frame_rate (`float`, *facultatif*, valeur par défaut 12,5) : Nombre de latents audio par seconde d'audio : `generate` en dérive son budget de trames par défaut.

initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids.

use_cache (`bool`, *facultatif*, valeur par défaut `True`) : Indique si le modèle doit retourner les dernières attentions clés/valeurs (non utilisé par tous les modèles). Pertinent uniquement si `config.is_decoder=True` ou si le modèle est un modèle génératif de type décodeur uniquement.

eos_loss_weight (`float`, *facultatif*, valeur par défaut 0,1) : Poids de la perte de fin de parole dans la perte d'entraînement.

flow_loss_num_samples (`int`, *facultatif*, valeur par défaut : 4) : Nombre de tirages de bruit par image cible dans la perte de flux.

lsd_distill_probability (`float`, *facultatif*, valeur par défaut 0,25) : Probabilité, à chaque étape d'entraînement, de calculer le terme d'auto-distillation de la perte LSD (repondéré pour maintenir la perte attendue) ; 1 le calcule à chaque étape.

lsd_diagonal_weight (`float`, *facultatif*, valeur par défaut 0,75) : Poids du terme diagonal (flux instantané) de la perte LSD ; le terme d'auto-distillation pondère le reste.

lsd_time_logit_mean (`float`, *facultatif*, valeur par défaut 0,4) : Moyenne de la distribution logit-normale des temps de flux tirés par la perte LSD.

lsd_time_logit_std (`float`, *facultatif*, valeur par défaut 1.0) : Écart-type de la distribution logit-normale des temps de flux tirés par la perte LSD.

latent_stats_ema_steps (`int`, *facultatif*, valeur par défaut 1000) : Nombre de premières étapes d'entraînement au cours desquelles `latent_mean` et `latent_std` suivent une moyenne mobile exponentielle des latents cibles ; 0 les maintient figés.

latent_stats_ema_decay (`float`, *facultatif*, valeur par défaut 0.999) : Décroissance de cette moyenne mobile.

audio_prompt_dim (`int`, *facultatif*, valeur par défaut 512) : Dimension des latents de l'invite vocale (`audio_prompt_latents`), les latents non quantifiés du codec de locuteur de Gradium (un encodeur Mimi, et non celui du tokeniseur audio), que le backbone projette vers `hidden_size`.

num_speakers (`int`, *facultatif*, valeur par défaut : 1) : Valeur de la condition `num_speakers` : la ligne de sa table de recherche ajoutée à chaque position latente audio.

num_speakers_vocab_size (`int`, *facultatif*, valeur par défaut : 32) : Nombre de lignes de la table de recherche `num_speakers`.

num_speakers_embedding_dim (`int`, *facultatif*, par défaut 16) : Largeur de la table de recherche `num_speakers`, projetée sur `hidden_size`.

duration_delta (`float`, *facultatif*, valeur par défaut 0.0) : Valeur de la condition `duration_delta`, encodée de manière sinusoïdale et ajoutée à chaque position latente audio.

duration_delta_embedding_dim (`int`, *facultatif*, valeur par défaut 128) : Taille de l'encodage sinusoïdal de `duration_delta`, projeté sur `hidden_size`.

duration_delta_scale (`float`, *facultatif*, valeur par défaut 1000.0) : Facteur appliqué à `duration_delta` avant son encodage sinusoïdal.

duration_delta_max_period (`float`, *facultatif*, valeur par défaut 10000.0) : Période maximale de l'encodage sinusoïdal de `duration_delta`.

Ceci est la classe de configuration destinée à stocker la configuration d'un GradiumPhononTTSModel. Elle est utilisée pour instancier un modèle Gradium Phonon Tts en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [gradium/phonon-31m-en](https://huggingface.co/gradium/phonon-31m-en)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

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

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

**Paramètres :**

hidden_size (`int`, *facultatif*, par défaut `512`) : Dimension des représentations cachées.

num_hidden_layers (`int`, *facultatif*, valeur par défaut `6`) : Nombre de couches cachées dans le décodeur Transformer.

latent_dim (`int`, *facultatif*, valeur par défaut 32) : Dimension des latents audio continus prédits par la tête (la dimension latente du tokenizer audio).

condition_dim (`int`, *facultatif*, valeur par défaut 768) : Dimension de l'état caché du backbone sur lequel la tête est conditionnée (`hidden_size` du backbone).

frequency_embedding_size (`int`, *facultatif*, valeur par défaut 256) : Taille de l'encodage sinusoïdal des temps de flux.

hidden_act (`str`, *facultatif*, par défaut `silu`) : La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc.

layer_norm_eps (`float`, *facultatif*, valeur par défaut 1e-06) : Epsilon des normalisations de couche dans les blocs résiduels et la couche finale.

rms_norm_eps (`float`, *facultatif*, valeur par défaut 1e-05) : Epsilon de la normalisation fermant les embeddings temporels.

max_period (`float`, *facultatif*, valeur par défaut 10000.0) : Période maximale de l'encodage temporel sinusoïdal, que le point de contrôle stocke sous la forme de `freqs`.

flow_type (`str`, *facultatif*, valeur par défaut `"lsd"`) : Objectif avec lequel la tête a été entraînée, qui détermine sa façon d'être conditionnée et échantillonnée. `"lsd"` (auto-distillation lagrangienne) : conditionnée sur les temps de début et de fin d'une étape de flux, échantillonnée par étapes d'Euler à partir d'un bruit gaussien. `"drifting"` : sans conditionnement temporel, la tête mappe le bruit vers le latent en un seul appel.

loss_weighting_hidden_size (`int`, *facultatif*, valeur par défaut : 32) : Largeur du MLP qui apprend le pondération de l'incertitude des termes de la perte LSD à partir de leurs temps de flux (entraînement uniquement).

loss_weighting_num_layers (`int`, *facultatif*, valeur par défaut 3) : Nombre de couches cachées de ce MLP.

Ceci est la classe de configuration destinée à stocker la configuration d'un GradiumPhononTTSModel. Elle est utilisée pour instancier un modèle Gradium Phonon Tts en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [gradium/phonon-31m-en](https://huggingface.co/gradium/phonon-31m-en)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

## GradiumPhononTTSModel[[transformers.GradiumPhononTTSModel]]

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

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

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

**Paramètres :**

config ([GradiumPhononTTSConfig](/docs/transformers/main/fr/model_doc/gradium_phonon_tts#transformers.GradiumPhononTTSConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le backbone Gradium Phonon TTS : un transformer causal sur un seul flux composé du prompt vocal (latents du codeur de locuteur), des jetons de texte et des latents audio, renvoyant les états cachés normalisés.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.GradiumPhononTTSModel.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'>)
```

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

**Paramètres :**

input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

audio_prompt_latents (`torch.Tensor` de forme `(batch_size, num_prompt_frames, latent_dim)`, *facultatif*) : Latents de l'invite vocale du tokenizer audio (encodés par le processeur, ou par le dossier `voices/` d'un point de contrôle), complétés à droite jusqu'à la longueur de la voix la plus longue du lot, et dispersés aux positions `audio_prompt_token_id`.

audio_prompt_latents_mask (`torch.Tensor` de forme `(batch_size, num_prompt_frames)`, *facultatif*) : Masque des trames vocales (`1`) par opposition au bourrage (`0`) dans `audio_prompt_latents`.

audio_latents (`torch.Tensor` de forme `(batch_size, num_latents, latent_dim)`, *facultatif*) : Latents audio normalisés, dispersés dans les positions `audio_latent_token_id`. La position `audio_bos_token_id` qui les précède, et qui clôt le prompt et à partir de laquelle la première image est générée, reçoit toujours le latent BOS appris.

audio_latents_mask (`torch.Tensor` de forme `(batch_size, num_latents)`, *facultatif*) : Masque des latents de chaque ligne (`1`) par opposition au bourrage (`0`) dans `audio_latents`, lorsque les lignes contiennent un nombre différent de positions latentes (entraînement).

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`.  [Que sont les identifiants de position ?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`.  Seule une instance de [Cache](/docs/transformers/main/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/main/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut.  Le modèle renverra le même format de cache que celui fourni en entrée.  Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle.

use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_key_values`).

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

Un [BaseModelOutputWithPast](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([GradiumPhononTTSConfig](/docs/transformers/main/fr/model_doc/gradium_phonon_tts#transformers.GradiumPhononTTSConfig)) et les entrées.

La méthode forward du [GradiumPhononTTSModel](/docs/transformers/main/fr/model_doc/gradium_phonon_tts#transformers.GradiumPhononTTSModel) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.

  Si `past_key_values` est utilisé, seule la dernière hidden-state des séquences de forme `(batch_size, 1, hidden_size)` est renvoyée.
- **past_key_values** (`Cache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [Cache](/docs/transformers/main/fr/internal/generation_utils#transformers.Cache). Pour plus de détails, consultez notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et, le cas échéant, si `config.is_encoder_decoder=True`, dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.

## GradiumPhononTTSForConditionalGeneration[[transformers.GradiumPhononTTSForConditionalGeneration]]

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

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

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

**Paramètres :**

config ([GradiumPhononTTSConfig](/docs/transformers/main/fr/model_doc/gradium_phonon_tts#transformers.GradiumPhononTTSConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle de synthèse vocale Gradium Phonon TTS : le tronc, la tête de flux qui échantillonne un latent audio à chaque étape et la tête de fin de parole. Il génère des latents du tokenizer audio, que le processeur décode en audio à 24 kHz.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.GradiumPhononTTSForConditionalGeneration.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'>)
```

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

**Paramètres :**

input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

audio_prompt_latents (`torch.Tensor` de forme `(batch_size, num_prompt_frames, latent_dim)`, *facultatif*) : Latents de l'invite vocale du tokenizer audio, complétés à droite, dispersés dans les positions `audio_prompt_token_id`.

audio_prompt_latents_mask (`torch.Tensor` de forme `(batch_size, num_prompt_frames)`, *facultatif*) : Masque des trames vocales (`1`) par opposition au bourrage (`0`) dans `audio_prompt_latents`.

audio_latents (`torch.Tensor` de forme `(batch_size, num_latents, latent_dim)`, *facultatif*) : Latents audio normalisés, dispersés dans les positions `audio_latent_token_id`.

labels (`torch.Tensor` de forme `(batch_size, num_frames, latent_dim)`, *facultatif*) : Latents cibles du tokenizer audio (entraînement), avec remplissage à droite. La prompt de chaque ligne se termine par la position `audio_bos_token_id` suivie d’une position `audio_latent_token_id` par image : le modèle alimente les cibles normalisées (teacher forcing), applique la perte de flux aux sorties du BOS et de toutes les images sauf la dernière, qui prédisent les images, et la perte de fin de parole à toutes, la dernière étant la fin de parole.

labels_mask (`torch.Tensor` de forme `(batch_size, num_frames)`, *facultatif*) : Masque des cibles de chaque ligne (`1`) par opposition au bourrage (`0`) dans `labels`.

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`.  [Que sont les identifiants de position ?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`.  Seule une instance de [Cache](/docs/transformers/main/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/main/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut.  Le modèle renverra le même format de cache que celui fourni en entrée.  Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle.

use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_key_values`).

**Retourne :** `GradiumPhononTTSOutputWithPast` ou `tuple(torch.Tensor)`

Un `GradiumPhononTTSOutputWithPast` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([GradiumPhononTTSConfig](/docs/transformers/main/fr/model_doc/gradium_phonon_tts#transformers.GradiumPhononTTSConfig)) et les entrées.

La méthode forward de [GradiumPhononTTSForConditionalGeneration](/docs/transformers/main/fr/model_doc/gradium_phonon_tts#transformers.GradiumPhononTTSForConditionalGeneration) surcharge la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **loss** (`torch.Tensor` de forme `()`, *facultatif*, renvoyé lorsque `labels` est passé) -- Perte d'entraînement : la perte de flux LSD des latents cibles plus `config.eos_loss_weight` fois la perte de fin de parole.
- **logits** (`torch.Tensor` de forme `(batch_size, sequence_length, 1)`) -- Logits de fin de parole, un par position.
- **past_key_values** (`Cache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [Cache](/docs/transformers/main/fr/internal/generation_utils#transformers.Cache). Pour plus de détails, consultez notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- États cachés normalisés du backbone, qui conditionnent la tête de flux.

Exemple :

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

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

**Paramètres :**

inputs (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Les `input_ids` préparés par [PocketTTSProcessor](/docs/transformers/main/fr/model_doc/pocket_tts#transformers.PocketTTSProcessor). Peut également être transmis sous la forme `input_ids=`.

kwargs (`dict[str, Any]`, *facultatif*) : `attention_mask`, le prompt vocal (`audio_prompt_latents` et `audio_prompt_latents_mask`, ou le cache d'un préfixe vocal sous forme de `past_key_values`, les voix fournies, avec des prompts de texte uniquement), `frames_after_eos` issu du processeur, les paramètres de génération (`do_sample`, `temperature`, `max_new_tokens`, ...), ainsi que `num_flow_steps`, `eos_threshold` et `min_frames_before_eos` spécifiques à Pocket TTS, qui par défaut correspondent à la configuration de génération.

**Retourne :**

[PocketTTSGenerateOutput](/docs/transformers/main/fr/model_doc/pocket_tts#transformers.models.pocket_tts.generation_pocket_tts.PocketTTSGenerateOutput) lorsque `return_dict_in_generate=True` (config de génération des checkpoints) : les `audio_latents` rembourrés et leur `audio_latents_mask`, que [PocketTTSProcessor.decode()](/docs/transformers/main/fr/model_doc/pocket_tts#transformers.PocketTTSProcessor.decode) décode en un seul lot. Sinon, la liste des latents générés, un tenseur `(num_frames, latent_dim)` par échantillon, chacun décodé individuellement.

Génère de la parole. Cette méthode redéfinit [generate()](/docs/transformers/main/fr/main_classes/text_generation#transformers.GenerationMixin.generate) pour définir `max_new_tokens` par défaut sur le budget de trames du temps d'exécution d'origine, soit `ceil((num_text_tokens / 3 + 2) * frame_rate)` pour le texte le plus long du lot. Le reste passe par les hooks de génération habituels.