Hugging Face's logo

Transformers documentation

SeamlessM4T

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Ce modèle a été publié dans HF papers le 2023-08-22 et contribué à Hugging Face Transformers le 2023-10-23.

SDPA

SeamlessM4T

Aperçu

Le modèle SeamlessM4T a été proposé dans SeamlessM4T — Massively Multilingual & Multimodal Machine Translation 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.

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 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 ? Alors que 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. Ensuite, nous avons 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 à l’état de l’art 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 critique, 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 à https://github.com/facebookresearch/seamless_communication

Utilisation

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

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 :

# 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 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 :

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(). Cette fois, traduisons en français.

# 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 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 l’exemple 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 :

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.

from transformers import SeamlessM4TForTextToText


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

N'hésitez pas à essayer également SeamlessM4TForSpeechToText et 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 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 pour renvoyer à la fois la parole et le texte !

Architecture du modèle

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

Chaque modalité dispose de son propre encodeur doté d'une architecture unique. De plus, pour la sortie vocale, un vocoder inspiré de l'architecture HiFi-GAN 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. Le code d’origine est disponible ici.

SeamlessM4TModel

classe transformers.SeamlessM4TModel

< >

( config: SeamlessM4TConfigcurrent_modality = 'text' )

Paramètres

  • config (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() pour charger les poids du modèle.
  • current_modality (str, facultatif, 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. 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, la taille des têtes, etc.)

Ce modèle est également une sous-classe de 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

< >

( input_ids: typing.Optional[torch.Tensor] = Noneinput_features: typing.Optional[torch.Tensor] = Nonereturn_intermediate_token_ids: bool | None = Nonetgt_lang: str | None = Nonespkr_id: int | None = 0generate_speech: bool | None = True**kwargs ) → Union[SeamlessM4TGenerationOutput, tuple[Tensor], ModelOutput]

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 ou de SeamlessM4TProcessor. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails. Que sont les identifiants d'entrée ?

    Les indices peuvent être obtenus à l'aide de SeamlessM4TTokenizer ou de SeamlessM4TProcessor. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • input_features (torch.Tensor de forme (batch_size, sequence_length, num_banks), facultatif) — Fonctions audio d’entrée. Elles doivent être renvoyées par la classe SeamlessM4TFeatureExtractor ou la classe SeamlessM4TProcessor. Voir 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, valeur 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(). Les arguments par mot-clé sont de deux types : sans préfixe, ils sont passés en tant que **kwargs à la méthode generate de chaque sous-modèle, à l'exception de decoder_input_ids qui n'est transmise que par les composants texte. Avec un préfixe text_ ou speech_, ils sont transmis respectivement à la méthode generate du modèle texte et du modèle vocal. 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.
    • Sans préfixe, ils seront transmis en tant que **kwargs à la méthode generate de chaque sous-modèle, à l'exception de decoder_input_ids, qui ne sera transmise que par les composants texte.
    • Avec un préfixe text_ ou speech_, ils seront respectivement les entrées de la méthode generate du modèle de texte et du modèle de parole. 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 est utilisé et que 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.
  • 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 différents : 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.

SeamlessM4TForTextToSpeech

classe transformers.SeamlessM4TForTextToSpeech

< >

( config: SeamlessM4TConfig )

Paramètres

  • config (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() 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. 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, la taille des têtes, etc.)

Ce modèle est également une sous-classe de 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

< >

( input_ids: typing.Optional[torch.Tensor] = Nonereturn_intermediate_token_ids: bool | None = Nonetgt_lang: str | None = Nonespkr_id: int | None = 0**kwargs ) → Union[SeamlessM4TGenerationOutput, tuple[Tensor]]

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 ou SeamlessM4TProcessor. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails. Que sont les identifiants d'entrée ?

    Les indices peuvent être obtenus à l'aide de SeamlessM4TTokenizer ou de SeamlessM4TProcessor. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • return_intermediate_token_ids (bool, facultatif) — Si True, renvoie également le texte généré intermédiaire et les jetons unitaires. Définissez cette valeur 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(). Les arguments par mot-clé sont de deux types : sans préfixe, ils sont passés en tant que **kwargs à la méthode generate de chaque sous-modèle, à l'exception de decoder_input_ids qui n'est transmise que par les composants texte. Avec un préfixe text_ ou speech_, ils sont transmis respectivement à la méthode generate du modèle texte et du modèle vocal. 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.
    • Sans préfixe, ils seront transmis en tant que **kwargs à la méthode generate de chaque sous-modèle, à l'exception de decoder_input_ids, qui ne sera transmise que par les composants texte.
    • Avec un préfixe text_ ou speech_, ils seront respectivement les entrées de la méthode generate du modèle de texte et du modèle de parole. 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 différents : 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) 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.

