# SeamlessM4T

## Aperçu

Le modèle SeamlessM4T a été proposé dans [SeamlessM4T — Massively Multilingual & Multimodal Machine Translation](https://huggingface.co/papers/2308.11596) par l'équipe Seamless Communication de Meta AI.

Il s'agit de la publication de la **version 1** du modèle. Pour la publication mise à jour de la **version 2**, reportez-vous à la [documentation de Seamless M4T v2](./seamless_m4t_v2).

SeamlessM4T est une collection de modèles conçus pour fournir des traductions de haute qualité, permettant aux personnes issues de différentes communautés linguistiques de communiquer sans effort par la voix et par le texte.

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

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

*Que faut-il pour créer le Babel Fish, un outil capable d’aider les individus à traduire la parole entre n’importe quelles deux langues ? Si les récentes percées dans les modèles basés sur le texte ont étendu la couverture de la traduction automatique à plus de 200 langues, les modèles unifiés de traduction de la parole à la parole n’ont pas encore atteint des progrès similaires. Plus précisément, les systèmes conventionnels de traduction de la parole à la parole s’appuient sur des systèmes en cascade qui effectuent la traduction de manière progressive, rendant les systèmes unifiés à haute performance inaccessibles. Pour combler ces lacunes, nous présentons SeamlessM4T, un modèle unique qui prend en charge la traduction de la parole à la parole, la traduction de la parole au texte, la traduction du texte à la parole, la traduction du texte au texte et la reconnaissance automatique de la parole pour jusqu’à 100 langues. Pour le construire, nous avons utilisé 1 million d’heures de données audio ouvertes pour apprendre des représentations auto-supervisées de la parole avec w2v-BERT 2.0. Nous avons ensuite créé un corpus multimodal de traductions de la parole alignées automatiquement. Filtre et combiné avec des données étiquetées par des humains et des données pseudo-étiquetées, nous avons développé le premier système multilingue capable de traduire depuis et vers l’anglais pour la parole et le texte. Sur FLEURS, SeamlessM4T établit une nouvelle norme pour les traductions vers plusieurs langues cibles, atteignant une amélioration de 20 % BLEU par rapport au SOTA précédent en traduction directe de la parole au texte. Par rapport à des modèles en cascade performants, SeamlessM4T améliore la qualité de la traduction vers l’anglais de 1,3 points BLEU en parole-à-texte et de 2,6 points ASR-BLEU en parole-à-parole. Testé pour sa robustesse, notre système offre de meilleures performances face aux bruits de fond et aux variations de locuteurs dans les tâches de parole-à-texte par rapport au modèle SOTA actuel. De manière cruciale, nous avons évalué SeamlessM4T sur le biais de genre et ajouté la toxicité pour évaluer la sécurité de la traduction. Enfin, toutes les contributions de ce travail sont open-sourcées et accessibles à l’adresse https://github.com/facebookresearch/seamless_communication*

## Utilisation

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

```python
from transformers import AutoProcessor, SeamlessM4TModel

processor = AutoProcessor.from_pretrained("facebook/hf-seamless-m4t-medium")
model = SeamlessM4TModel.from_pretrained("facebook/hf-seamless-m4t-medium", 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 test as well
text_inputs = processor(text = "Hello, my dog is cute", src_lang="eng", return_tensors="pt").to(model.device)
```

### Traitement de la parole

[SeamlessM4TModel](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TModel) 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` à [SeamlessM4TModel.generate()](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TModel.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

[SeamlessM4TModel](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TModel) 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 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 SeamlessM4TForSpeechToSpeech

model = SeamlessM4TForSpeechToSpeech.from_pretrained("facebook/hf-seamless-m4t-medium", 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 SeamlessM4TForTextToText

model = SeamlessM4TForTextToText.from_pretrained("facebook/hf-seamless-m4t-medium", device_map="auto")
```

N'hésitez pas à essayer également [SeamlessM4TForSpeechToText](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TForSpeechToText) et [SeamlessM4TForTextToSpeech](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TForTextToSpeech).

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

Vous avez la possibilité de changer le locuteur utilisé pour la synthèse vocale à l'aide de l'argument `spkr_id`. Certains `spkr_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 parole et de texte, par exemple `.generate(input_ids=input_ids, text_num_beams=4, speech_do_sample=True)`, qui effectuera successivement un décodage par beam-search sur le modèle de texte et un échantillonnage multinomial sur le modèle de parole.

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

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

## Architecture du modèle

SeamlessM4T dispose d'une architecture polyvalente qui gère en douceur 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.

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, suivant une structure standard encodeur-décodeur, génère des jetons unitaires.
- 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).

## SeamlessM4TModel[[transformers.SeamlessM4TModel]]

#### transformers.SeamlessM4TModel[[transformers.SeamlessM4TModel]]

```python
transformers.SeamlessM4TModel(config: SeamlessM4TConfig, current_modality = 'text')
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L3361)

