# VITS

[VITS (Variational Inference with adversarial learning for end-to-end Text-to-Speech)](https://huggingface.co/papers/2106.06103) est un modèle de synthèse vocale de bout en bout qui simplifie les systèmes de synthèse vocale (TTS) traditionnels en deux étapes. Il se distingue par sa capacité à synthétiser directement la parole à partir du texte en utilisant l'inférence variationnelle, l'apprentissage adversarial et les flux normalisants, afin de produire une parole naturelle et expressive, dotée de rythmes et d'intonations variés.

Vous pouvez trouver tous les points de contrôle VITS originaux sous l’organisation [AI at Meta](https://huggingface.co/facebook?search_models=mms-tts).

> [!TIP]
> Cliquez sur les modèles VITS dans la barre latérale droite pour plus d’exemples sur l’application de VITS.

L'exemple ci-dessous montre comment générer du texte à partir d'une image avec [Pipeline](/docs/transformers/v5.23.0/fr/main_classes/pipelines#transformers.Pipeline) ou la classe [AutoModel](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoModel).

```python
from scipy.io.wavfile import write

from transformers import pipeline, set_seed

set_seed(555)

pipe = pipeline(
    task="text-to-speech",
    model="facebook/mms-tts-eng",
    device=0
)

speech = pipe("Hello, my dog is cute")

# Extract audio data and sampling rate
audio_data = speech["audio"]
sampling_rate = speech["sampling_rate"]

# Save as WAV file
write("hello.wav", sampling_rate, audio_data.squeeze())
```

```python
import scipy
import torch
from IPython.display import Audio

from transformers import AutoTokenizer, VitsModel, set_seed

tokenizer = AutoTokenizer.from_pretrained("facebook/mms-tts-eng")
model = VitsModel.from_pretrained("facebook/mms-tts-eng", device_map="auto")
inputs = tokenizer("Hello, my dog is cute", return_tensors="pt").to(model.device)

set_seed(555)

with torch.no_grad():
    outputs = model(**inputs)

waveform = outputs.waveform[0]
scipy.io.wavfile.write("hello.wav", rate=model.config.sampling_rate, data=waveform)

# display in Colab notebook
Audio(waveform, rate=model.config.sampling_rate)
```

## Notes

- Définissez une graine pour la reproductibilité, car VITS synthétise la parole de manière non déterministe.
- Pour les langues utilisant des alphabets non latins (coréen, arabe, etc.), installez le package [uroman](https://github.com/isi-nlp/uroman) afin de prétraiter les entrées textuelles vers l'alphabet latin. Vous pouvez vérifier si le tokenizer nécessite uroman, comme indiqué ci-dessous.

   ```py
   # pip install -U uroman
   from transformers import VitsTokenizer

   tokenizer = VitsTokenizer.from_pretrained("facebook/mms-tts-eng")
   print(tokenizer.is_uroman)
   ```

   Si votre langue nécessite uroman, le tokenizer l’applique automatiquement aux entrées textuelles.

## VitsConfig[[transformers.VitsConfig]]

#### transformers.VitsConfig[[transformers.VitsConfig]]

```python
transformers.VitsConfig(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, vocab_size: int = 38, hidden_size: int = 192, num_hidden_layers: int = 6, num_attention_heads: int = 2, window_size: int = 4, use_bias: bool = True, ffn_dim: int = 768, layerdrop: float | int = 0.1, ffn_kernel_size: int = 3, flow_size: int = 192, spectrogram_bins: int = 513, hidden_act: str = 'relu', hidden_dropout: float | int = 0.1, attention_dropout: float | int = 0.1, activation_dropout: float | int = 0.1, initializer_range: float = 0.02, layer_norm_eps: float = 1e-05, use_stochastic_duration_prediction: bool = True, num_speakers: int = 1, speaker_embedding_size: int = 0, upsample_initial_channel: int = 512, upsample_rates: list[int] | tuple[int, ...] = (8, 8, 2, 2), upsample_kernel_sizes: list[int] | tuple[int, ...] = (16, 16, 4, 4), resblock_kernel_sizes: list[int] | tuple[int, ...] = (3, 7, 11), resblock_dilation_sizes: list | tuple = ((1, 3, 5), (1, 3, 5), (1, 3, 5)), leaky_relu_slope: float = 0.1, depth_separable_channels: int = 2, depth_separable_num_layers: int = 3, duration_predictor_flow_bins: int = 10, duration_predictor_tail_bound: float = 5.0, duration_predictor_kernel_size: int = 3, duration_predictor_dropout: float | int = 0.5, duration_predictor_num_flows: int = 4, duration_predictor_filter_channels: int = 256, prior_encoder_num_flows: int = 4, prior_encoder_num_wavenet_layers: int = 4, posterior_encoder_num_wavenet_layers: int = 16, wavenet_kernel_size: int = 5, wavenet_dilation_rate: int = 1, wavenet_dropout: float | int = 0.0, speaking_rate: float | int = 1.0, noise_scale: float = 0.667, noise_scale_duration: float = 0.8, sampling_rate: int = 16000, pad_token_id: int | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vits/configuration_vits.py#L24)

**Paramètres :**

vocab_size (`int`, *facultatif*, valeur par défaut `38`) : 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 `192`) : 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 `2`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.

window_size (`int`, *facultatif*, valeur par défaut : 4) : Taille de la fenêtre pour les embeddings positionnels relatifs dans les couches d'attention de l'encodeur Transformer.

use_bias (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut utiliser un biais dans les couches de projection des clés, requêtes et valeurs de l'encodeur Transformer.

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

layerdrop (`Union[float, int]`, *facultatif*, valeur par défaut `0.1`) : La probabilité de LayerDrop. Consultez l'article [LayerDrop](see https://huggingface.co/papers/1909.11556) pour plus de détails.

ffn_kernel_size (`int`, *facultatif*, valeur par défaut 3) : Taille du noyau des couches de convolution 1D utilisées par le réseau feed-forward dans l'encodeur Transformer.

flow_size (`int`, *facultatif*, valeur par défaut 192) : Dimensionnalité des couches de flux.

spectrogram_bins (`int`, *facultatif*, valeur par défaut 513) : Nombre de bandes de fréquence dans le spectrogramme cible.

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

hidden_dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.1`) : La probabilité de dropout pour toutes les couches entièrement connectées des embeddings, de l'encodeur et du pooler.

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

activation_dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.1`) : Le taux de dropout pour les activations à l'intérieur de la couche entièrement connectée.

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.

layer_norm_eps (`float`, *facultatif*, valeur par défaut `1e-05`) : L'épsilon utilisé par les couches de normalisation de couche.

use_stochastic_duration_prediction (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut utiliser le module de prédiction de durée stochastique ou le prédicteur de durée standard.

num_speakers (`int`, *facultatif*, valeur par défaut : 1) : Nombre d'orateurs s'il s'agit d'un modèle multi-orateurs.

speaker_embedding_size (`int`, *facultatif*, valeur par défaut 0) : Nombre de canaux utilisés par les embeddings de locuteur. Valeur nulle pour les modèles mono-locuteur.

upsample_initial_channel (`int`, *facultatif*, valeur par défaut : 512) : Le nombre de canaux d'entrée du réseau de suréchantillonnage HiFi-GAN.

upsample_rates (`tuple[int]` ou `list[int]`, *facultatif*, valeur par défaut `[8, 8, 2, 2]`) : Un tuple d'entiers définissant le pas de chaque couche de convolution 1D dans le réseau de suréchantillonnage HiFi-GAN. La longueur de `upsample_rates` définit le nombre de couches de convolution et doit correspondre à la longueur de `upsample_kernel_sizes`.

upsample_kernel_sizes (`tuple[int]` ou `list[int]`, *facultatif*, valeur par défaut `[16, 16, 4, 4]`) : Un tuple d'entiers définissant la taille du noyau de chaque couche convolutive 1D du réseau de suréchantillonnage HiFi-GAN. La longueur de `upsample_kernel_sizes` définit le nombre de couches convolutives et doit correspondre à la longueur de `upsample_rates`.

resblock_kernel_sizes (`tuple[int]` ou `list[int]`, *facultatif*, valeur par défaut `[3, 7, 11]`) : Un tuple d'entiers définissant les tailles de noyau des couches de convolution 1D du module de fusion multi-réceptif (MRF) de HiFi-GAN.

resblock_dilation_sizes (`tuple[tuple[int]]` ou `list[list[int]]`, *facultatif*, par défaut `[[1, 3, 5], [1, 3, 5], [1, 3, 5]]`) : Un tuple imbriqué d'entiers définissant les taux de dilatation des couches de convolution 1D dilatées dans le module de fusion multi-récepteur (MRF) de HiFi-GAN.

leaky_relu_slope (`float`, *facultatif*, valeur par défaut 0,1) : L'angle de la pente négative utilisé par l'activation leaky ReLU.

depth_separable_channels (`int`, *facultatif*, valeur par défaut : 2) : Nombre de canaux à utiliser dans chaque bloc séparable en profondeur.

depth_separable_num_layers (`int`, *facultatif*, valeur par défaut : 3) : Nombre de couches de convolution à utiliser dans chaque bloc séparable en profondeur.

duration_predictor_flow_bins (`int`, *facultatif*, valeur par défaut : 10) : Nombre de canaux à mapper à l'aide de la spline rationnelle non contrainte dans le modèle de prédicteur de durée.

duration_predictor_tail_bound (`float`, *facultatif*, valeur par défaut 5.0) : Valeur de la limite de la classe de queue lors du calcul de la spline rationnelle non contrainte dans le modèle de prédicteur de durée.

duration_predictor_kernel_size (`int`, *facultatif*, valeur par défaut : 3) : Taille du noyau des couches de convolution 1D utilisées dans le modèle de prédiction de la durée.

duration_predictor_dropout (`float`, *facultatif*, valeur par défaut 0,5) : Le taux de dropout pour le modèle de prédiction de la durée.

duration_predictor_num_flows (`int`, *facultatif*, valeur par défaut : 4) : Nombre d'étapes de flux utilisées par le modèle de prédiction de durée.

duration_predictor_filter_channels (`int`, *facultatif*, valeur par défaut : 256) : Nombre de canaux des couches de convolution utilisées dans le modèle de prédiction de la durée.

prior_encoder_num_flows (`int`, *facultatif*, valeur par défaut : 4) : Nombre de stades de flux utilisés par le modèle de flux de l'encodeur a priori.

prior_encoder_num_wavenet_layers (`int`, *facultatif*, valeur par défaut 4) : Nombre de couches WaveNet utilisées par le modèle de flux de l'encodeur a priori.

posterior_encoder_num_wavenet_layers (`int`, *facultatif*, valeur par défaut 16) : Nombre de couches WaveNet utilisées par le modèle d'encodeur a posteriori.

wavenet_kernel_size (`int`, *facultatif*, valeur par défaut : 5) : Taille du noyau des couches de convolution 1D utilisées dans le modèle WaveNet.

wavenet_dilation_rate (`int`, *facultatif*, valeur par défaut : 1) : Taux de dilatation des couches de convolution 1D dilatées utilisées dans le modèle WaveNet.

wavenet_dropout (`float`, *facultatif*, valeur par défaut 0.0) : Le taux de dropout pour les couches WaveNet.

speaking_rate (`float`, *facultatif*, valeur par défaut 1.0) : Vitesse de parole. Des valeurs plus élevées produisent une voix synthétisée plus rapide.

noise_scale (`float`, *facultatif*, valeur par défaut 0.667) : Niveau d'aléa de la prédiction de la parole. Des valeurs plus élevées génèrent plus de variations dans la parole prédite.

noise_scale_duration (`float`, *facultatif*, valeur par défaut 0,8) : Niveau d'aléa de la prédiction de la durée. Des valeurs plus élevées génèrent plus de variation dans les durées prédites.

sampling_rate (`int`, *facultatif*, valeur par défaut `16000`) : Le taux d'échantillonnage auquel les fichiers audio doivent être numérisés, exprimé en hertz (Hz).

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

Ceci est la classe de configuration destinée à stocker la configuration d'un VitsModel. Elle est utilisée pour instancier un modèle Vits 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 [facebook/mms-tts-eng](https://huggingface.co/facebook/mms-tts-eng)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/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/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

Exemple :

```python
>>> from transformers import VitsModel, VitsConfig

>>> # Initializing a "facebook/mms-tts-eng" style configuration
>>> configuration = VitsConfig()

>>> # Initializing a model (with random weights) from the "facebook/mms-tts-eng" style configuration
>>> model = VitsModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## VitsTokenizer[[transformers.VitsTokenizer]]

#### transformers.VitsTokenizer[[transformers.VitsTokenizer]]

```python
transformers.VitsTokenizer(vocab_file, pad_token = '<pad>', unk_token = '<unk>', language = None, add_blank = True, normalize = True, phonemize = True, is_uroman = False, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vits/tokenization_vits.py#L46)

**Paramètres :**

vocab_file (`str`) : Chemin vers le fichier de vocabulaire.

language (`str`, *facultatif*) : Identifiant de la langue.

add_blank (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut insérer l'identifiant de jeton 0 entre les autres jetons.

normalize (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut normaliser le texte d'entrée en supprimant toutes les majuscules et la ponctuation.

phonemize (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut convertir le texte d'entrée en phonèmes.

is_uroman (`bool`, *facultatif*, valeur par défaut `False`) : Indique si le romaniseur `uroman` doit être appliqué au texte d'entrée avant la tokenisation.

Construit un tokeniseur VITS. Prend également en charge MMS-TTS.

Ce tokenizer hérite de [PreTrainedTokenizer](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.PythonBackend), qui contient la plupart des méthodes principales. Les utilisateurs doivent se reporter à cette superclasse pour plus d’informations sur ces méthodes.

#### __appel__[[transformers.VitsTokenizer.__call__]]

```python
__call__(text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, add_special_tokens: bool = True, padding: bool | str | PaddingStrategy = False, truncation: bool | str | TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, is_split_into_words: bool = False, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, tokenizer_kwargs: dict[str, Any] | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L2448)

**Paramètres :**

text (`str`, `list[str]`, `list[list[str]]`, *facultatif*) : La séquence ou le lot de séquences à encoder. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes de caractères (chaînes pré-tokenisées). Si les séquences sont fournies sous forme de liste de chaînes de caractères (pré-tokenisées), vous devez définir `is_split_into_words=True` (pour lever l'ambiguïté avec un lot de séquences).

text_pair (`str`, `list[str]`, `list[list[str]]`, *facultatif*) : La séquence ou le lot de séquences à encoder. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes de caractères (chaînes pré-tokenisées). Si les séquences sont fournies sous forme de liste de chaînes de caractères (pré-tokenisées), vous devez définir `is_split_into_words=True` (pour lever l'ambiguïté avec un lot de séquences).

text_target (`str`, `list[str]`, `list[list[str]]`, *facultatif*) : La séquence ou le lot de séquences à encoder en tant que textes cibles. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes de caractères (chaîne pré-tokenisée). Si les séquences sont fournies sous forme de liste de chaînes de caractères (pré-tokenisées), vous devez définir `is_split_into_words=True` (pour lever l’ambiguïté avec un lot de séquences).

text_pair_target (`str`, `list[str]`, `list[list[str]]`, *facultatif*) : La séquence ou le lot de séquences à encoder en tant que textes cibles. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes de caractères (chaîne pré-tokenisée). Si les séquences sont fournies sous forme de liste de chaînes de caractères (pré-tokenisées), vous devez définir `is_split_into_words=True` (pour lever l’ambiguïté avec un lot de séquences).

tokenizer_kwargs (`dict[str, Any]`, *facultatif*) : kwargs supplémentaires à passer au tokenizer. Ils seront fusionnés avec les paramètres explicites et les autres kwargs, les paramètres explicites ayant la priorité.

add_special_tokens (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ajouter des jetons spéciaux lors de l'encodage des séquences. Cette opération utilise la fonction sous-jacente `PretrainedTokenizerBase.build_inputs_with_special_tokens`, qui définit les jetons ajoutés automatiquement aux identifiants d'entrée. Cela est utile si vous souhaitez ajouter automatiquement des jetons `bos` ou `eos`.

padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/v5.23.0/fr/internal/file_utils#transformers.utils.PaddingStrategy), *facultatif*, par défaut `False`) : Active et contrôle le bourrage. Accepte les valeurs suivantes :  - `True` ou `'longest'` : Bourrage jusqu'à la séquence la plus longue du lot (ou aucun bourrage si une seule séquence est fournie). - `'max_length'` : Bourrage jusqu'à une longueur maximale spécifiée avec l'argument `max_length` ou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. - `False` ou `'do_not_pad'` (par défaut) : Aucun bourrage (c'est-à-dire, peut produire un lot avec des séquences de longueurs différentes).

truncation (`bool`, `str` ou [TruncationStrategy](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *facultatif*, par défaut `False`) : Active et contrôle la troncature. Accepte les valeurs suivantes :  - `True` ou `'longest_first'` : Tronque à une longueur maximale spécifiée par l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela tronque jeton par jeton, en supprimant un jeton de la séquence la plus longue de la paire si une paire de séquences (ou un lot de paires) est fournie. - `'only_first'` : Tronque à une longueur maximale spécifiée par l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronque que la première séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie. - `'only_second'` : Tronque à une longueur maximale spécifiée par l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronque que la deuxième séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie. - `False` ou `'do_not_truncate'` (par défaut) : Aucune troncature (c'est-à-dire, peut produire un lot avec des longueurs de séquences supérieures à la taille d'entrée maximale admissible du modèle).

max_length (`int`, *facultatif*) : Permet de contrôler la longueur maximale à utiliser par l'un des paramètres de troncature/remplissage. S'il n'est pas défini ou s'il est défini sur `None`, la longueur maximale prédéfinie du modèle sera utilisée si l'un des paramètres de troncature/remplissage exige une longueur maximale. Si le modèle n'a pas de longueur d'entrée maximale spécifique (comme XLNet), la troncature/remplissage à une longueur maximale sera désactivée.

stride (`int`, *facultatif*, valeur par défaut 0) : Si défini avec une valeur numérique en plus de `max_length`, les jetons en dépassement renvoyés lorsque `return_overflowing_tokens=True` contiendront certains jetons de la fin de la séquence tronquée renvoyée, afin d'assurer un chevauchement entre les séquences tronquées et celles en dépassement. La valeur de cet argument définit le nombre de jetons en chevauchement.

is_split_into_words (`bool`, *facultatif*, valeur par défaut `False`) : Indique si l'entrée est déjà pré-tokenisée (par exemple, découpée en mots). Si défini sur `True`, le tokenizer suppose que l'entrée est déjà découpée en mots (par exemple, en la séparant sur les espaces) et procède à sa tokenisation. Cela est utile pour la NER ou la classification de tokens.

pad_to_multiple_of (`int`, *facultatif*) : Si défini, la séquence sera rembourdie jusqu'à un multiple de la valeur fournie. Nécessite l'activation de `padding`. Cela est particulièrement utile pour permettre l'utilisation des Tensor Cores sur le matériel NVIDIA avec une capacité de calcul `>= 7.5` (Volta).

padding_side (`str`, *facultatif*) : Le côté sur lequel le modèle doit appliquer le bourrage. Doit être sélectionné parmi ['right', 'left']. La valeur par défaut est choisie à partir de l'attribut de classe du même nom.

return_tensors (`str` ou [TensorType](/docs/transformers/v5.23.0/fr/internal/file_utils#transformers.TensorType), *facultatif*) : Si défini, renverra des tenseurs au lieu d'une liste d'entiers Python. Les valeurs acceptables sont :  - `'pt'` : Renvoie des objets `torch.Tensor` de PyTorch. - `'np'` : Renvoie des objets `np.ndarray` de Numpy.

return_token_type_ids (`bool`, *facultatif*) : Indique s'il faut renvoyer les identifiants de type de jeton. Si la valeur par défaut est conservée, les identifiants de type de jeton seront renvoyés selon la valeur par défaut du tokeniseur spécifique, définie par l'attribut `return_outputs`.  [Qu'est-ce que les identifiants de type de jeton ?](../glossary#token-type-ids)

return_attention_mask (`bool`, *facultatif*) : Indique s'il faut retourner le masque d'attention. Si la valeur par défaut est conservée, le masque d'attention est retourné selon la valeur par défaut du tokenizer spécifique, définie par l'attribut `return_outputs`.  [Qu'est-ce que les masques d'attention ?](../glossary#attention-mask)

return_overflowing_tokens (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non renvoyer les séquences de jetons en dépassement. Si une paire de séquences d'identifiants d'entrée (ou un lot de paires) est fournie avec `truncation_strategy = longest_first` ou `True`, une erreur est levée au lieu de renvoyer les jetons en dépassement.

return_special_tokens_mask (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non retourner les informations du masque des jetons spéciaux.

return_offsets_mapping (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non retourner `(char_start, char_end)` pour chaque jeton. Cette option n'est disponible que pour les tokenizers rapides héritant de [PreTrainedTokenizerFast](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.TokenizersBackend) ; si vous utilisez le tokenizer Python, cette méthode lèvera `NotImplementedError`.

return_length  (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut retourner les longueurs des entrées encodées.

verbose (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut afficher plus d'informations et d'avertissements.

- ****kwargs** : transmis à la méthode `self.tokenize()`

**Retourne :** [BatchEncoding](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.BatchEncoding)

Un [BatchEncoding](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.BatchEncoding) avec les champs suivants :

- **input_ids** -- Liste des identifiants de jetons à fournir au modèle.

  [Qu'est-ce que les identifiants d'entrée ?](../glossary#input-ids)

- **token_type_ids** -- Liste des identifiants de type de jeton à fournir au modèle (lorsque `return_token_type_ids=True` ou si *"token_type_ids"* est présent dans `self.model_input_names`).

  [Qu'est-ce que les identifiants de type de jeton ?](../glossary#token-type-ids)

- **attention_mask** -- Liste d'indices spécifiant les jetons auxquels le modèle doit prêter attention (lorsque `return_attention_mask=True` ou si *"attention_mask"* est présent dans `self.model_input_names`).

  [Qu'est-ce que les masques d'attention ?](../glossary#attention-mask)

- **overflowing_tokens** -- Liste des séquences de jetons en dépassement (lorsqu'une `max_length` est spécifiée et `return_overflowing_tokens=True`).
- **num_truncated_tokens** -- Nombre de jetons tronqués (lorsqu'une `max_length` est spécifiée et `return_overflowing_tokens=True`).
- **special_tokens_mask** -- Liste de 0 et de 1, où 1 indique les jetons spéciaux ajoutés et 0 indique les jetons de séquence réguliers (lorsque `add_special_tokens=True` et `return_special_tokens_mask=True`).
- **length** -- La longueur des entrées (lorsque `return_length=True`)

Méthode principale pour tokeniser et préparer pour le modèle une ou plusieurs séquences ou une ou plusieurs paires de séquences.

#### save_vocabulary[[transformers.VitsTokenizer.save_vocabulary]]

```python
save_vocabulary(save_directory: str, filename_prefix: str | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vits/tokenization_vits.py#L232)

## VitsModel[[transformers.VitsModel]]

#### transformers.VitsModel[[transformers.VitsModel]]

```python
transformers.VitsModel(config: VitsConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vits/modeling_vits.py#L1228)

**Paramètres :**

config ([VitsConfig](/docs/transformers/v5.23.0/fr/model_doc/vits#transformers.VitsConfig)) : 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/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle VITS complet, pour la synthèse vocale à partir de texte.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/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.VitsModel.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, speaker_id: int | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, labels: typing.Optional[torch.Tensor] = None, speaking_rate: float | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/vits/modeling_vits.py#L1255)

**Paramètres :**

input_ids (`torch.Tensor` 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/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

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)

speaker_id (`int`, *facultatif*) : Lequel des embeddings de locuteur à utiliser. Utilisé uniquement pour les modèles multi-locuteurs.

output_attentions (`bool`, *facultatif*) : Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Voir `attentions` sous les tenseurs retournés pour plus de détails.

output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans les tenseurs retournés pour plus de détails.

return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple.

labels (`torch.Tensor` de forme `(batch_size, config.spectrogram_bins, sequence_length)`, *facultatif*) : Valeurs flottantes du spectrogramme cible. Les pas de temps définis à `-100.0` sont ignorés (masqués) pour le calcul de la perte.

speaking_rate (`float`, *facultatif*) : Vitesse de parole.

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

Un `VitsModelOutput` 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 ([VitsConfig](/docs/transformers/v5.23.0/fr/model_doc/vits#transformers.VitsConfig)) et les entrées.

La méthode forward du modèle [VitsModel](/docs/transformers/v5.23.0/fr/model_doc/vits#transformers.VitsModel) 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.

- **waveform** (`torch.Tensor` de forme `(batch_size, sequence_length)`) -- La forme d'onde audio finale prédite par le modèle.
- **sequence_lengths** (`torch.Tensor` de forme `(batch_size,)`) -- La longueur en échantillons de chaque élément du lot `waveform`.
- **spectrogram** (`torch.Tensor` de forme `(batch_size, sequence_length, num_bins)`) -- Le spectrogramme log-mel prédit à la sortie du modèle de flux. Ce spectrogramme est transmis au modèle de décodeur Hi-Fi GAN pour obtenir la forme d'onde audio finale.
- **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.

Exemple :

```python
>>> from transformers import VitsTokenizer, VitsModel, set_seed
>>> import torch

>>> tokenizer = VitsTokenizer.from_pretrained("facebook/mms-tts-eng")
>>> model = VitsModel.from_pretrained("facebook/mms-tts-eng")

>>> inputs = tokenizer(text="Hello - my dog is cute", return_tensors="pt")

>>> set_seed(555)  # make deterministic

>>> with torch.no_grad():
...     outputs = model(inputs["input_ids"])
>>> outputs.waveform.shape
torch.Size([1, 45824])
```