SeamlessM4TForSpeechToSpeech

classe transformers.SeamlessM4TForSpeechToSpeech

< >

( config: SeamlessM4TConfig )

Paramètres

  • config (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() 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. 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, la taille des têtes, etc.)

Ce modèle est également une sous-classe de 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

< >

( input_features: typing.Optional[torch.Tensor] = Nonereturn_intermediate_token_ids: bool | None = Nonetgt_lang: str | None = Nonespkr_id: int | None = 0**kwargs ) → Union[SeamlessM4TGenerationOutput, tuple[Tensor]]

Paramètres

  • input_features (torch.Tensor de forme (batch_size, sequence_length, num_banks)) — Fonctions audio d'entrée. Elles doivent être renvoyées par la classe SeamlessM4TFeatureExtractor ou la classe SeamlessM4TProcessor. Voir 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 unitaires. Définissez cette valeur 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(). Les arguments par mot-clé sont de deux types : sans préfixe, ils sont passés en tant que **kwargs à la méthode generate de chaque sous-modèle, à l'exception de decoder_input_ids qui n'est transmise que par les composants texte. Avec un préfixe text_ ou speech_, ils sont transmis respectivement à la méthode generate du modèle texte et du modèle vocal. 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.
    • Sans préfixe, ils seront transmis en tant que **kwargs à la méthode generate de chaque sous-modèle, à l'exception de decoder_input_ids, qui ne sera transmise que par les composants texte.
    • Avec un préfixe text_ ou speech_, ils seront respectivement les entrées de la méthode generate du modèle de texte et du modèle de parole. 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 différents : 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.

SeamlessM4TForTextToText

classe transformers.SeamlessM4TForTextToText

< >

( config: SeamlessM4TConfig )

Paramètres

  • config (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() 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. 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, la taille des têtes, etc.)

Ce modèle est également une sous-classe de 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

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Seq2SeqLMOutput or tuple(torch.Tensor)

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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • 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 masqués.

    Qu'est-ce que les masques d'attention ?

  • 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 d'AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails. Que sont les IDs d'entrée du décodeur ? 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éera ce tenseur en décalant input_ids vers la droite pour la pré-formation par débruitage, conformément à l'article.

    Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Quelles sont les identifiants d'entrée du décodeur ?

    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 le dernier decoder_input_ids (voir past_key_values).

    Pour l’entraînement à la traduction et à la résumée, 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 la pré-formation 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 le modifier selon vos besoins. Consultez la figure 1 de l'article pour plus d'informations sur la stratégie par défaut.

    Si vous souhaitez modifier le comportement du padding, vous devez lire modeling_bart._prepare_decoder_attention_mask et l’adapter à vos besoins. Consultez la figure 1 de l’article 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 d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en la past_key_values retournée 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 est autorisée en entrée, consultez notre guide du cache kv. Si aucun past_key_values n'est transmis, DynamicCache sera initialisé par défaut.

    Le modèle produira le même format de cache qui est 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 n’ont pas été 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) — Facultatif, 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 conversion des input_ids indices en vecteurs associés que 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 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 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é, facultativement, seules les dernières decoder_inputs_embeds doivent être entrées (voir past_key_values). Cela est utile si vous souhaitez un meilleur contrôle sur la conversion des decoder_input_ids indices en vecteurs associés que 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 dans [0, ..., config.vocab_size] ou -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 dans [0, ..., config.vocab_size].
  • use_cache (bool, facultatif) — Si défini sur True, les états clé-valeur past_key_values sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir past_key_values).