**Paramètres :**

config ([SeamlessM4TConfig](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TConfig)) : 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 SeamlessM4T, 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.SeamlessM4TModel.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, spkr_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/modeling_seamless_m4t.py#L3549)

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

spkr_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[SeamlessM4TGenerationOutput, tuple[Tensor], ModelOutput]`

- Si `generate_speech` et `return_intermediate_token_ids`, renvoie `SeamlessM4TGenerationOutput`.
- 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).

## SeamlessM4TForTextToSpeech[[transformers.SeamlessM4TForTextToSpeech]]

#### transformers.SeamlessM4TForTextToSpeech[[transformers.SeamlessM4TForTextToSpeech]]

```python
transformers.SeamlessM4TForTextToSpeech(config: SeamlessM4TConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L2753)

**Paramètres :**

config ([SeamlessM4TConfig](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TConfig)) : 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 SeamlessM4T, 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.SeamlessM4TForTextToSpeech.generate]]

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L2881)

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

spkr_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[SeamlessM4TGenerationOutput, tuple[Tensor]]`

- Si `return_intermediate_token_ids` est défini, renvoie `SeamlessM4TGenerationOutput`.
- 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).

## SeamlessM4TForSpeechToSpeech[[transformers.SeamlessM4TForSpeechToSpeech]]

#### transformers.SeamlessM4TForSpeechToSpeech[[transformers.SeamlessM4TForSpeechToSpeech]]

```python
transformers.SeamlessM4TForSpeechToSpeech(config: SeamlessM4TConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L3054)

**Paramètres :**

config ([SeamlessM4TConfig](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TConfig)) : 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 SeamlessM4T 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.SeamlessM4TForSpeechToSpeech.generate]]

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L3181)

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

spkr_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[SeamlessM4TGenerationOutput, tuple[Tensor]]`

- Si `return_intermediate_token_ids` est défini, renvoie `SeamlessM4TGenerationOutput`.
- 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).

## SeamlessM4TForTextToText[[transformers.SeamlessM4TForTextToText]]

#### transformers.SeamlessM4TForTextToText[[transformers.SeamlessM4TForTextToText]]

```python
transformers.SeamlessM4TForTextToText(config: SeamlessM4TConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L2277)

**Paramètres :**

config ([SeamlessM4TConfig](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TConfig)) : 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 SeamlessM4T 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.SeamlessM4TForTextToText.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/modeling_seamless_m4t.py#L2313)

**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 en fonction de la configuration ([SeamlessM4TConfig](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TConfig)) et des entrées.

La méthode forward de [SeamlessM4TForTextToText](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TForTextToText) 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.SeamlessM4TForTextToText.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/modeling_seamless_m4t.py#L2395)

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

## SeamlessM4TForSpeechToText[[transformers.SeamlessM4TForSpeechToText]]

#### transformers.SeamlessM4TForSpeechToText[[transformers.SeamlessM4TForSpeechToText]]

