# SeamlessM4T-v2

## Aperçu

Le modèle SeamlessM4T-v2 a été proposé dans [Seamless: Multilingual Expressive and Streaming Speech Translation](https://huggingface.co/papers/2312.05187) par l'équipe Seamless Communication de Meta AI.

SeamlessM4T-v2 est une collection de modèles conçus pour offrir une traduction de haute qualité, permettant aux personnes issues de différentes communautés linguistiques de communiquer sans effort par la voix et par le texte. Il s'agit d'une amélioration par rapport à la [version précédente](./seamless_m4t). Pour plus de détails sur les différences entre v1 et v2, reportez-vous à la section [Différence avec SeamlessM4T-v1](#difference-with-seamlessm4t-v1).

SeamlessM4T-v2 permet de réaliser plusieurs tâches sans recourir à des modèles distincts :

- Traduction de la parole à la parole (S2ST)
- Traduction de la parole en texte (S2TT)
- Traduction de texte en parole (T2ST)
- Traduction texte vers texte (T2TT)
- Reconnaissance automatique de la parole (ASR)

[SeamlessM4Tv2Model](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2Model) peut effectuer toutes les tâches ci-dessus, mais chaque tâche dispose également de son propre sous-modèle dédié.

L'abstract de l'article est le suivant :

*Les récentes avancées en matière de traduction automatique de la parole ont considérablement élargi la couverture linguistique, amélioré les capacités multimodales et permis une large gamme de tâches et de fonctionnalités. Cela dit, les systèmes de traduction automatique de la parole à grande échelle actuels manquent de fonctionnalités clés qui permettent à la communication médiatisée par la machine de paraître fluide par rapport au dialogue humain. Dans ce travail, nous présentons une famille de modèles qui permettent des traductions expressives et multilingues de bout en bout en mode streaming. Tout d'abord, nous proposons une version améliorée du modèle massivement multilingue et multimodal SeamlessM4T, à savoir SeamlessM4T v2. Ce nouveau modèle, intégrant le cadre mis à jour UnitY2, a été entraîné sur davantage de données pour des langues à faibles ressources. La version étendue de SeamlessAlign ajoute 114 800 heures de données alignées automatiquement, pour un total de 76 langues. SeamlessM4T v2 constitue la base sur laquelle reposent nos deux modèles les plus récents, SeamlessExpressive et SeamlessStreaming. SeamlessExpressive permet une traduction qui préserve les styles vocaux et la prosodie. Par rapport aux travaux antérieurs sur la parole expressive, notre travail aborde certains aspects sous-explorés de la prosodie, tels que le débit de parole et les pauses, tout en préservant le style de la voix. Quant à SeamlessStreaming, notre modèle exploite le mécanisme Efficient Monotonic Multihead Attention (EMMA) pour générer des traductions cibles à faible latence sans attendre la fin des énoncés sources. En tant que premier du genre, SeamlessStreaming permet la traduction simultanée de la parole vers la parole/texte pour plusieurs langues sources et cibles. Pour évaluer les performances de ces modèles, nous avons combiné des métriques automatiques nouvelles et des versions modifiées de métriques existantes afin d'évaluer la prosodie, la latence et la robustesse. Pour les évaluations humaines, nous avons adapté des protocoles existants conçus pour mesurer les attributs les plus pertinents en matière de préservation du sens, de naturalité et d'expressivité. Pour garantir que nos modèles puissent être utilisés de manière sûre et responsable, nous avons mis en œuvre le premier effort de red-teaming connu pour la traduction machine multimodale, un système de détection et d'atténuation de la toxicité ajoutée, une évaluation systématique du biais de genre et un mécanisme de filigrane localisé inaudible conçu pour atténuer l'impact des deepfakes. En conséquence, nous réunissons les principaux composants de SeamlessExpressive et de SeamlessStreaming pour former Seamless, le premier système disponible publiquement qui permet une communication interlinguistique expressive en temps réel. En somme, Seamless nous offre un aperçu essentiel des fondations techniques nécessaires pour transformer le Traducteur Universel de la Parole d'un concept de science-fiction en une technologie réelle. Enfin, les contributions de ce travail, y compris les modèles, le code et un détecteur de filigrane, sont publiés publiquement et accessibles via le lien ci-dessous.*

## Utilisation

Dans l'exemple suivant, nous chargeons un échantillon audio en arabe et un échantillon de texte en anglais, puis nous les convertissons en parole russe et en texte français.

Tout d'abord, chargez le processeur et un point de contrôle du modèle :

```python
from transformers import AutoProcessor, SeamlessM4Tv2Model

processor = AutoProcessor.from_pretrained("facebook/seamless-m4t-v2-large")
model = SeamlessM4Tv2Model.from_pretrained("facebook/seamless-m4t-v2-large", device_map="auto")
```

Vous pouvez utiliser ce modèle de manière transparente sur du texte ou sur de l’audio, afin de générer du texte traduit ou de l’audio traduit.

Voici comment utiliser le processeur pour traiter le texte et l'audio :

```python
# let's load an audio sample from an Arabic speech corpus
from datasets import load_dataset

dataset = load_dataset("halabi2016/arabic_speech_corpus", split="test", streaming=True)
audio_sample = next(iter(dataset))["audio"]

# now, process it
audio_inputs = processor(audio=audio_sample["array"], return_tensors="pt").to(model.device)

# now, process some English text as well
text_inputs = processor(text = "Hello, my dog is cute", src_lang="eng", return_tensors="pt").to(model.device)
```

### Traitement de la parole

[SeamlessM4Tv2Model](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2Model) peut générer du texte ou de la parole *de manière transparente* avec peu ou pas de modifications. Ciblons la traduction vocale en russe :

```python
audio_array_from_text = model.generate(**text_inputs, tgt_lang="rus")[0].cpu().numpy().squeeze()
audio_array_from_audio = model.generate(**audio_inputs, tgt_lang="rus")[0].cpu().numpy().squeeze()
```

Avec essentiellement le même code, j'ai traduit du texte anglais et de la parole arabe en échantillons de parole russe.

### Texte

De même, vous pouvez générer du texte traduit à partir de fichiers audio ou de texte avec le même modèle. Il vous suffit de passer `generate_speech=False` à [SeamlessM4Tv2Model.generate()](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2Model.generate). Cette fois, traduisons en français.

```python
# from audio
output_tokens = model.generate(**audio_inputs, tgt_lang="fra", generate_speech=False)
translated_text_from_audio = processor.decode(output_tokens[0].tolist()[0], skip_special_tokens=True)

# from text
output_tokens = model.generate(**text_inputs, tgt_lang="fra", generate_speech=False)
translated_text_from_text = processor.decode(output_tokens[0].tolist()[0], skip_special_tokens=True)
```

### Astuces

#### 1. Utiliser des modèles dédiés

[SeamlessM4Tv2Model](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2Model) est le modèle de niveau supérieur de Transformers pour générer de la parole et du texte, mais vous pouvez également utiliser des modèles dédiés qui exécutent la tâche sans composants supplémentaires, réduisant ainsi l'empreinte mémoire. Par exemple, vous pouvez remplacer le extrait de code de génération audio-vers-audio par le modèle dédié à la tâche S2ST, le reste du code est exactement le même :

```python
from transformers import SeamlessM4Tv2ForSpeechToSpeech

model = SeamlessM4Tv2ForSpeechToSpeech.from_pretrained("facebook/seamless-m4t-v2-large", device_map="auto")
```

Vous pouvez également remplacer l'extrait de génération texte-vers-texte par le modèle dédié à la tâche T2TT, il vous suffit de supprimer `generate_speech=False`.

```python
from transformers import SeamlessM4Tv2ForTextToText

model = SeamlessM4Tv2ForTextToText.from_pretrained("facebook/seamless-m4t-v2-large", device_map="auto")
```

N'hésitez pas à essayer également [SeamlessM4Tv2ForSpeechToText](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2ForSpeechToText) et [SeamlessM4Tv2ForTextToSpeech](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2ForTextToSpeech).

#### 2. Modifier l'identité du locuteur

Vous avez la possibilité de changer l’orateur utilisé pour la synthèse vocale à l’aide de l’argument `speaker_id`. Certains `speaker_id` fonctionnent mieux que d’autres pour certaines langues !

#### 3. Modifier la stratégie de génération

Vous pouvez utiliser différentes [stratégies de génération](../generation_strategies) pour la génération de texte, par exemple `.generate(input_ids=input_ids, text_num_beams=4, text_do_sample=True)`, qui effectuera un décodage par beam-search multinomial sur le modèle de texte. Notez que la génération de parole ne prend en charge que le décodage glouton - par défaut - ou l'échantillonnage multinomial, qui peut être utilisé avec, par exemple, `.generate(..., speech_do_sample=True, speech_temperature=0.6)`.

#### 4. Générer la voix et le texte en même temps

Utilisez `return_intermediate_token_ids=True` avec [SeamlessM4Tv2Model](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2Model) pour retourner à la fois la parole et le texte !

## Architecture du modèle

SeamlessM4T-v2 dispose d'une architecture polyvalente qui gère de manière fluide la génération séquentielle de texte et de parole. Cette configuration comprend deux modèles séquence-à-séquence (seq2seq). Le premier modèle traduit la modalité d'entrée en texte traduit, tandis que le second modèle génère des jetons de parole, appelés « unit tokens », à partir du texte traduit.

Chaque modalité dispose de son propre encodeur doté d'une architecture unique. De plus, pour la sortie vocale, un vocoder inspiré de l'architecture [HiFi-GAN](https://huggingface.co/papers/2010.05646) est placé au-dessus du second modèle seq2seq.

### Différence avec SeamlessM4T-v1

L'architecture de cette nouvelle version diffère de la première à quelques égards :

#### Améliorations du modèle de deuxième passe

Le second modèle seq2seq, nommé modèle text-to-unit, est désormais non auto-régressif, ce qui signifie qu'il calcule les unités en un **seul passage avant**. Cet accomplissement est rendu possible par :

- l'utilisation de **embeddings au niveau des caractères**, c'est-à-dire que chaque caractère du texte traduit prédit possède ses propres embeddings, qui sont ensuite utilisés pour prédire les jetons unitaires.
- l'utilisation d'un prédicteur de durée intermédiaire, qui prédit la durée de la parole au niveau **caractère** sur le texte traduit prédit.
- l'utilisation d'un nouveau décodeur texte-vers-unité combinant convolutions et auto-attention pour traiter des contextes plus longs.

#### Différence dans l'encodeur de la parole

L'encodeur audio, utilisé lors du processus de génération de la première passe pour prédire le texte traduit, diffère principalement de l'encodeur audio précédent par ces mécanismes :

- l'utilisation d'un masque d'attention par blocs pour empêcher l'attention entre les blocs, garantissant ainsi que chaque position ne porte attention qu'aux positions de son propre bloc et d'un nombre fixe de blocs précédents.
- l’utilisation d’embeddings de position relative qui ne prend en compte que la distance entre les éléments de la séquence plutôt que les positions absolues. Veuillez consulter [Self-Attention with Relative Position Representations (Shaw et al.)](https://huggingface.co/papers/1803.02155) pour plus de détails.
- l'utilisation d'une convolution causale en profondeur plutôt que d'une convolution non causale.

### Processus de génération

Voici comment fonctionne le processus de génération :

- Le texte ou la parole en entrée est traité par son encodeur spécifique.
- Un décodeur génère des jetons de texte dans la langue souhaitée.
- Si la génération de parole est requise, le second modèle seq2seq génère des jetons d’unité de manière non auto-régressive.
- Ces jetons unitaires sont ensuite transmis au vocoder final pour produire la parole réelle.

Ce modèle a été contribué par [ylacombe](https://huggingface.co/ylacombe). Le code d’origine est disponible [ici](https://github.com/facebookresearch/seamless_communication).

## SeamlessM4Tv2Model[[transformers.SeamlessM4Tv2Model]]

#### transformers.SeamlessM4Tv2Model[[transformers.SeamlessM4Tv2Model]]

```python
transformers.SeamlessM4Tv2Model(config: SeamlessM4Tv2Config, current_modality = 'text')
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t_v2/modeling_seamless_m4t_v2.py#L3665)

**Paramètres :**

config ([SeamlessM4Tv2Config](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2Config)) : 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.

current_modality (`str`, *facultatif*, valeur par défaut `"text"`) : Modalité par défaut. Utilisée pour initialiser le modèle.

Le modèle transformer original de SeamlessM4Tv2, utilisable pour toutes les tâches disponibles (S2ST, S2TT, T2TT, T2ST).

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.

#### generate[[transformers.SeamlessM4Tv2Model.generate]]

```python
generate(input_ids: typing.Optional[torch.Tensor] = None, input_features: typing.Optional[torch.Tensor] = None, return_intermediate_token_ids: bool | None = None, tgt_lang: str | None = None, speaker_id: int | None = 0, generate_speech: bool | None = True, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t_v2/modeling_seamless_m4t_v2.py#L3859)

**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. Les indices peuvent être obtenus à l'aide de [SeamlessM4TTokenizer](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TTokenizer) ou de [SeamlessM4TProcessor](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TProcessor). 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)

input_features (`torch.Tensor` de forme `(batch_size, sequence_length, num_banks)`, *facultatif*) : Caractéristiques audio en entrée. Elles doivent être renvoyées par la classe [SeamlessM4TFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TFeatureExtractor) ou la classe [SeamlessM4TProcessor](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TProcessor). Voir [SeamlessM4TFeatureExtractor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TFeatureExtractor.__call__) pour plus de détails.

return_intermediate_token_ids (`bool`, *facultatif*) : Si `True`, renvoie également le texte généré intermédiaire et les jetons d'unité. Définissez-le sur `True` si vous souhaitez également obtenir le texte traduit en plus de l'audio. Notez que si `generate_speech=False`, ce paramètre est ignoré et les jetons de texte sont renvoyés.

tgt_lang (`str`, *facultatif*) : La langue à utiliser comme langue cible pour la traduction.

speaker_id (`int`, *facultatif*, valeur par défaut 0) : L'identifiant du locuteur utilisé pour la synthèse vocale. Doit être inférieur à `config.vocoder_num_spkrs`.

generate_speech (`bool`, *facultatif*, par défaut `True`) : Si `False`, ne renvoie que les jetons de texte et ne génère pas de parole.

kwargs (*facultatif*) : Dictionnaire restant d'arguments par mot-clé qui sera transmis à [GenerationMixin.generate()](/docs/transformers/v5.23.0/fr/main_classes/text_generation#transformers.GenerationMixin.generate). Les arguments par mot-clé sont de deux types :  - Sans préfixe, ils seront saisis en tant que `**kwargs` pour la méthode `generate` de chaque sous-modèle, à l'exception de `decoder_input_ids` qui ne sera transmis que par les composants texte. - Avec un préfixe *text_* ou *speech_*, ils seront saisis pour la méthode `generate` du modèle texte et du modèle vocal respectivement. Ils ont la priorité sur les mots-clés sans préfixe.  Cela signifie que vous pouvez, par exemple, spécifier une stratégie de génération pour une génération mais pas pour l'autre.

**Retourne :** `Union[SeamlessM4Tv2GenerationOutput, tuple[Tensor], ModelOutput]`

- Si `generate_speech` et `return_intermediate_token_ids`, renvoie `SeamlessM4Tv2GenerationOutput`.
- Si `generate_speech` et non `return_intermediate_token_ids`, renvoie un tuple composé des formes d'onde de forme `(batch_size, sequence_length)` et de `waveform_lengths`, qui indique la longueur de chaque échantillon.
- Si `generate_speech=False`, la méthode renvoie un `ModelOutput`.

Génère des identifiants de jetons traduits et/ou des formes d’onde audio traduites.

Cette méthode appelle successivement la fonction `.generate` de deux sous-modèles différents. Vous pouvez spécifier des arguments par mot-clé à deux niveaux distincts : des arguments généraux qui seront transmis aux deux modèles, ou des arguments préfixés qui seront transmis à l’un d’entre eux.

Par exemple, l’appel de `.generate(input_ids=input_ids, num_beams=4, speech_do_sample=True)` effectuera successivement un décodage par beam-search sur le modèle de texte, puis un échantillonnage multinomial par beam-search sur le modèle de parole.

Pour un aperçu des stratégies de génération et des exemples de code, consultez le [guide suivant](./generation_strategies).

## SeamlessM4Tv2ForTextToSpeech[[transformers.SeamlessM4Tv2ForTextToSpeech]]

#### transformers.SeamlessM4Tv2ForTextToSpeech[[transformers.SeamlessM4Tv2ForTextToSpeech]]

```python
transformers.SeamlessM4Tv2ForTextToSpeech(config: SeamlessM4Tv2Config)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t_v2/modeling_seamless_m4t_v2.py#L2984)

**Paramètres :**

config ([SeamlessM4Tv2Config](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2Config)) : 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 transformer text-to-speech SeamlessM4Tv2, utilisable pour le T2ST.

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.

#### generate[[transformers.SeamlessM4Tv2ForTextToSpeech.generate]]

```python
generate(input_ids: typing.Optional[torch.Tensor] = None, return_intermediate_token_ids: bool | None = None, tgt_lang: str | None = None, speaker_id: int | None = 0, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t_v2/modeling_seamless_m4t_v2.py#L3118)

**Paramètres :**

input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Les indices peuvent être obtenus à l'aide de [SeamlessM4TTokenizer](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TTokenizer) ou de [SeamlessM4TProcessor](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TProcessor). 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)

return_intermediate_token_ids (`bool`, *facultatif*) : Si `True`, renvoie également le texte généré intermédiaire et les jetons d'unité. Définissez sur `True` si vous souhaitez également obtenir le texte traduit en plus de l'audio.

tgt_lang (`str`, *facultatif*) : La langue à utiliser comme langue cible pour la traduction.

speaker_id (`int`, *facultatif*, valeur par défaut 0) : L'identifiant du locuteur utilisé pour la synthèse vocale. Doit être inférieur à `config.vocoder_num_spkrs`.

kwargs (*facultatif*) : Dictionnaire restant d'arguments par mot-clé qui sera transmis à [GenerationMixin.generate()](/docs/transformers/v5.23.0/fr/main_classes/text_generation#transformers.GenerationMixin.generate). Les arguments par mot-clé sont de deux types :  - Sans préfixe, ils seront saisis en tant que `**kwargs` pour la méthode `generate` de chaque sous-modèle, à l'exception de `decoder_input_ids` qui ne sera transmis que par les composants texte. - Avec un préfixe *text_* ou *speech_*, ils seront saisis pour la méthode `generate` du modèle texte et du modèle vocal respectivement. Ils ont la priorité sur les mots-clés sans préfixe.  Cela signifie que vous pouvez, par exemple, spécifier une stratégie de génération pour une génération mais pas pour l'autre.

**Retourne :** `Union[SeamlessM4Tv2GenerationOutput, tuple[Tensor]]`

- Si `return_intermediate_token_ids` est défini, renvoie `SeamlessM4Tv2GenerationOutput`.
- Si `return_intermediate_token_ids` n'est pas défini, renvoie un tuple composé des formes d'onde de forme `(batch_size, sequence_length)` et de `waveform_lengths`, qui indique la longueur de chaque échantillon.

Génère des formes d'onde audio traduites.

Cette méthode appelle successivement la fonction `.generate` de deux sous-modèles différents. Vous pouvez spécifier des arguments par mot-clé à deux niveaux distincts : des arguments généraux qui seront transmis aux deux modèles, ou des arguments préfixés qui seront transmis à l’un d’entre eux.

Par exemple, l’appel de `.generate(input_ids, num_beams=4, speech_do_sample=True)` effectuera successivement un décodage par beam-search sur le modèle de texte, puis un échantillonnage multinomial par beam-search sur le modèle de parole.

Pour un aperçu des stratégies de génération et des exemples de code, consultez le [guide suivant](./generation_strategies).

## SeamlessM4Tv2ForSpeechToSpeech[[transformers.SeamlessM4Tv2ForSpeechToSpeech]]

#### transformers.SeamlessM4Tv2ForSpeechToSpeech[[transformers.SeamlessM4Tv2ForSpeechToSpeech]]

```python
transformers.SeamlessM4Tv2ForSpeechToSpeech(config: SeamlessM4Tv2Config)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t_v2/modeling_seamless_m4t_v2.py#L3322)

**Paramètres :**

config ([SeamlessM4Tv2Config](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2Config)) : 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 transformer speech-to-speech SeamlessM4Tv2 qui peut être utilisé pour le S2ST.

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.

#### generate[[transformers.SeamlessM4Tv2ForSpeechToSpeech.generate]]

```python
generate(input_features: typing.Optional[torch.Tensor] = None, return_intermediate_token_ids: bool | None = None, tgt_lang: str | None = None, speaker_id: int | None = 0, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t_v2/modeling_seamless_m4t_v2.py#L3455)

**Paramètres :**

input_features (`torch.Tensor` de forme `(batch_size, sequence_length, num_banks)`) : Caractéristiques audio en entrée. Elles doivent être renvoyées par la classe [SeamlessM4TFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TFeatureExtractor) ou la classe [SeamlessM4TProcessor](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TProcessor). Voir [SeamlessM4TFeatureExtractor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TFeatureExtractor.__call__) pour plus de détails.

return_intermediate_token_ids (`bool`, *facultatif*) : Si `True`, renvoie également le texte généré intermédiaire et les jetons d'unité. Définissez sur `True` si vous souhaitez également obtenir le texte traduit en plus de l'audio.

tgt_lang (`str`, *facultatif*) : La langue à utiliser comme langue cible pour la traduction.

speaker_id (`int`, *facultatif*, valeur par défaut 0) : L'identifiant du locuteur utilisé pour la synthèse vocale. Doit être inférieur à `config.vocoder_num_spkrs`.

kwargs (*facultatif*) : Dictionnaire restant d'arguments par mot-clé qui sera transmis à [GenerationMixin.generate()](/docs/transformers/v5.23.0/fr/main_classes/text_generation#transformers.GenerationMixin.generate). Les arguments par mot-clé sont de deux types :  - Sans préfixe, ils seront saisis en tant que `**kwargs` pour la méthode `generate` de chaque sous-modèle, à l'exception de `decoder_input_ids` qui ne sera transmis que par les composants texte. - Avec un préfixe *text_* ou *speech_*, ils seront saisis pour la méthode `generate` du modèle texte et du modèle vocal respectivement. Ils ont la priorité sur les mots-clés sans préfixe.  Cela signifie que vous pouvez, par exemple, spécifier une stratégie de génération pour une génération mais pas pour l'autre.

**Retourne :** `Union[SeamlessM4Tv2GenerationOutput, tuple[Tensor]]`

- Si `return_intermediate_token_ids` est défini, renvoie `SeamlessM4Tv2GenerationOutput`.
- Si `return_intermediate_token_ids` n'est pas défini, renvoie un tuple composé des formes d'onde de forme `(batch_size, sequence_length)` et de `waveform_lengths`, qui indique la longueur de chaque échantillon.

Génère des formes d'onde audio traduites.

Cette méthode appelle successivement la fonction `.generate` de deux sous-modèles différents. Vous pouvez spécifier des arguments par mot-clé à deux niveaux distincts : des arguments généraux qui seront transmis aux deux modèles, ou des arguments préfixés qui seront transmis à l’un d’entre eux.

Par exemple, l’appel de `.generate(input_features, num_beams=4, speech_do_sample=True)` exécute successivement un décodage par beam-search sur le modèle de texte, puis un échantillonnage multinomial par beam-search sur le modèle de parole.

Pour un aperçu des stratégies de génération et des exemples de code, consultez le [guide suivant](./generation_strategies).

## SeamlessM4Tv2ForTextToText[[transformers.SeamlessM4Tv2ForTextToText]]

#### transformers.SeamlessM4Tv2ForTextToText[[transformers.SeamlessM4Tv2ForTextToText]]

```python
transformers.SeamlessM4Tv2ForTextToText(config: SeamlessM4Tv2Config)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t_v2/modeling_seamless_m4t_v2.py#L2501)

**Paramètres :**

config ([SeamlessM4Tv2Config](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2Config)) : 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 transformer text-to-text SeamlessM4Tv2 qui peut être utilisé pour le T2TT.

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

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t_v2/modeling_seamless_m4t_v2.py#L2537)

**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/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)

decoder_input_ids (`torch.LongTensor` de forme `(batch_size, target_sequence_length)`, *facultatif*) : Indices des jetons de la séquence d’entrée du décodeur dans le vocabulaire. 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 IDs d’entrée du décodeur ?](../glossary#decoder-input-ids) Bart utilise `eos_token_id` comme jeton de départ pour la génération de `decoder_input_ids`. Si `past_key_values` est utilisé, il est facultatif de n’entrer que les derniers `decoder_input_ids` (voir `past_key_values`). Pour l’entraînement à la traduction et à la résumation, `decoder_input_ids` doit être fourni. Si aucun `decoder_input_ids` n’est fourni, le modèle crée ce tenseur en décalant `input_ids` vers la droite pour le pré-entraînement par débruitage, conformément à l’article.

decoder_attention_mask (`torch.LongTensor` de forme `(batch_size, target_sequence_length)`, *facultatif*) : Comportement par défaut : générer un tenseur qui ignore les jetons de remplissage dans `decoder_input_ids`. Un masque causal sera également utilisé par défaut. Si vous souhaitez modifier le comportement de remplissage, vous devez lire `modeling_bart._prepare_decoder_attention_mask` et l'adapter à vos besoins. Consultez le diagramme 1 de [l'article](https://huggingface.co/papers/1910.13461) pour plus d'informations sur la stratégie par défaut.

encoder_outputs (`tuple[tuple[torch.Tensor]]`, *facultatif*) : le tuple est composé de (`last_hidden_state`, *facultatif* : `hidden_states`, *facultatif* : `attentions`) `last_hidden_state` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) est une séquence d'états cachés à la sortie de la dernière couche de l'encodeur. Utilisé dans l'attention croisée du décodeur.

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/v5.23.0/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/v5.23.0/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 façon de convertir les indices de `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle.  labels (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être dans `[-100, 0, ..., config.vocab_size]` (voir la docstring de `input_ids`) Les jetons dont les indices sont définis sur `-100` sont ignorés (masqués), la perte n'est calculée que pour les jetons dont les étiquettes sont dans `[0, ..., config.vocab_size]`

decoder_inputs_embeds (`torch.Tensor` de forme `(batch_size, target_sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `decoder_input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Si `past_key_values` est utilisé, il est facultatif de n'entrer que les derniers `decoder_inputs_embeds` (voir `past_key_values`). Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `decoder_input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle. Si `decoder_input_ids` et `decoder_inputs_embeds` sont tous deux non définis, `decoder_inputs_embeds` prend la valeur de `inputs_embeds`.

labels (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être compris dans `[0, ..., config.vocab_size]` ou égaux à -100 (voir la docstring de `input_ids`). Les jetons dont l'indice est défini sur `-100` sont ignorés (masqués) ; la perte n'est calculée que pour les jetons dont l'étiquette est comprise dans `[0, ..., config.vocab_size]`.

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 :** [Seq2SeqLMOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) ou `tuple(torch.Tensor)`

Un [Seq2SeqLMOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) 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 ([SeamlessM4Tv2Config](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2Config)) et les entrées.

La méthode forward de [SeamlessM4Tv2ForTextToText](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2ForTextToText) 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.

- **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) -- Perte de modélisation du langage.
- **logits** (`torch.Tensor` de forme `(batch_size, sequence_length, config.vocab_size)`) -- Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax).
- **past_key_values** (`EncoderDecoderCache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [EncoderDecoderCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.EncoderDecoderCache). 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 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.
- **decoder_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 décodeur à la sortie de chaque couche, plus les sorties de l'intégration initiale.
- **decoder_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)`.

  Poids d'attention du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- **cross_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)`.

  Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
- **encoder_last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) -- Séquence d'états cachés à la sortie de la dernière couche de l'encodeur du modèle.
- **encoder_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 de l'encodeur à la sortie de chaque couche, plus les sorties des embeddings initiaux.
- **encoder_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)`.

  Poids d'attention de l'encodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

#### generate[[transformers.SeamlessM4Tv2ForTextToText.generate]]

```python
generate(input_ids = None, tgt_lang = None, generation_config = None, logits_processor = None, stopping_criteria = None, prefix_allowed_tokens_fn = None, synced_gpus = False, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t_v2/modeling_seamless_m4t_v2.py#L2619)

**Paramètres :**

input_ids (`torch.Tensor` de forme variable selon la modalité, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Les indices peuvent être obtenus à l'aide de [SeamlessM4TTokenizer](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TTokenizer) ou de [SeamlessM4TProcessor](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TProcessor). 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)

tgt_lang (`str`, *facultatif*) : La langue à utiliser comme langue cible pour la traduction.

generation_config (`~generation.GenerationConfig`, *facultatif*) : La configuration de génération à utiliser comme paramétrage de base pour l'appel de génération. Les `**kwargs` passés à generate qui correspondent aux attributs de `generation_config` les remplaceront. Si `generation_config` n'est pas fourni, la valeur par défaut sera utilisée, avec la priorité de chargement suivante : 1) depuis le fichier modèle `generation_config.json`, s'il existe ; 2) depuis la configuration du modèle. Veuillez noter que les paramètres non spécifiés hériteront des valeurs par défaut de [GenerationConfig](/docs/transformers/v5.23.0/fr/main_classes/text_generation#transformers.GenerationConfig), dont la documentation doit être consultée pour paramétrer la génération.

logits_processor (`LogitsProcessorList`, *facultatif*) : Processeurs de logits personnalisés qui complètent les processeurs de logits par défaut créés à partir des arguments et de la configuration de génération. Si un processeur de logits est transmis qui a déjà été créé avec les arguments ou une configuration de génération, une erreur est levée. Cette fonctionnalité est destinée aux utilisateurs avancés.

stopping_criteria (`StoppingCriteriaList`, *facultatif*) : Critères d'arrêt personnalisés qui complètent les critères d'arrêt par défaut construits à partir des arguments et d'une configuration de génération. Si un critère d'arrêt est transmis qui a déjà été créé à partir des arguments ou d'une configuration de génération, une erreur est levée. Cette fonctionnalité est destinée aux utilisateurs avancés.

prefix_allowed_tokens_fn (`Callable[[int, torch.Tensor], list[int]]`, *facultatif*) : Si fournie, cette fonction contraint la recherche par faisceau aux jetons autorisés uniquement à chaque étape. Si elle n'est pas fournie, aucune contrainte n'est appliquée. Cette fonction prend 2 arguments : l'identifiant du lot `batch_id` et `input_ids`. Elle doit retourner une liste des jetons autorisés pour l'étape de génération suivante, conditionnée par l'identifiant du lot `batch_id` et les jetons précédemment générés `inputs_ids`. Cet argument est utile pour la génération contrainte conditionnée par le préfixe, comme décrit dans [Autoregressive Entity Retrieval](https://huggingface.co/papers/2010.00904).

synced_gpus (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut continuer à exécuter la boucle while jusqu'à max_length (nécessaire pour éviter un blocage avec `FullyShardedDataParallel` et DeepSpeed ZeRO Stage 3).

kwargs (`dict[str, Any]`, *facultatif*) : Paramétrage ad hoc de `generate_config` et/ou kwargs supplémentaires spécifiques au modèle qui seront transmis à la fonction `forward` du modèle.

**Retourne :** [ModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.utils.ModelOutput) ou `torch.LongTensor`

Un [ModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.utils.ModelOutput) (si `return_dict_in_generate=True` ou lorsque `config.return_dict_in_generate=True`) ou un `torch.Tensor`. Les types [ModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.utils.ModelOutput) possibles sont :
- [GenerateEncoderDecoderOutput](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.generation.GenerateEncoderDecoderOutput),
- [GenerateBeamEncoderDecoderOutput](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.generation.GenerateBeamEncoderDecoderOutput)

Génère des séquences d'identifiants de jetons.

La plupart des paramètres de contrôle de la génération sont définis dans `generation_config` qui, s'il n'est pas transmis, sera réglé sur la configuration de génération par défaut du modèle. Vous pouvez remplacer n'importe quel `generation_config` en transmettant les paramètres correspondants à generate(), par exemple `.generate(inputs, num_beams=4, do_sample=True)`.

Pour un aperçu des stratégies de génération et des exemples de code, consultez le [guide suivant](./generation_strategies).

## SeamlessM4Tv2ForSpeechToText[[transformers.SeamlessM4Tv2ForSpeechToText]]

#### transformers.SeamlessM4Tv2ForSpeechToText[[transformers.SeamlessM4Tv2ForSpeechToText]]

```python
transformers.SeamlessM4Tv2ForSpeechToText(config: SeamlessM4Tv2Config)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t_v2/modeling_seamless_m4t_v2.py#L2736)

**Paramètres :**

config ([SeamlessM4Tv2Config](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2Config)) : 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 transformer de transcription vocale en texte SeamlessM4Tv2 peut être utilisé pour la traduction vocale en texte (S2TT).

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

```python
forward(input_features: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: tuple[tuple[torch.Tensor]] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t_v2/modeling_seamless_m4t_v2.py#L2774)

**Paramètres :**

input_features (`torch.Tensor` de forme `(batch_size, sequence_length, num_banks)`) : Caractéristiques audio en entrée. Elles doivent être renvoyées par la classe [SeamlessM4TFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TFeatureExtractor) ou la classe [SeamlessM4TProcessor](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TProcessor). Voir [SeamlessM4TFeatureExtractor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TFeatureExtractor.__call__) pour plus de détails.

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)

decoder_input_ids (`torch.LongTensor` de forme `(batch_size, target_sequence_length)`, *facultatif*) : Indices des jetons de la séquence d’entrée du décodeur dans le vocabulaire. 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 IDs d’entrée du décodeur ?](../glossary#decoder-input-ids) Bart utilise `eos_token_id` comme jeton de départ pour la génération de `decoder_input_ids`. Si `past_key_values` est utilisé, il est facultatif de n’entrer que les derniers `decoder_input_ids` (voir `past_key_values`). Pour l’entraînement à la traduction et à la résumation, `decoder_input_ids` doit être fourni. Si aucun `decoder_input_ids` n’est fourni, le modèle crée ce tenseur en décalant `input_ids` vers la droite pour le pré-entraînement par débruitage, conformément à l’article.

decoder_attention_mask (`torch.LongTensor` de forme `(batch_size, target_sequence_length)`, *facultatif*) : Comportement par défaut : générer un tenseur qui ignore les jetons de remplissage dans `decoder_input_ids`. Un masque causal sera également utilisé par défaut. Si vous souhaitez modifier le comportement de remplissage, vous devez lire `modeling_bart._prepare_decoder_attention_mask` et l'adapter à vos besoins. Consultez le diagramme 1 de [l'article](https://huggingface.co/papers/1910.13461) pour plus d'informations sur la stratégie par défaut.

encoder_outputs (`tuple[tuple[torch.Tensor]]`, *facultatif*) : le tuple est composé de (`last_hidden_state`, *facultatif* : `hidden_states`, *facultatif* : `attentions`) `last_hidden_state` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) est une séquence d'états cachés à la sortie de la dernière couche de l'encodeur. Utilisé dans l'attention croisée du décodeur.

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/v5.23.0/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/v5.23.0/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 façon de convertir les indices de `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle.  labels (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être dans `[-100, 0, ..., config.vocab_size]` (voir la docstring de `input_ids`) Les jetons dont les indices sont définis sur `-100` sont ignorés (masqués), la perte n'est calculée que pour les jetons dont les étiquettes sont dans `[0, ..., config.vocab_size]`

decoder_inputs_embeds (`torch.Tensor` de forme `(batch_size, target_sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `decoder_input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Si `past_key_values` est utilisé, il est facultatif de n'entrer que les derniers `decoder_inputs_embeds` (voir `past_key_values`). Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `decoder_input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle. Si `decoder_input_ids` et `decoder_inputs_embeds` sont tous deux non définis, `decoder_inputs_embeds` prend la valeur de `inputs_embeds`.

labels (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être compris dans `[0, ..., config.vocab_size]` ou égaux à -100 (voir la docstring de `input_ids`). Les jetons dont l'indice est défini sur `-100` sont ignorés (masqués) ; la perte n'est calculée que pour les jetons dont l'étiquette est comprise dans `[0, ..., config.vocab_size]`.

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 :** [Seq2SeqLMOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) ou `tuple(torch.Tensor)`

Un [Seq2SeqLMOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) 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 ([SeamlessM4Tv2Config](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2Config)) et les entrées.

La méthode forward de [SeamlessM4Tv2ForSpeechToText](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2ForSpeechToText) 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.

- **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) -- Perte de modélisation du langage.
- **logits** (`torch.Tensor` de forme `(batch_size, sequence_length, config.vocab_size)`) -- Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax).
- **past_key_values** (`EncoderDecoderCache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [EncoderDecoderCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.EncoderDecoderCache). 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 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.
- **decoder_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 décodeur à la sortie de chaque couche, plus les sorties de l'intégration initiale.
- **decoder_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)`.

  Poids d'attention du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- **cross_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)`.

  Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
- **encoder_last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) -- Séquence d'états cachés à la sortie de la dernière couche de l'encodeur du modèle.
- **encoder_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 de l'encodeur à la sortie de chaque couche, plus les sorties des embeddings initiaux.
- **encoder_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)`.

  Poids d'attention de l'encodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemple :

```python
>>> from transformers import AutoProcessor, SeamlessM4Tv2ForSpeechToText
>>> from datasets import load_dataset
>>> import torch

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate

>>> processor = AutoProcessor.from_pretrained("facebook/hf-seamless-m4t-medium")
>>> model = SeamlessM4Tv2ForSpeechToText.from_pretrained("facebook/hf-seamless-m4t-medium")

>>> # audio file is decoded on the fly
>>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> with torch.no_grad():
...     logits = model(**inputs).logits
>>> predicted_ids = torch.argmax(logits, dim=-1)

>>> # transcribe speech
>>> transcription = processor.batch_decode(predicted_ids)
>>> transcription[0]
...

>>> inputs["labels"] = processor(text=dataset[0]["text"], return_tensors="pt").input_ids

>>> # compute loss
>>> loss = model(**inputs).loss
>>> round(loss.item(), 2)
...
```

#### generate[[transformers.SeamlessM4Tv2ForSpeechToText.generate]]

```python
generate(input_features = None, tgt_lang = None, generation_config = None, logits_processor = None, stopping_criteria = None, prefix_allowed_tokens_fn = None, synced_gpus = False, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t_v2/modeling_seamless_m4t_v2.py#L2865)

**Paramètres :**

input_features (`torch.Tensor` de forme `(batch_size, sequence_length, num_banks)`) : Caractéristiques audio en entrée. Elles doivent être renvoyées par la classe [SeamlessM4TFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TFeatureExtractor) ou la classe [SeamlessM4TProcessor](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TProcessor). Voir [SeamlessM4TFeatureExtractor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TFeatureExtractor.__call__) pour plus de détails.

tgt_lang (`str`, *facultatif*) : La langue à utiliser comme langue cible pour la traduction.

generation_config (`~generation.GenerationConfig`, *facultatif*) : La configuration de génération à utiliser comme paramétrage de base pour l'appel de génération. Les `**kwargs` passés à generate qui correspondent aux attributs de `generation_config` les remplaceront. Si `generation_config` n'est pas fourni, la valeur par défaut sera utilisée, avec la priorité de chargement suivante : 1) depuis le fichier modèle `generation_config.json`, s'il existe ; 2) depuis la configuration du modèle. Veuillez noter que les paramètres non spécifiés hériteront des valeurs par défaut de [GenerationConfig](/docs/transformers/v5.23.0/fr/main_classes/text_generation#transformers.GenerationConfig), dont la documentation doit être consultée pour paramétrer la génération.

logits_processor (`LogitsProcessorList`, *facultatif*) : Processeurs de logits personnalisés qui complètent les processeurs de logits par défaut créés à partir des arguments et de la configuration de génération. Si un processeur de logits est transmis qui a déjà été créé avec les arguments ou une configuration de génération, une erreur est levée. Cette fonctionnalité est destinée aux utilisateurs avancés.

stopping_criteria (`StoppingCriteriaList`, *facultatif*) : Critères d'arrêt personnalisés qui complètent les critères d'arrêt par défaut construits à partir des arguments et d'une configuration de génération. Si un critère d'arrêt est transmis qui a déjà été créé à partir des arguments ou d'une configuration de génération, une erreur est levée. Cette fonctionnalité est destinée aux utilisateurs avancés.

prefix_allowed_tokens_fn (`Callable[[int, torch.Tensor], list[int]]`, *facultatif*) : Si fournie, cette fonction contraint la recherche par faisceau aux jetons autorisés uniquement à chaque étape. Si elle n'est pas fournie, aucune contrainte n'est appliquée. Cette fonction prend 2 arguments : l'identifiant du lot `batch_id` et `input_ids`. Elle doit retourner une liste des jetons autorisés pour l'étape de génération suivante, conditionnée par l'identifiant du lot `batch_id` et les jetons précédemment générés `inputs_ids`. Cet argument est utile pour la génération contrainte conditionnée par le préfixe, comme décrit dans [Autoregressive Entity Retrieval](https://huggingface.co/papers/2010.00904).

synced_gpus (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut continuer à exécuter la boucle while jusqu'à max_length (nécessaire pour éviter un blocage avec `FullyShardedDataParallel` et DeepSpeed ZeRO Stage 3).

kwargs (`dict[str, Any]`, *facultatif*) : Paramétrage ad hoc de `generate_config` et/ou kwargs supplémentaires spécifiques au modèle qui seront transmis à la fonction `forward` du modèle.

**Retourne :** [ModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.utils.ModelOutput) ou `torch.LongTensor`

Un [ModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.utils.ModelOutput) (si `return_dict_in_generate=True` ou lorsque `config.return_dict_in_generate=True`) ou un `torch.Tensor`. Les types [ModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.utils.ModelOutput) possibles sont :
- [GenerateEncoderDecoderOutput](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.generation.GenerateEncoderDecoderOutput),
- [GenerateBeamEncoderDecoderOutput](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.generation.GenerateBeamEncoderDecoderOutput)

Génère des séquences d'identifiants de jetons.

La plupart des paramètres de contrôle de la génération sont définis dans `generation_config` qui, s'il n'est pas transmis, sera réglé sur la configuration de génération par défaut du modèle. Vous pouvez remplacer n'importe quel `generation_config` en transmettant les paramètres correspondants à generate(), par exemple `.generate(inputs, num_beams=4, do_sample=True)`.

Pour un aperçu des stratégies de génération et des exemples de code, consultez le [guide suivant](./generation_strategies).

## SeamlessM4Tv2Config[[transformers.SeamlessM4Tv2Config]]

#### transformers.SeamlessM4Tv2Config[[transformers.SeamlessM4Tv2Config]]

```python
transformers.SeamlessM4Tv2Config(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, 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, is_encoder_decoder: bool = True, vocab_size: int = 256102, t2u_vocab_size: int = 10082, char_vocab_size: int = 10943, hidden_size: int = 1024, initializer_range: float = 0.02, layer_norm_eps: float = 1e-05, use_cache: bool = True, max_position_embeddings: int = 4096, encoder_layerdrop: float | int = 0.05, decoder_layerdrop: float | int = 0.05, activation_function: str = 'relu', dropout: float | int = 0.1, attention_dropout: float | int = 0.1, activation_dropout: float | int = 0.0, scale_embedding: bool = True, encoder_layers: int = 24, encoder_ffn_dim: int = 8192, encoder_attention_heads: int = 16, decoder_layers: int = 24, decoder_ffn_dim: int = 8192, decoder_attention_heads: int = 16, decoder_start_token_id: int = 3, max_new_tokens: int | None = 256, pad_token_id: int | None = 0, bos_token_id: int | None = 2, eos_token_id: int | list[int] | None = 3, speech_encoder_layers: int = 24, speech_encoder_attention_heads: int = 16, speech_encoder_intermediate_size: int = 4096, speech_encoder_hidden_act: str = 'swish', speech_encoder_dropout: float | int = 0.0, add_adapter: bool = True, speech_encoder_layerdrop: float | int = 0.1, feature_projection_input_dim: int = 160, adaptor_kernel_size: int = 8, adaptor_stride: int = 8, adaptor_dropout: float | int = 0.1, num_adapter_layers: int = 1, position_embeddings_type: str = 'relative_key', conv_depthwise_kernel_size: int = 31, left_max_position_embeddings: int = 64, right_max_position_embeddings: int = 8, speech_encoder_chunk_size: int = 20000, speech_encoder_left_chunk_num: int = 128, t2u_bos_token_id: int | None = 0, t2u_pad_token_id: int | None = 1, t2u_eos_token_id: int | list[int] | None = 2, t2u_encoder_layers: int = 6, t2u_encoder_ffn_dim: int = 8192, t2u_encoder_attention_heads: int = 16, t2u_decoder_layers: int = 6, t2u_decoder_ffn_dim: int = 8192, t2u_decoder_attention_heads: int = 16, t2u_max_position_embeddings: int = 4096, t2u_variance_predictor_embed_dim: int = 1024, t2u_variance_predictor_hidden_dim: int = 256, t2u_variance_predictor_kernel_size: int = 3, t2u_variance_pred_dropout: float | int = 0.5, sampling_rate: int = 16000, upsample_initial_channel: int = 512, upsample_rates: list[int] | tuple[int, ...] = (5, 4, 4, 2, 2), upsample_kernel_sizes: list[int] | tuple[int, ...] = (11, 8, 8, 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, unit_hifi_gan_vocab_size: int = 10000, unit_embed_dim: int = 1280, lang_embed_dim: int = 256, spkr_embed_dim: int = 256, vocoder_num_langs: int = 36, vocoder_num_spkrs: int = 200, variance_predictor_kernel_size: int = 3, var_pred_dropout: float | int = 0.5, vocoder_offset: int = 4, tie_word_embeddings: bool = True)
```

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

**Paramètres :**

is_encoder_decoder (`bool`, *facultatif*, valeur par défaut `True`) : Indique si le modèle est utilisé comme encodeur/décodeur ou non.

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

t2u_vocab_size (`int`, *facultatif*, par défaut 10082) : Taille du vocabulaire des unités du modèle SeamlessM4Tv2. Définit le nombre de « jetons d'unité » distincts qui peuvent être représentés par les `inputs_ids` passés lors de l'appel du sous-modèle Text-To-Units de [~SeamlessM4Tv2Model](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2Model), [~SeamlessM4Tv2ForSpeechToSpeech](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2ForSpeechToSpeech) ou [~SeamlessM4Tv2ForTextToSpeech](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2ForTextToSpeech).

char_vocab_size (`int`, *facultatif*, valeur par défaut 10943) : Taille du vocabulaire de caractères du modèle SeamlessM4Tv2. Définit le nombre de jetons de caractères différents qui peuvent être représentés par `char_inputs_ids` lors de l'appel du sous-modèle Text-To-Units de [~SeamlessM4Tv2Model](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2Model), [~SeamlessM4Tv2ForSpeechToSpeech](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2ForSpeechToSpeech) ou [~SeamlessM4Tv2ForTextToSpeech](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2ForTextToSpeech).

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

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

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

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

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

activation_function (`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.

dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.1`) : Le ratio pour toutes les couches de dropout.

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.0`) : Le taux de dropout pour les activations à l'intérieur de la couche entièrement connectée.

scale_embedding (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut mettre à l'échelle les embeddings en les divisant par sqrt(d_model).

encoder_layers (`int`, *facultatif*, valeur par défaut `24`) : Nombre de couches cachées dans l'encodeur Transformer. Utilise la même valeur que `num_layers` si non défini.

encoder_ffn_dim (`int`, *facultatif*, valeur par défaut `8192`) : Dimension de la couche « intermédiaire » (souvent appelée couche feed-forward) dans l'encodeur.

encoder_attention_heads (`int`, *facultatif*, valeur par défaut `16`) : Nombre de têtes d'attention pour chaque couche d'attention dans l'encodeur Transformer.

decoder_layers (`int`, *facultatif*, valeur par défaut `24`) : Nombre de couches cachées dans le décodeur Transformer. Utilise la même valeur que `num_layers` si non défini.

decoder_ffn_dim (`int`, *facultatif*, valeur par défaut `8192`) : Dimension de la couche « intermédiaire » (souvent appelée couche feed-forward) du décodeur.

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

decoder_start_token_id (`int`, *facultatif*, valeur par défaut `3`) : si un modèle encodeur-décodeur commence le décodage avec un jeton différent de `bos`, l'identifiant de ce jeton.

max_new_tokens (`int`, *facultatif*, valeur par défaut 256) : Nombre maximal de jetons de texte à générer, en ignorant le nombre de jetons du prompt.

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

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

eos_token_id (`Union[int, list[int]]`, *facultatif*, valeur par défaut `3`) : Identifiant de jeton utilisé pour la fin de flux dans le vocabulaire.

speech_encoder_layers (`int`, *facultatif*, valeur par défaut : 24) : Nombre de couches cachées dans l'encodeur de parole Transformer.

speech_encoder_attention_heads (`int`, *facultatif*, valeur par défaut : 16) : Nombre de têtes d'attention pour chaque couche d'attention dans l'encodeur vocal Transformer.

speech_encoder_intermediate_size (`int`, *facultatif*, valeur par défaut 4096) : Dimension de la couche « intermédiaire » (c.-à-d. à propagation avant) de l'encodeur vocal Transformer.

speech_encoder_hidden_act (`str` ou `function`, *facultatif*, par défaut `"swish"`) : La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans l'encodeur audio. Si c'est une chaîne de caractères, `"gelu"`, `"relu"`, `"selu"`, `"swish"` et `"gelu_new"` sont pris en charge.

speech_encoder_dropout (`float`, *facultatif*, valeur par défaut 0.0) : La probabilité de dropout pour toutes les couches de l'encodeur audio.

add_adapter (`bool`, *facultatif*, valeur par défaut `True`) : Ajoute une couche d'adaptateur au-dessus de l'encodeur audio.

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

feature_projection_input_dim (`int`, *facultatif*, valeur par défaut 160) : Dimension d'entrée de la projection des caractères d'entrée de l'encodeur audio, c'est-à-dire la dimension après le traitement des audios d'entrée avec [SeamlessM4TFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TFeatureExtractor).

adaptor_kernel_size (`int`, *facultatif*, valeur par défaut : 8) : Taille du noyau des couches de convolution du réseau adaptateur. Ne concerne que le cas où `add_adapter is True`.

adaptor_stride (`int`, *facultatif*, par défaut 8) : Pas des couches convolutives du réseau adaptateur. Ne concerne que le cas où `add_adapter is True`.

adaptor_dropout (`float`, *facultatif*, valeur par défaut 0.1) : La probabilité de dropout pour toutes les couches de l'adaptateur vocal.

num_adapter_layers (`int`, *facultatif*, valeur par défaut : 1) : Nombre de couches de convolution à utiliser dans le réseau adaptateur. Ne concerne que le cas où `add_adapter is True`.

position_embeddings_type (`str`, *facultatif*, valeur par défaut `"relative_key"`) : Peut être spécifié pour `relative_key`. S'il est laissé à `None`, aucun encodage de position relative n'est appliqué. Appliqué uniquement à l'encodeur vocal. Pour plus d'informations sur `"relative_key"`, veuillez consulter [Self-Attention with Relative Position Representations (Shaw et al.)](https://huggingface.co/papers/1803.02155).

conv_depthwise_kernel_size (`int`, *facultatif*, valeur par défaut 31) : Taille du noyau de la couche convolutive 1D en profondeur dans les blocs Conformer. Appliqué uniquement à l'encodeur audio.

left_max_position_embeddings (`int`, *facultatif*, valeur par défaut 64) : valeur de rognage à gauche pour les positions relatives.

right_max_position_embeddings (`int`, *facultatif*, valeur par défaut : 8) : La valeur de rognage à droite pour les positions relatives.

speech_encoder_chunk_size (`int`, *facultatif*, valeur par défaut 20000) : La taille de chaque bloc d'attention.

speech_encoder_left_chunk_num (`int`, *facultatif*, valeur par défaut 128) : Nombre de blocs à gauche jusqu'à lesquels l'anticipation est autorisée.

t2u_bos_token_id (`int`, *facultatif*, valeur par défaut 0) : L'identifiant du jeton d'unité _beginning-of-stream_. Appliqué uniquement au modèle seq2seq texte-versus-unité.

t2u_pad_token_id (`int`, *facultatif*, valeur par défaut : 1) : L'identifiant du jeton d'unité de _padding_. Appliqué uniquement au modèle seq2seq texte-vers-unité.

t2u_eos_token_id (`int`, *facultatif*, valeur par défaut : 2) : L'identifiant du jeton d'unité _end-of-stream_. Appliqué uniquement au modèle seq2seq texte-versus-unité.

t2u_encoder_layers (`int`, *facultatif*, valeur par défaut : 6) : Nombre de couches cachées dans l'encodeur texte-vers-unité Transformer.

t2u_encoder_ffn_dim (`int`, *facultatif*, valeur par défaut : 8192) : Dimension de la couche « intermédiaire » (c.-à-d. à propagation avant) de l'encodeur texte-vers-unité Transformer.

t2u_encoder_attention_heads (`int`, *facultatif*, valeur par défaut : 16) : Nombre de têtes d'attention pour chaque couche d'attention dans l'encodeur texte-vers-unité du Transformer.

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

t2u_decoder_ffn_dim (`int`, *facultatif*, valeur par défaut : 8192) : Dimension de la couche « intermédiaire » (c.-à-d. feed-forward) du décodeur texte-vers-unité du Transformer.

t2u_decoder_attention_heads (`int`, *facultatif*, valeur par défaut : 16) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur texte-vers-unité du Transformer.

t2u_max_position_embeddings (`int`, *facultatif*, valeur par défaut 4096) : La longueur de séquence maximale avec laquelle ce composant texte-vers-unité du modèle pourrait éventuellement être utilisé. Il est généralement recommandé de définir cette valeur sur un nombre élevé par précaution (par exemple, 512, 1024 ou 2048).

t2u_variance_predictor_embed_dim (`int`, *facultatif*, valeur par défaut 1024) : La dimension de projection du prédicteur de durée de l'unité texte-vers-unité.

t2u_variance_predictor_hidden_dim (`int`, *facultatif*, valeur par défaut : 256) : Dimension interne du prédicteur de durée du composant texte-vers-unité.

t2u_variance_predictor_kernel_size (`int`, *facultatif*, valeur par défaut : 3) : Taille du noyau des couches de convolution du prédicteur de durée du texte vers l'unité.

t2u_variance_pred_dropout (`float`, *facultatif*, valeur par défaut 0,5) : La probabilité de dropout du prédicteur de durée du modèle texte-vers-unité.

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

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. S'applique uniquement au vocoder.

upsample_rates (`tuple[int]` ou `list[int]`, *facultatif*, valeur par défaut `[5, 4, 4, 2, 2]`) : Un tuple d'entiers définissant le pas de chaque couche de convolution 1D du réseau d'interpolation ascendante du vocoder. La longueur de *upsample_rates* définit le nombre de couches de convolution et doit correspondre à la longueur de *upsample_kernel_sizes*. S'applique uniquement au vocoder.

upsample_kernel_sizes (`tuple[int]` ou `list[int]`, *facultatif*, valeur par défaut `[11, 8, 8, 4, 4]`) : Un tuple d'entiers définissant la taille du noyau de chaque couche de convolution 1D dans le réseau de remontrage du vocoder. La longueur de *upsample_kernel_sizes* définit le nombre de couches de convolution et doit correspondre à la longueur de *upsample_rates*. S'applique uniquement au vocoder.

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 vocodeur dans le module de fusion multi-réceptif (MRF). S'applique uniquement au vocodeur.

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 du vocoder dans le module de fusion multi-récepteur (MRF). S'applique uniquement au vocoder.

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

unit_hifi_gan_vocab_size (`int`, *facultatif*, valeur par défaut 10000) : Taille du vocabulaire du vocodeur SeamlessM4Tv2. Définit le nombre de jetons d'unités différents qui peuvent être représentés par les `inputs_ids` passés lors de l'appel du vocodeur de [~SeamlessM4Tv2Model](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2Model), [~SeamlessM4Tv2ForSpeechToSpeech](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2ForSpeechToSpeech) ou [~SeamlessM4Tv2ForTextToSpeech](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t_v2#transformers.SeamlessM4Tv2ForTextToSpeech).

unit_embed_dim (`int`, *facultatif*, valeur par défaut 1280) : La dimension de projection des identifiants d'entrée fournis au vocodeur hifi-gan. S'applique uniquement au vocodeur.

lang_embed_dim (`int`, *facultatif*, valeur par défaut 256) : La dimension de projection de la langue cible transmise au vocodeur hifi-gan. S'applique uniquement au vocodeur.

spkr_embed_dim (`int`, *facultatif*, valeur par défaut 256) : La dimension de projection de l'identifiant de locuteur transmis au vocodeur hifi-gan. S'applique uniquement au vocodeur.

vocoder_num_langs (`int`, *facultatif*, valeur par défaut 36) : Nombre de langues prises en charge par le vocoder. Peut différer de `t2u_num_langs`.

vocoder_num_spkrs (`int`, *facultatif*, valeur par défaut 200) : Nombre d'orateurs pris en charge par le vocodeur.

variance_predictor_kernel_size (`int`, *facultatif*, valeur par défaut : 3) : Taille du noyau du prédicteur de durée. S'applique uniquement au vocodeur.

var_pred_dropout (`float`, *facultatif*, valeur par défaut 0,5) : La probabilité de dropout du prédicteur de durée. S'applique uniquement au vocodeur.

vocoder_offset (`int`, *facultatif*, valeur par défaut : 4) : Décale les identifiants de jetons unitaires de ce nombre pour prendre en compte les jetons de symboles. S'applique uniquement au vocodeur.

tie_word_embeddings (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut lier les embeddings de poids selon la correspondance `tied_weights_keys` du modèle.

Il s'agit de la classe de configuration destinée à stocker la configuration d'un SeamlessM4Tv2Model. Elle est utilisée pour instancier un modèle Seamless M4T V2 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/hf-seamless-m4t-medium](https://huggingface.co/facebook/hf-seamless-m4t-medium)

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.

```python
>>> from transformers import SeamlessM4Tv2Model, SeamlessM4Tv2Config

>>> # Initializing a SeamlessM4Tv2 "" style configuration
>>> configuration = SeamlessM4Tv2Config()

>>> # Initializing a model from the "" style configuration
>>> model = SeamlessM4Tv2Model(configuration)

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