Retourne

Seq2SeqLMOutput ou tuple(torch.Tensor)

Un 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) et des entrées.

La méthode forward de 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. Pour plus de détails, consultez notre guide sur le cache kv.

    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

< >

( input_ids = Nonetgt_lang = Nonegeneration_config = Nonelogits_processor = Nonestopping_criteria = Noneprefix_allowed_tokens_fn = Nonesynced_gpus = False**kwargs ) → ModelOutput or torch.LongTensor

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 ou de SeamlessM4TProcessor. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • 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 transmis à 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, 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 construits à 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 fourni, cette fonction contraint la recherche par faisceau aux jetons autorisés uniquement à chaque étape. Si non fourni, 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 générés précédemment 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.
  • 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 les blocages 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 ou torch.LongTensor

Un ModelOutput (si return_dict_in_generate=True ou lorsque config.return_dict_in_generate=True) ou un torch.Tensor. Les types ModelOutput possibles sont :

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 défini 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.

SeamlessM4TForSpeechToText

classe transformers.SeamlessM4TForSpeechToText

< >

( config: SeamlessM4TConfig )

Paramètres

  • config (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() 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. 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, la taille des têtes, etc.)

Ce modèle est également une sous-classe de 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

< >

( input_features: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Seq2SeqLMOutput or tuple(torch.Tensor)

Paramètres

  • input_features (torch.Tensor de forme (batch_size, sequence_length, num_banks)) — Fonctions audio d'entrée. Elles doivent être renvoyées par la classe SeamlessM4TFeatureExtractor ou la classe SeamlessM4TProcessor. Voir 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 masqués.

    Qu'est-ce que les masques d'attention ?

  • 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 d'AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails. Que sont les IDs d'entrée du décodeur ? 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éera ce tenseur en décalant input_ids vers la droite pour la pré-formation par débruitage, conformément à l'article.

    Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Quelles sont les identifiants d'entrée du décodeur ?

    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 le dernier decoder_input_ids (voir past_key_values).

    Pour l’entraînement à la traduction et à la résumée, 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 la pré-formation 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 le modifier selon vos besoins. Consultez la figure 1 de l'article pour plus d'informations sur la stratégie par défaut.

    Si vous souhaitez modifier le comportement du padding, vous devez lire modeling_bart._prepare_decoder_attention_mask et l’adapter à vos besoins. Consultez la figure 1 de l’article 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 d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en la past_key_values retournée 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 est autorisée en entrée, consultez notre guide du cache kv. Si aucun past_key_values n'est transmis, DynamicCache sera initialisé par défaut.

    Le modèle produira le même format de cache qui est 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 n’ont pas été 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) — Facultatif, 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 conversion des input_ids indices en vecteurs associés que 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 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 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é, facultativement, seules les dernières decoder_inputs_embeds doivent être entrées (voir past_key_values). Cela est utile si vous souhaitez un meilleur contrôle sur la conversion des decoder_input_ids indices en vecteurs associés que 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 dans [0, ..., config.vocab_size] ou -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 dans [0, ..., config.vocab_size].
  • use_cache (bool, facultatif) — Si défini sur True, les états clé-valeur past_key_values sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir past_key_values).

Retourne

Seq2SeqLMOutput ou tuple(torch.Tensor)

Un 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) et des entrées.