```python
transformers.SeamlessM4TForSpeechToText(config: SeamlessM4TConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L2512)

**Paramètres :**

config ([SeamlessM4TConfig](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TConfig)) : 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 SeamlessM4T, utilisable 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.SeamlessM4TForSpeechToText.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/modeling_seamless_m4t.py#L2545)

**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 en fonction de la configuration ([SeamlessM4TConfig](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TConfig)) et des entrées.

La méthode forward de [SeamlessM4TForSpeechToText](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TForSpeechToText) 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, SeamlessM4TForSpeechToText
>>> 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 = SeamlessM4TForSpeechToText.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.SeamlessM4TForSpeechToText.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/modeling_seamless_m4t.py#L2634)

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

## SeamlessM4TConfig[[transformers.SeamlessM4TConfig]]

#### transformers.SeamlessM4TConfig[[transformers.SeamlessM4TConfig]]

```python
transformers.SeamlessM4TConfig(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, hidden_size: int = 1024, initializer_range: float = 0.02, layer_norm_eps: float = 1e-05, use_cache: bool = True, max_position_embeddings: int = 1024, 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, num_conv_pos_embeddings: int = 128, num_conv_pos_embedding_groups: int = 16, 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', rotary_embedding_base: int = 10000, max_source_positions: int = 4096, conv_depthwise_kernel_size: int = 31, t2u_bos_token_id: int | None = 0, t2u_pad_token_id: int | None = 1, t2u_eos_token_id: int | list[int] | None = 2, t2u_decoder_start_token_id: int = 2, t2u_max_new_tokens: int = 1024, 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 = 2048, 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/configuration_seamless_m4t.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 SeamlessM4T. 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 [~SeamlessM4TModel](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TModel), [~SeamlessM4TForSpeechToSpeech](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TForSpeechToSpeech) ou [~SeamlessM4TForTextToSpeech](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TForTextToSpeech).

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 `1024`) : 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).

num_conv_pos_embeddings (`int`, *facultatif*, valeur par défaut 128) : Nombre d'incorporations positionnelles convolutives. Définit la taille du noyau de la couche d'incorporations positionnelles convolutives 1D de l'encodeur audio.

num_conv_pos_embedding_groups (`int`, *facultatif*, valeur par défaut 16) : Nombre de groupes de la couche d'embeddings positionnels convolutifs 1D de l'encodeur audio.

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"`) : Peut être défini sur `relative` ou `rotary` pour les embeddings de position relatifs ou rotatifs, respectivement. S'il est laissé à `None`, aucun embedding de position relatif n'est appliqué. Appliqué uniquement à l'encodeur vocal.

rotary_embedding_base (`int`, *facultatif*, valeur par défaut 10000) : Si des embeddings de position `"rotary"` sont utilisés, définit la taille de la base d'embedding. Appliqué uniquement à l'encodeur vocal.

max_source_positions (`int`, *facultatif*, valeur par défaut 4096) : si des embeddings de position `"relative"` sont utilisés, définit les positions d'entrée source maximales. Appliqué uniquement à l'encodeur vocal.

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.

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_decoder_start_token_id (`int`, *facultatif*, valeur par défaut : 2) : Si un modèle encodeur-décodeur commence le décodage avec un jeton différent de _bos_, l'identifiant de ce jeton. Appliqué uniquement au modèle seq2seq texte-vers-unité.

t2u_max_new_tokens (`int`, *facultatif*, valeur par défaut 1024) : Nombre maximal de jetons unitaires à générer, en ignorant le nombre de jetons du prompt. Appliqué uniquement au modèle seq2seq texte-vers-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 : 2048) : La longueur de séquence maximale avec laquelle ce composant texte-vers-unité du modèle pourrait ê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).

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 SeamlessM4T. Définit le nombre de jetons d'unités distincts qui peuvent être représentés par les `inputs_ids` passés lors de l'appel du vocodeur de [~SeamlessM4TModel](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TModel), [~SeamlessM4TForSpeechToSpeech](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TForSpeechToSpeech) ou [~SeamlessM4TForTextToSpeech](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TForTextToSpeech).

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 SeamlessM4TModel. Elle est utilisée pour instancier un modèle Seamless M4T 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 SeamlessM4TModel, SeamlessM4TConfig

>>> # Initializing a SeamlessM4T "facebook/hf-seamless-m4t-medium" style configuration
>>> configuration = SeamlessM4TConfig()

>>> # Initializing a model from the "facebook/hf-seamless-m4t-medium" style configuration
>>> model = SeamlessM4TModel(configuration)

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

## SeamlessM4TTokenizer[[transformers.SeamlessM4TTokenizer]]

#### transformers.SeamlessM4TTokenizer[[transformers.SeamlessM4TTokenizer]]

```python
transformers.SeamlessM4TTokenizer(vocab: str | dict[str, int] | None = None, merges: str | list[str] | None = None, bos_token = '<s>', eos_token = '</s>', sep_token = '</s>', cls_token = '<s>', unk_token = '<unk>', pad_token = '<pad>', src_lang = 'eng', tgt_lang = 'fra', additional_special_tokens = None, keep_accents = None, vocab_file = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/tokenization_seamless_m4t.py#L33)

**Paramètres :**

vocab (`list` ou `dict`, *facultatif*) : Liste de tuples (jeton, score) ou dictionnaire associant les jetons à des indices. Si non fourni, utilise le vocabulaire par défaut.

merges (`str` ou `list`, *facultatif*) : Liste de règles de fusion pour le modèle BPE. Si non fournie, utilise une liste vide.

bos_token (`str`, *facultatif*, valeur par défaut `"<s>"`) : Jeton de début de séquence utilisé lors de la préformation. Peut être utilisé comme jeton de classifieur de séquence. Lors de la construction d'une séquence à l'aide de jetons spéciaux, ce n'est pas le jeton utilisé pour le début de séquence. Le jeton utilisé est `cls_token`.

eos_token (`str`, *facultatif*, par défaut `"</s>"`) : Jeton de fin de séquence. Lors de la construction d'une séquence à l'aide de jetons spéciaux, ce n'est pas le jeton utilisé pour la fin de séquence. Le jeton utilisé est le `sep_token`.

sep_token (`str`, *facultatif*, valeur par défaut `"</s>"`) : le jeton séparateur, utilisé lors de la construction d'une séquence à partir de plusieurs séquences, par exemple deux séquences pour la classification de séquences ou un texte et une question pour le question answering. Il est également utilisé comme dernier jeton d'une séquence construite avec des jetons spéciaux.

cls_token (`str`, *facultatif*, valeur par défaut `"<s>"`) : le jeton de classifieur utilisé lors de la classification de séquence (classification de la séquence entière plutôt que la classification par jeton). C'est le premier jeton de la séquence lorsqu'elle est construite avec des jetons spéciaux.

unk_token (`str`, *facultatif*, par défaut `"<unk>"`) : Le jeton inconnu. Un jeton qui n'est pas dans le vocabulaire ne peut pas être converti en identifiant et est remplacé par ce jeton.

pad_token (`str`, *facultatif*, par défaut `"<pad>"`) : le jeton utilisé pour le bourrage, par exemple lors du groupement de séquences de longueurs différentes.

src_lang (`str`, *facultatif*, valeur par défaut `"eng"`) : La langue à utiliser comme langue source pour la traduction.

tgt_lang (`str`, *facultatif*, valeur par défaut `"fra"`) : La langue à utiliser comme langue cible pour la traduction.

additional_special_tokens (tuple ou liste de `str` ou `tokenizers.AddedToken`, *facultatif*) : Un tuple ou une liste de jetons spéciaux supplémentaires.

Construit un tokenizer SeamlessM4T (basé sur la bibliothèque *tokenizers* de HuggingFace). Fondé sur [BPE](https://huggingface.co/docs/tokenizers/python/latest/components.html?highlight=bpe#models).

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

La méthode de tokenisation est `<language code> <tokens> <eos>` pour les documents de la langue source, et ` <language code>  ` pour les documents de la langue cible.

Exemples :

```python
>>> from transformers import SeamlessM4TTokenizer