La méthode forward de 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. Pour plus de détails, consultez notre guide sur le cache kv.

    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 :

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

< >

( input_features = Nonetgt_lang = Nonegeneration_config = Nonelogits_processor = Nonestopping_criteria = Noneprefix_allowed_tokens_fn = Nonesynced_gpus = False**kwargs ) → ModelOutput or torch.LongTensor

Paramètres

  • input_features (torch.Tensor de forme (batch_size, sequence_length, num_banks)) — Fonctions audio d'entrée. Elles doivent être renvoyées par la classe SeamlessM4TFeatureExtractor ou la classe SeamlessM4TProcessor. Voir 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 transmis à 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, 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 construits à 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 fourni, cette fonction contraint la recherche par faisceau aux jetons autorisés uniquement à chaque étape. Si non fourni, 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 générés précédemment 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.
  • 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 les blocages 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 ou torch.LongTensor

Un ModelOutput (si return_dict_in_generate=True ou lorsque config.return_dict_in_generate=True) ou un torch.Tensor. Les types ModelOutput possibles sont :

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 défini 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.

SeamlessM4TConfig

classe transformers.SeamlessM4TConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0id2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneis_encoder_decoder: bool = Truevocab_size: int = 256102t2u_vocab_size: int = 10082hidden_size: int = 1024initializer_range: float = 0.02layer_norm_eps: float = 1e-05use_cache: bool = Truemax_position_embeddings: int = 1024encoder_layerdrop: float | int = 0.05decoder_layerdrop: float | int = 0.05activation_function: str = 'relu'dropout: float | int = 0.1attention_dropout: float | int = 0.1activation_dropout: float | int = 0.0scale_embedding: bool = Trueencoder_layers: int = 24encoder_ffn_dim: int = 8192encoder_attention_heads: int = 16decoder_layers: int = 24decoder_ffn_dim: int = 8192decoder_attention_heads: int = 16decoder_start_token_id: int = 3max_new_tokens: int | None = 256pad_token_id: int | None = 0bos_token_id: int | None = 2eos_token_id: int | list[int] | None = 3speech_encoder_layers: int = 24speech_encoder_attention_heads: int = 16speech_encoder_intermediate_size: int = 4096speech_encoder_hidden_act: str = 'swish'speech_encoder_dropout: float | int = 0.0add_adapter: bool = Truespeech_encoder_layerdrop: float | int = 0.1feature_projection_input_dim: int = 160num_conv_pos_embeddings: int = 128num_conv_pos_embedding_groups: int = 16adaptor_kernel_size: int = 8adaptor_stride: int = 8adaptor_dropout: float | int = 0.1num_adapter_layers: int = 1position_embeddings_type: str = 'relative'rotary_embedding_base: int = 10000max_source_positions: int = 4096conv_depthwise_kernel_size: int = 31t2u_bos_token_id: int | None = 0t2u_pad_token_id: int | None = 1t2u_eos_token_id: int | list[int] | None = 2t2u_decoder_start_token_id: int = 2t2u_max_new_tokens: int = 1024t2u_encoder_layers: int = 6t2u_encoder_ffn_dim: int = 8192t2u_encoder_attention_heads: int = 16t2u_decoder_layers: int = 6t2u_decoder_ffn_dim: int = 8192t2u_decoder_attention_heads: int = 16t2u_max_position_embeddings: int = 2048sampling_rate: int = 16000upsample_initial_channel: int = 512upsample_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.1unit_hifi_gan_vocab_size: int = 10000unit_embed_dim: int = 1280lang_embed_dim: int = 256spkr_embed_dim: int = 256vocoder_num_langs: int = 36vocoder_num_spkrs: int = 200variance_predictor_kernel_size: int = 3var_pred_dropout: float | int = 0.5vocoder_offset: int = 4tie_word_embeddings: bool = True )

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, 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, valeur par défaut 10082) — Taille du vocabulaire unitaire du modèle SeamlessM4T. Définit le nombre de jetons unitaires 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, ~SeamlessM4TForSpeechToSpeech ou ~SeamlessM4TForTextToSpeech.
  • hidden_size (int, facultatif, par défaut 1024) — Dimension des représentations cachées.
  • initializer_range (float, facultatif, par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser 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). N’est pertinent que si config.is_decoder=True ou si le modèle est un modèle génératif uniquement décodeur.
  • max_position_embeddings (int, facultatif, 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. Voir l'article [LayerDrop](voir https://huggingface.co/papers/1909.11556) pour plus de détails.
  • decoder_layerdrop (Union[float, int], facultatif, valeur par défaut 0.05) — Probabilité de LayerDrop pour le décodeur. Voir l’article [LayerDrop](voir https://huggingface.co/papers/1909.11556) pour plus de détails.
  • activation_function (str, facultatif, par défaut relu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, "gelu", "relu", "silu", etc.
  • dropout (Union[float, int], facultatif, par défaut 0.1) — Le taux appliqué à 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 appliqué aux activations à l'intérieur de la couche entièrement connectée.
  • scale_embedding (bool, facultatif, 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) de 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, par défaut 0) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire.
  • bos_token_id (int, facultatif, par défaut 2) — Identifiant du jeton utilisé pour le début de flux dans le vocabulaire.
  • eos_token_id (Union[int, list[int]], facultatif, par défaut 3) — Identifiant du jeton utilisé pour la fin de flux dans le vocabulaire.
  • speech_encoder_layers (int, facultatif, par défaut 24) — Nombre de couches cachées dans l'encodeur vocal 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) du codeur vocal Transformer.
  • speech_encoder_hidden_act (str ou function, facultatif, valeur par défaut "swish") — Fonction d'activation non linéaire (fonction ou chaîne de caractères) dans l'encodeur vocal. 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) — Probabilité de dropout pour toutes les couches de l'encodeur vocal.
  • add_adapter (bool, facultatif, par défaut True) — Ajoute une couche d'adaptateur au-dessus de l'encodeur audio.
  • speech_encoder_layerdrop (float, facultatif, valeur par défaut 0.1) — Probabilité de LayerDrop pour l'encodeur de la parole. Consultez l'article [LayerDrop](voir 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éristiques d'entrée de l'encodeur audio, c'est-à-dire la dimension après le traitement des audios d'entrée avec SeamlessM4TFeatureExtractor.
  • num_conv_pos_embeddings (int, facultatif, valeur par défaut : 128) — Nombre d'embeddings positionnels convolutifs. Définit la taille du noyau de la couche d'embeddings positionnels convolutifs 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. N'est pertinent que si add_adapter is True.
  • adaptor_stride (int, facultatif, valeur par défaut : 8) — Pas des couches de convolution dans le réseau adaptateur. Ne concerne que le cas où add_adapter is True.
  • adaptor_dropout (float, facultatif, valeur par défaut 0.1) — 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 d'adaptateur. Ne concerne que le cas où add_adapter is True.
  • position_embeddings_type (str, facultatif, par défaut "relative") — Peut être défini sur relative ou rotary pour utiliser respectivement des embeddings de position relatifs ou rotatifs. S'il est laissé à None, aucun embedding de position relatif n'est appliqué. S'applique 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 depthwise 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 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 end-of-stream. Appliqué uniquement au modèle seq2seq texte-vers-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. feed-forward) dans 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, par défaut 6) — Nombre de couches cachées dans le décodeur texte-vers-unité du 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é 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 le composant texte-vers-unité de ce 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, par défaut 16000) — La fréquence d'échantillonnage à laquelle les fichiers audio doivent être numérisés, exprimée en hertz (Hz).
  • upsample_initial_channel (int, facultatif, valeur par défaut : 512) — Le nombre de canaux d'entrée du réseau d'interpolation (upsampling) hifi-gan. S'applique uniquement au vocoder.
  • upsample_rates (tuple[int] ou list[int], facultatif, par défaut [5, 4, 4, 2, 2]) — Un tuple d'entiers définissant le pas de chaque couche de convolution 1D dans le réseau de suréchantillonnage 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, par défaut [11, 8, 8, 4, 4]) — Un tuple d'entiers définissant la taille du noyau de chaque couche de convolution 1D du réseau de suréchantillonnage 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, 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-champ 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 vocodeur dans le module de fusion multi-récepteur (MRF). S'applique uniquement au vocodeur.
  • 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 unitaires distincts qui peuvent être représentés par les inputs_ids passés lors de l'appel du vocodeur de ~SeamlessM4TModel, ~SeamlessM4TForSpeechToSpeech ou ~SeamlessM4TForTextToSpeech.
  • unit_embed_dim (int, facultatif, valeur par défaut 1280) — Dimension de projection des identifiants d'entrée fournis au vocodeur hifi-gan. S'applique uniquement au vocodeur.
  • lang_embed_dim (int, facultatif, 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) — 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 vocoder.
  • tie_word_embeddings (bool, facultatif, 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

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

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

classe transformers.SeamlessM4TTokenizer

< >

( vocab: str | dict[str, int] | None = Nonemerges: str | list[str] | None = Nonebos_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 = Nonekeep_accents = Nonevocab_file = None**kwargs )

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 des règles de fusion pour le modèle BPE. Si non fournie, utilise une liste vide.
  • bos_token (str, facultatif, défaut "<s>") — Le 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 ce jeton qui est utilisé pour le début de la séquence. Le jeton utilisé est cls_token.

  • eos_token (str, facultatif, défaut : "</s>") — Le 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 sep_token.

    Lors de la construction d'une séquence à l'aide de jetons spéciaux, ce n'est pas ce jeton qui est utilisé pour la fin de séquence. Le jeton utilisé est le sep_token.

  • sep_token (str, facultatif, 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, par défaut "<s>") — Le jeton de classification 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 regroupement de séquences de longueurs différentes.
  • src_lang (str, facultatif, 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.

Ce tokenizer hérite de TokenizersBackend, qui contient la plupart des méthodes principales. Les utilisateurs doivent se référer à cette superclasse 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 <eos> <language code> <tokens> <eos> pour les documents de la langue cible.

Exemples :

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

__call__

< >

( text: str | list[str] | list[list[str]] | None = Nonetext_pair: str | list[str] | list[list[str]] | None = Nonetext_target: str | list[str] | list[list[str]] | None = Nonetext_pair_target: str | list[str] | list[list[str]] | None = Nonepadding: bool | str | transformers.utils.generic.PaddingStrategy = Falsepad_to_multiple_of: int | None = Nonesrc_lang: str | None = Nonetgt_lang: str | None = None**kwargs )

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, facultatif, 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 les options suivantes :
    • True ou 'longest' : Ajuster à la séquence la plus longue du lot (ou aucun ajustement si une seule séquence est fournie).
    • 'max_length' : Remplir jusqu'à une longueur maximale spécifiée par 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 produire 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 est rembourrée jusqu'à un multiple de la valeur fournie.

    C'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 (que ce soit lors de l'initialisation ou 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 (que ce soit lors de l'initialisation ou lors de l'appel de ce tokenizer) sera utilisée.
  • kwargs (facultatif) — Dictionnaire restant d'arguments par mot-clé qui sera transmis à TokenizersBackend.call().

get_special_tokens_mask

< >

( token_ids_0: list[int]token_ids_1: list[int] | None = Nonealready_has_special_tokens: bool = False ) → A list of integers in the range [0, 1]

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 pour 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

< >

( save_directory: strfilename_prefix: str | None = None )

SeamlessM4TFeatureExtractor

classe transformers.SeamlessM4TFeatureExtractor

< >

( feature_size = 80sampling_rate = 16000num_mel_bins = 80padding_value = 0.0stride = 2**kwargs )

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) — La fréquence d'échantillonnage à laquelle les fichiers audio doivent être numérisés, exprimée 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 fonctionnalités hérite de SequenceFeatureExtractor, qui contient la plupart des méthodes principales. Les utilisateurs doivent se référer à 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.

__call__

< >

( raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]]padding: bool | str | transformers.utils.generic.PaddingStrategy = Truepad_to_multiple_of: int | None = 2max_length: int | None = Nonetruncation: bool = Falsereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonesampling_rate: int | None = Nonereturn_attention_mask: bool | None = Nonedo_normalize_per_mel_bins: bool | None = True**kwargs )

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, facultatif, 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' : Ajuster à la séquence la plus longue du lot (ou aucun ajustement si une seule séquence est fournie).
    • 'max_length' : Remplir jusqu'à une longueur maximale spécifiée par 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 produire 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 est rembourrée jusqu'à un multiple de la valeur fournie.

    Ceci 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 d'avoir des longueurs de séquence qui sont un multiple 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 ?

    Pour les modèles SeamlessM4T, attention_mask doit toujours être transmis lors de l'inférence par lot, afin d'éviter des bugs subtils.

  • return_tensors (str ou TensorType, facultatif) — Si défini, renvoie des tenseurs au lieu d'une liste d'entiers Python. Les valeurs acceptées sont :
    • 'pt' : Renvoie des objets torch.Tensor de PyTorch.
    • 'np' : Renvoie des objets Numpy np.ndarray.
  • sampling_rate (int, facultatif) — La fréquence d’échantillonnage à laquelle 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

classe transformers.SeamlessM4TProcessor

< >

( feature_extractortokenizer )

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 offre toutes les fonctionnalités de SeamlessM4TFeatureExtractor et de SeamlessM4TTokenizer. Consultez ~SeamlessM4TFeatureExtractor et ~SeamlessM4TTokenizer pour plus d'informations.

__call__

< >

( text: str | list[str] | list[list[str]] | None = Noneaudio: 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'> ) → BatchEncoding

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 de caractères (chaînes pré-tokenisées). Si vous passez 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/tenseur PyTorch, chaque audio doit avoir la forme (C, T), où C est le nombre de canaux et T est la longueur d’échantillonnage de l’audio.
  • return_tensors (str ou TensorType, facultatif) — Si défini, renvoie des tenseurs d'un framework particulier. Les valeurs acceptées sont :
    • 'pt' : Renvoie des objets torch.Tensor de PyTorch.
    • 'np' : Renvoie des objets NumPy np.ndarray.
  • **kwargs (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

Un BatchEncoding avec les champs suivants :

  • input_ids — Liste des identifiants de jetons à fournir à un 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

classe transformers.SeamlessM4TCodeHifiGan

< >

( config: SeamlessM4TConfig )

Paramètres

  • config (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() pour charger les poids du modèle.

Code du vocodeur HiFi-GAN tel que décrit dans ce dépôt.

Ce modèle hérite de 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, la taille des têtes, etc.)

Ce modèle est également une sous-classe de 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

< >

( input_ids: LongTensorspkr_id: Tensorlang_id: Tensor**kwargs )

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. Que sont les identifiants d'entrée ?

  • 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

classe transformers.SeamlessM4THifiGan

< >

( config: SeamlessM4TConfig )

forward

< >

( inputs_embeds: Tensor ) → torch.Tensor

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 loti, renvoie une forme d’onde vocale unique, non lotie.

SeamlessM4TTextToUnitModel

classe transformers.SeamlessM4TTextToUnitModel

< >

( config: SeamlessM4TConfigembed_tokens_decoder: typing.Optional[torch.nn.Embedding] = None )

Paramètres

  • config (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() pour charger les poids du modèle.
  • embed_tokens_decoder (nn.Embedding, facultatif) — matrice d'incorporation 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. 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, la taille des têtes, etc.)

Ce modèle est également une sous-classe de 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

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Seq2SeqModelOutput or tuple(torch.Tensor)

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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • 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 masqués.

    Qu'est-ce que les masques d'attention ?

  • 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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Quelles sont les identifiants d'entrée du décodeur ?

  • decoder_attention_mask (torch.LongTensor de forme (batch_size, target_sequence_length), facultatif) — Masque pour éviter d’effectuer l’attention sur certains indices de jetons. Par défaut, un masque causal est utilisé afin de s’assurer que le modèle ne peut regarder 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 d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en la past_key_values retournée 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 est autorisée en entrée, consultez notre guide du cache kv. Si aucun past_key_values n'est transmis, DynamicCache sera initialisé par défaut.

    Le modèle produira le même format de cache qui est 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 n’ont pas été 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 que 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é, facultativement, seules les dernières decoder_inputs_embeds doivent être entrées (voir past_key_values). Cela est utile si vous souhaitez un meilleur contrôle sur la conversion des decoder_input_ids indices en vecteurs associés que 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 past_key_values sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir past_key_values).

Retourne

Seq2SeqModelOutput ou tuple(torch.Tensor)

Un Seq2SeqModelOutput 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) et des entrées.

La méthode forward du modèle 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. Pour plus de détails, consultez notre guide sur le cache kv.

    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

classe transformers.SeamlessM4TTextToUnitForConditionalGeneration

< >

( config: SeamlessM4TConfigembed_tokens_decoder: typing.Optional[torch.nn.Embedding] = None )

Paramètres

  • config (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() pour charger les poids du modèle.
  • embed_tokens_decoder (nn.Embedding, facultatif) — matrice d'incorporation 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. 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, la taille des têtes, etc.)

Ce modèle est également une sous-classe de 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

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Seq2SeqLMOutput or tuple(torch.Tensor)

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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • 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 masqués.

    Qu'est-ce que les masques d'attention ?

  • 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 d'AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails. Que sont les IDs d'entrée du décodeur ? 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éera ce tenseur en décalant input_ids vers la droite pour la pré-formation par débruitage, conformément à l'article.

    Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Quelles sont les identifiants d'entrée du décodeur ?

    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 le dernier decoder_input_ids (voir past_key_values).

    Pour l’entraînement à la traduction et à la résumée, 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 la pré-formation 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 le modifier selon vos besoins. Consultez la figure 1 de l'article pour plus d'informations sur la stratégie par défaut.

    Si vous souhaitez modifier le comportement du padding, vous devez lire modeling_bart._prepare_decoder_attention_mask et l’adapter à vos besoins. Consultez la figure 1 de l’article 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 d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en la past_key_values retournée 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 est autorisée en entrée, consultez notre guide du cache kv. Si aucun past_key_values n'est transmis, DynamicCache sera initialisé par défaut.

    Le modèle produira le même format de cache qui est 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 n’ont pas été 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) — Facultatif, 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 conversion des input_ids indices en vecteurs associés que 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 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 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é, facultativement, seules les dernières decoder_inputs_embeds doivent être entrées (voir past_key_values). Cela est utile si vous souhaitez un meilleur contrôle sur la conversion des decoder_input_ids indices en vecteurs associés que 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 dans [0, ..., config.vocab_size] ou -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 dans [0, ..., config.vocab_size].
  • use_cache (bool, facultatif) — Si défini sur True, les états clé-valeur past_key_values sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir past_key_values).

Retourne

Seq2SeqLMOutput ou tuple(torch.Tensor)

Un 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) et des entrées.

La méthode forward de 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. Pour plus de détails, consultez notre guide sur le cache kv.

    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.

Update on GitHub

←Qwen3 ASR SeamlessM4T-v2→