>>> tokenizer = SeamlessM4TTokenizer.from_pretrained(
...     "facebook/hf-seamless-m4t-medium", src_lang="eng", tgt_lang="fra"
... )
>>> example_english_phrase = " UN Chief Says There Is No Military Solution in Syria"
>>> expected_translation_french = "Le chef de l'ONU affirme qu'il n'y a pas de solution militaire en Syrie."
>>> inputs = tokenizer(example_english_phrase, text_target=expected_translation_french, return_tensors="pt")
```

#### __appel__[[transformers.SeamlessM4TTokenizer.__call__]]

```python
__call__(text: str | list[str] | list[list[str]] | None = None, text_pair: str | list[str] | list[list[str]] | None = None, text_target: str | list[str] | list[list[str]] | None = None, text_pair_target: str | list[str] | list[list[str]] | None = None, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, pad_to_multiple_of: int | None = None, src_lang: str | None = None, tgt_lang: str | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/tokenization_seamless_m4t.py#L355)

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

padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/v5.23.0/fr/internal/file_utils#transformers.utils.PaddingStrategy), *facultatif*, valeur par défaut `False`) : Sélectionne une stratégie pour mettre en place le padding des séquences renvoyées (selon le côté de padding et l'index de padding du modèle) parmi :  - `True` ou `'longest'` : Met en place le padding jusqu'à la séquence la plus longue du lot (ou aucun padding si une seule séquence est fournie). - `'max_length'` : Met en place le padding 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 padding (c'est-à-dire, peut renvoyer un lot avec des séquences de longueurs différentes).

pad_to_multiple_of (`int`, *facultatif*, valeur par défaut `None`) : Si défini, la séquence sera rembourdie jusqu'à un multiple de la valeur fournie. 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).

src_lang (`str`, *facultatif*) : Une chaîne de caractères représentant la langue source. Si elle n'est pas spécifiée, la dernière valeur de `src_lang` définie (soit lors de l'initialisation, soit lors de l'appel de ce tokenizer) sera utilisée.

tgt_lang (`str`, *facultatif*) : Une chaîne de caractères représentant la langue cible. Si elle n'est pas spécifiée, la dernière valeur de `tgt_lang` définie (soit lors de l'initialisation, soit lors de l'appel de ce tokenizer) sera utilisée.

kwargs (*facultatif*) : Dictionnaire restant des arguments par mot-clé qui seront transmis à [TokenizersBackend.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__).

#### get_special_tokens_mask[[transformers.SeamlessM4TTokenizer.get_special_tokens_mask]]

```python
get_special_tokens_mask(token_ids_0: list[int], token_ids_1: list[int] | None = None, already_has_special_tokens: bool = False)
```

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

**Paramètres :**

token_ids_0 : Liste des identifiants de la séquence (éventuellement déjà formatée).

token_ids_1 : Non utilisé lorsque `already_has_special_tokens=True`. Doit être None dans ce cas.

already_has_special_tokens : Indique si la séquence est déjà formatée avec des jetons spéciaux.

**Retourne :** une liste d'entiers dans l'intervalle [0, 1]

1 pour un jeton spécial, 0 pour un jeton de séquence.

Récupérer les identifiants de séquences à partir d'une liste de jetons à laquelle aucun jeton spécial n'a été ajouté.

Pour les tokenizers rapides, les data collators appellent cette fonction avec `already_has_special_tokens=True` afin de construire un masque sur une séquence déjà formatée. Dans ce cas, nous calculons le masque en vérifiant l’appartenance à `all_special_ids`.

#### save_vocabulary[[transformers.SeamlessM4TTokenizer.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/tokenization_utils_tokenizers.py#L547)

## SeamlessM4TFeatureExtractor[[transformers.SeamlessM4TFeatureExtractor]]

#### transformers.SeamlessM4TFeatureExtractor[[transformers.SeamlessM4TFeatureExtractor]]

```python
transformers.SeamlessM4TFeatureExtractor(feature_size = 80, sampling_rate = 16000, num_mel_bins = 80, padding_value = 0.0, stride = 2, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/feature_extraction_seamless_m4t.py#L35)

**Paramètres :**

feature_size (`int`, *facultatif*, valeur par défaut 80) : La dimension des caractéristiques des fonctionnalités extraites.

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

num_mel_bins (`int`, *facultatif*, valeur par défaut 80) : Nombre de bandes de fréquences Mel.

padding_value (`float`, *facultatif*, valeur par défaut 0.0) : La valeur utilisée pour remplir les vecteurs de bourrage.

stride (`int`, *facultatif*, valeur par défaut : 2) : Pas utilisé pour redimensionner les audios de la forme (batch_size,num_frames,num_mel_bins) à (batch_size,num_frames//stride,num_mel_bins*stride).

Construit un extracteur de caractéristiques SeamlessM4T.

Cet extracteur de caractéristiques hérite de [SequenceFeatureExtractor](/docs/transformers/v5.23.0/fr/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), qui contient la plupart des méthodes principales. Les utilisateurs doivent se reporter à cette superclasse pour plus d'informations sur ces méthodes.

Cette classe extrait les caractéristiques de la banque de filtres mel à partir de la parole brute.

#### __appel__[[transformers.SeamlessM4TFeatureExtractor.__call__]]

```python
__call__(raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]], padding: bool | str | transformers.utils.generic.PaddingStrategy = True, pad_to_multiple_of: int | None = 2, max_length: int | None = None, truncation: bool = False, return_tensors: str | transformers.utils.generic.TensorType | None = None, sampling_rate: int | None = None, return_attention_mask: bool | None = None, do_normalize_per_mel_bins: bool | None = True, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/feature_extraction_seamless_m4t.py#L140)

**Paramètres :**

raw_speech (`np.ndarray`, `torch.Tensor`, `list[float]`, `list[np.ndarray]`, `list[torch.Tensor]`, --

`list[list[float]]`, `list[list[list[float]]]`) : La séquence ou le lot de séquences à rembourrer. Chaque séquence peut être un tableau numpy, un tenseur torch, une liste de valeurs flottantes, une liste de tableaux numpy, une liste de tenseurs torch, une liste de listes de valeurs flottantes ou une liste de listes de listes de valeurs flottantes. Si `raw_speech` est un `np.ndarray`, un `torch.Tensor` ou une `list[float]` unidimensionnel, `raw_speech` est considéré comme un son mono-canal, mono-échantillon. Dans tous les autres cas, la première dimension de `raw_speech`, qu'elle provienne d'un `np.ndarray`, d'un `torch.Tensor` ou d'une `list[...]`, correspond au nombre d'échantillons du lot, et le nombre de canaux (c'est-à-dire le caractère mono ou stéréo) est déduit des autres dimensions (1D -> lots de formes d'onde mono-canal ; 2D-> lots de formes d'onde stéréo-canal).

padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/v5.23.0/fr/internal/file_utils#transformers.utils.PaddingStrategy), *facultatif*, valeur par défaut `True`) : Sélectionne une stratégie pour mettre en place le padding des séquences renvoyées (selon le côté de padding et l'index de padding du modèle) parmi :  - `True` ou `'longest'` : Padding jusqu'à la séquence la plus longue du lot (ou aucun padding si une seule séquence est fournie). - `'max_length'` : Padding 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 padding (c'est-à-dire, peut renvoyer un lot avec des séquences de longueurs différentes).

pad_to_multiple_of (`int`, *facultatif*, valeur par défaut : 2) : Si défini, la séquence sera rembourdée jusqu'à un multiple de la valeur fournie. 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), ou sur les TPU, qui bénéficient de longueurs de séquence multiples de 128.

max_length (`int`, *facultatif*) : Longueur maximale de la liste renvoyée et, le cas échéant, longueur du bourrage (voir ci-dessus).

truncation (`bool`) : Active la troncature pour couper les séquences d'entrée plus longues que *max_length* à *max_length*.

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 feature_extractor spécifique. [Qu'est-ce que les masques d'attention ?](../glossary#attention-mask) Pour les modèles SeamlessM4T, `attention_mask` doit toujours être transmis lors d'une inférence par lots, afin d'éviter des bugs subtils.

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.

sampling_rate (`int`, *facultatif*) : Le taux d'échantillonnage auquel l'entrée `raw_speech` a été échantillonnée. Il est fortement recommandé de passer `sampling_rate` lors de l'appel forward afin d'éviter les erreurs silencieuses.

do_normalize_per_mel_bins (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut normaliser l'entrée par canal mel avec une moyenne nulle et une variance unitaire.

kwargs (*facultatif*) : Dictionnaire restant des arguments par mot-clé qui seront transmis au tokenizer ou à l'extracteur de caractéristiques.

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

## SeamlessM4TProcessor[[transformers.SeamlessM4TProcessor]]

#### transformers.SeamlessM4TProcessor[[transformers.SeamlessM4TProcessor]]

```python
transformers.SeamlessM4TProcessor(feature_extractor, tokenizer)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/processing_seamless_m4t.py#L48)

**Paramètres :**

feature_extractor (`SeamlessM4TFeatureExtractor`) : l'extracteur de caractéristiques est une entrée obligatoire.

tokenizer (`SeamlessM4TTokenizer`) : le tokenizer est une entrée obligatoire.

Construit un SeamlessM4TProcessor qui encapsule un extracteur de caractéristiques et un tokeniseur en un seul processeur.

[SeamlessM4TProcessor](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TProcessor) offre toutes les fonctionnalités de [SeamlessM4TFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TFeatureExtractor) et de [SeamlessM4TTokenizer](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TTokenizer). Consultez [~SeamlessM4TFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TFeatureExtractor) et [~SeamlessM4TTokenizer](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TTokenizer) pour plus d'informations.

#### __appel__[[transformers.SeamlessM4TProcessor.__call__]]

```python
__call__(text: str | list[str] | list[list[str]] | None = None, audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, **kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/processing_seamless_m4t.py#L52)

**Paramètres :**

text (`Union[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 (chaîne pré-tokenisée). Si vous transmettez une entrée pré-tokenisée, définissez `is_split_into_words=True` pour éviter toute ambiguïté avec les entrées en lot.

audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *facultatif*) : L'audio ou le lot d'audios à préparer. Chaque audio peut être un tableau NumPy ou un tenseur PyTorch. Dans le cas d'un tableau NumPy/d'un tenseur PyTorch, chaque audio doit avoir la forme (C, T), où C est le nombre de canaux et T est la longueur en échantillons de l'audio.

return_mm_token_type_ids (`bool`, *kwargs*) : Indique s'il faut retourner les identifiants de type de jeton multimodal indiquant les positions des jetons de substitution multimodaux.

return_text_replacement_offsets (`bool`, *kwargs*) : Indique s'il faut retourner les décalages de caractères pour chaque emplacement multimodal et son remplacement.

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

- ****kwargs** ([ProcessingKwargs](/docs/transformers/v5.23.0/fr/main_classes/processors#transformers.ProcessingKwargs), *facultatif*) : Options de traitement supplémentaires pour chaque modalité (texte, images, vidéos, audio). Les paramètres spécifiques au modèle sont répertoriés ci-dessus ; consultez la classe TypedDict pour la liste complète des arguments pris en charge.

**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. Renvoyé lorsque `text` n'est pas `None`.
- **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` et si `text` n'est pas `None`).
- **input_features** -- Caractéristiques d'entrée audio à fournir à un modèle. Renvoyé lorsque `audios` n'est pas `None`.

## SeamlessM4TCodeHifiGan[[transformers.SeamlessM4TCodeHifiGan]]

#### transformers.SeamlessM4TCodeHifiGan[[transformers.SeamlessM4TCodeHifiGan]]

```python
transformers.SeamlessM4TCodeHifiGan(config: SeamlessM4TConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L2123)

**Paramètres :**

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

Code du vocodeur HiFi-GAN tel que décrit dans ce [dépôt](https://github.com/facebookresearch/speech-resynthesis).

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

```python
forward(input_ids: LongTensor, spkr_id: Tensor, lang_id: Tensor, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L2199)

**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 [SeamlessM4TTextToUnitForConditionalGeneration](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TTextToUnitForConditionalGeneration). [Que sont les identifiants d'entrée ?](../glossary#input-ids)

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

tgt_lang (`str`, *facultatif*) : L'identifiant de langue à utiliser comme langue cible pour la traduction.

## SeamlessM4THifiGan[[transformers.SeamlessM4THifiGan]]

#### transformers.SeamlessM4THifiGan[[transformers.SeamlessM4THifiGan]]

```python
transformers.SeamlessM4THifiGan(config: SeamlessM4TConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L2046)

#### forward[[transformers.SeamlessM4THifiGan.forward]]

```python
forward(inputs_embeds: Tensor)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L2081)

**Paramètres :**

spectrogram (`torch.Tensor`) : Tenseur contenant les spectrogrammes log-mel. Peut être groupé (batched) et de forme `(batch_size, sequence_length, model_in_dim)`, ou non groupé et de forme `(sequence_length, model_in_dim)`. Notez que `model_in_dim` est la somme de `config.unit_embed_dim`, `config.lang_embed_dim` et `config.spkr_embed_dim`.

**Retourne :** `torch.Tensor`

Tenseur contenant la forme d’onde de la parole. Si le spectrogramme d’entrée est groupé (batched), il aura la forme `(batch_size, num_frames,)`. S’il n’est pas groupé, il aura la forme `(num_frames,)`.

Convertit un spectrogramme log-mel en forme d’onde vocale. Le passage d’un lot de spectrogrammes log-mel renvoie un lot de formes d’onde vocales. Le passage d’un spectrogramme log-mel unique, non lotisé, renvoie une forme d’onde vocale unique, non lotisée.

## SeamlessM4TTextToUnitModel[[transformers.SeamlessM4TTextToUnitModel]]

#### transformers.SeamlessM4TTextToUnitModel[[transformers.SeamlessM4TTextToUnitModel]]

```python
transformers.SeamlessM4TTextToUnitModel(config: SeamlessM4TConfig, embed_tokens_decoder: typing.Optional[torch.nn.Embedding] = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L1753)

**Paramètres :**

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

embed_tokens_decoder (`nn.Embedding`, *facultatif*) : embedding d'entrée du décodeur.

Transformateur texte brut vers unité, encodeur-décodeur. L’encodeur est un `SeamlessM4TEncoder` sans embeddings et le décodeur est un `SeamlessM4TDecoder`.

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.SeamlessM4TTextToUnitModel.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, 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/modeling_seamless_m4t.py#L1771)

**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. [Quelles sont les identifiants d'entrée du décodeur ?](../glossary#decoder-input-ids)

decoder_attention_mask (`torch.LongTensor` de forme `(batch_size, target_sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention à certains indices de jetons. Par défaut, un masque causal est utilisé afin de s'assurer que le modèle ne peut consulter que les entrées précédentes pour prédire le futur.

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 manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle.

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

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

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

La méthode forward du modèle [SeamlessM4TTextToUnitModel](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TTextToUnitModel) redéfinit la méthode spéciale `__call__`.

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

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

  Si `past_key_values` est utilisé, seule la dernière hidden-state des séquences de forme `(batch_size, 1, hidden_size)` est renvoyée.
- **past_key_values** (`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 d'incorporation initiale facultatives.
- **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 d'incorporation initiales facultatives.
- **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.

## SeamlessM4TTextToUnitForConditionalGeneration[[transformers.SeamlessM4TTextToUnitForConditionalGeneration]]

#### transformers.SeamlessM4TTextToUnitForConditionalGeneration[[transformers.SeamlessM4TTextToUnitForConditionalGeneration]]

```python
transformers.SeamlessM4TTextToUnitForConditionalGeneration(config: SeamlessM4TConfig, embed_tokens_decoder: typing.Optional[torch.nn.Embedding] = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seamless_m4t/modeling_seamless_m4t.py#L1832)

**Paramètres :**

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

embed_tokens_decoder (`nn.Embedding`, *facultatif*) : embedding d'entrée du décodeur.

Encodeur-décodeur texte-vers-unité Transformer avec une tête de modèle de langage. Le modèle encodeur-décodeur de base est un `SeamlessM4TTextToUnit`.

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.SeamlessM4TTextToUnitForConditionalGeneration.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/modeling_seamless_m4t.py#L1876)

**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 en fonction de la configuration ([SeamlessM4TConfig](/docs/transformers/v5.23.0/fr/model_doc/seamless_m4t#transformers.SeamlessM4TConfig)) et des entrées.

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

