Hugging Face's logo

Transformers documentation

Wav2Vec2-BERT

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.2).
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-12-08 et ajouté à Hugging Face Transformers le 2024-01-18.

SDPA

Wav2Vec2-BERT

Aperçu

Le modèle Wav2Vec2-BERT a été proposé dans Seamless: Multilingual Expressive and Streaming Speech Translation par l'équipe Seamless Communication de Meta AI.

Ce modèle a été pré-entraîné sur 4,5 millions d’heures de données audio non étiquetées couvrant plus de 143 langues. Il nécessite un affinement pour être utilisé sur des tâches en aval telles que la reconnaissance automatique de la parole (ASR) ou la classification audio.

Les résultats officiels du modèle peuvent être consultés dans la section 3.2.1 de l’article.

L'abstract de l'article est le suivant :

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

Ce modèle a été contribué par ylacombe. Le code d’origine est disponible ici.

Conseils d'utilisation

  • Wav2Vec2-BERT suit la même architecture que Wav2Vec2-Conformer, mais emploie une couche de convolution causale en profondeur et utilise comme entrée une représentation en spectrogramme mélo de l’audio au lieu de la forme d’onde brute.
  • Wav2Vec2-BERT peut utiliser soit aucun encodage de position relatif, soit des encodages de position de type Shaw, soit des encodages de position de type Transformer-XL, soit des encodages de position rotatifs, en définissant la valeur appropriée de config.position_embeddings_type.
  • Wav2Vec2-BERT introduit également un réseau adaptateur basé sur Conformer plutôt qu'un simple réseau convolutif.

Ressources

Automatic Speech Recognition
Audio Classification

Wav2Vec2BertConfig

classe transformers.Wav2Vec2BertConfig

< >

( 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 = 0is_encoder_decoder: bool = Falseid2label: 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 = Nonevocab_size: int | None = Nonehidden_size: int = 1024num_hidden_layers: int = 24num_attention_heads: int = 16intermediate_size: int = 4096feature_projection_input_dim: int = 160hidden_act: str = 'swish'hidden_dropout: float | int = 0.0activation_dropout: float | int = 0.0attention_dropout: float | int = 0.0feat_proj_dropout: float | int = 0.0final_dropout: float | int = 0.1layerdrop: float | int = 0.1initializer_range: float = 0.02layer_norm_eps: float = 1e-05apply_spec_augment: bool = Truemask_time_prob: float | int = 0.05mask_time_length: int = 10mask_time_min_masks: int = 2mask_feature_prob: float | int = 0.0mask_feature_length: int = 10mask_feature_min_masks: int = 0ctc_loss_reduction: str = 'sum'ctc_zero_infinity: bool = Falseuse_weighted_layer_sum: bool = Falseclassifier_proj_size: int = 768tdnn_dim: list[int] | tuple[int, ...] = (512, 512, 512, 512, 1500)tdnn_kernel: list[int] | tuple[int, ...] = (5, 3, 3, 1, 1)tdnn_dilation: list[int] | tuple[int, ...] = (1, 2, 3, 1, 1)xvector_output_dim: int = 512pad_token_id: int | None = 0bos_token_id: int | None = 1eos_token_id: int | list[int] | None = 2add_adapter: bool = Falseadapter_kernel_size: int = 3adapter_stride: int = 2num_adapter_layers: int = 1adapter_act: str = 'relu'use_intermediate_ffn_before_adapter: bool = Falseoutput_hidden_size: int | None = Noneposition_embeddings_type: typing.Optional[typing.Literal['rotary', 'relative', 'relative_key']] = 'relative_key'rotary_embedding_base: int = 10000max_source_positions: int = 5000left_max_position_embeddings: int = 64right_max_position_embeddings: int = 8conv_depthwise_kernel_size: int = 31conformer_conv_dropout: float | int = 0.1 )

Paramètres

  • vocab_size (int, facultatif) — Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par input_ids.
  • hidden_size (int, facultatif, par défaut 1024) — Dimension des représentations cachées.
  • num_hidden_layers (int, facultatif, par défaut 24) — Nombre de couches cachées dans le décodeur Transformer.
  • num_attention_heads (int, facultatif, valeur par défaut 16) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.
  • intermediate_size (int, facultatif, par défaut 4096) — Dimension des représentations du MLP.
  • feature_projection_input_dim (int, facultatif, valeur par défaut 160) — Dimension d’entrée de ce modèle, c’est-à-dire la dimension après traitement des audios d’entrée avec SeamlessM4TFeatureExtractor ou Wav2Vec2BertProcessor.
  • hidden_act (str, facultatif, par défaut swish) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, "gelu", "relu", "silu", etc.
  • hidden_dropout (Union[float, int], facultatif, valeur par défaut 0.0) — Probabilité de dropout pour toutes les couches entièrement connectées des embeddings, de l’encodeur et du pooler.
  • 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.
  • attention_dropout (Union[float, int], facultatif, valeur par défaut 0.0) — Le taux de dropout appliqué aux probabilités d'attention.
  • feat_proj_dropout (float, facultatif, valeur par défaut 0.0) — Probabilité de dropout pour la projection des caractéristiques.
  • final_dropout (float, facultatif, valeur par défaut 0.1) — Probabilité de dropout pour la couche de projection finale de Wav2Vec2BertForCTC.
  • layerdrop (Union[float, int], facultatif, par défaut 0.1) — La probabilité de LayerDrop. Consultez l'article [LayerDrop](voir https://huggingface.co/papers/1909.11556) pour plus de détails.
  • 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.
  • apply_spec_augment (bool, facultatif, par défaut True) — Indique s'il faut appliquer l'augmentation de données SpecAugment aux sorties de l'encodeur de caractéristiques. Pour référence, voir SpecAugment: A Simple Data Augmentation Method for Automatic Speech Recognition.
  • mask_time_prob (float, optional, defaults to 0.05) — Percentage (between 0 and 1) of all feature vectors along the time axis which will be masked. The masking procedure generates mask_time_prob*len(time_axis)/mask_time_length ``independent masks over the axis. If reasoning from the probability of each feature vector to be chosen as the start of the vector span to be masked, *mask_time_prob* should be prob_vector_start*mask_time_length. Note that overlap may decrease the actual percentage of masked vectors. This is only relevant if apply_spec_augment is True`.
  • mask_time_length (int, facultatif, valeur par défaut 10) — Longueur de la portée du vecteur le long de l'axe temporel.
  • mask_time_min_masks (int, facultatif, valeur par défaut : 2) — Le nombre minimal de masques de longueur mask_feature_length générés le long de l'axe temporel, à chaque pas de temps, indépendamment de mask_feature_prob. Ne concerne que le cas où mask_time_prob*len(time_axis)/mask_time_length < mask_time_min_masks.
  • mask_feature_prob (float, facultatif, valeur par défaut 0.0) — Pourcentage (compris entre 0 et 1) de tous les vecteurs de caractéristiques le long de l'axe des caractéristiques qui seront masqués. La procédure de masquage génère mask_feature_prob*len(feature_axis)/mask_time_length masques indépendants sur l'axe. Si l'on raisonne à partir de la probabilité que chaque vecteur de caractéristiques soit choisi comme début de la portée de vecteurs à masquer, mask_feature_prob doit être prob_vector_start*mask_feature_length. Notez que les chevauchements peuvent réduire le pourcentage réel de vecteurs masqués. Cela ne concerne que le cas où apply_spec_augment is True.
  • mask_feature_length (int, facultatif, valeur par défaut 10) — Longueur de la portée du vecteur le long de l'axe des caractéristiques.
  • mask_feature_min_masks (int, facultatif, valeur par défaut 0) — Nombre minimal de masques de longueur mask_feature_length générés le long de l’axe des caractéristiques, à chaque étape, indépendamment de mask_feature_prob. Ne concerne que le cas où mask_feature_prob*len(feature_axis)/mask_feature_length < mask_feature_min_masks.
  • ctc_loss_reduction (str, facultatif, par défaut sum) — Spécifie la réduction à appliquer à la sortie de torch.nn.CTCLoss. N'est pertinent que lors de l'entraînement.
  • ctc_zero_infinity (bool, facultatif, valeur par défaut False) — Indique s'il faut mettre à zéro les pertes infinies et les gradients associés de torch.nn.CTCLoss. Les pertes infinies surviennent principalement lorsque les entrées sont trop courtes pour être alignées sur les cibles. Ne concerne que l'entraînement d'une instance de Wav2Vec2BertForCTC.
  • use_weighted_layer_sum (bool, facultatif, valeur par défaut False) — Indique s'il faut utiliser une moyenne pondérée des sorties des couches avec des poids appris. Ne concerne que l'utilisation d'une instance de Wav2Vec2BertForSequenceClassification.
  • classifier_proj_size (int, facultatif, valeur par défaut : 768) — Dimension de la projection avant le pooling par moyenne des jetons pour la classification.
  • tdnn_dim (tuple[int] ou list[int], facultatif, par défaut (512, 512, 512, 512, 1500)) — Un tuple d'entiers définissant le nombre de canaux de sortie de chaque couche de convolution 1D du module TDNN du modèle XVector. La longueur de tdnn_dim définit le nombre de couches TDNN.
  • tdnn_kernel (tuple[int] ou list[int], facultatif, par défaut (5, 3, 3, 1, 1)) — Un tuple d'entiers définissant la taille du noyau de chaque couche convolutive 1D du module TDNN du modèle XVector. La longueur de tdnn_kernel doit correspondre à la longueur de tdnn_dim.
  • tdnn_dilation (tuple[int] ou list[int], facultatif, par défaut (1, 2, 3, 1, 1)) — Un tuple d'entiers définissant le facteur de dilatation de chaque couche convolutive 1D du module TDNN du modèle XVector. La longueur de tdnn_dilation doit correspondre à la longueur de tdnn_dim.
  • xvector_output_dim (int, facultatif, par défaut 512) — Dimension des vecteurs d'incorporation XVector.
  • 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 1) — Identifiant du jeton utilisé pour le début de flux dans le vocabulaire.
  • eos_token_id (Union[int, list[int]], facultatif, par défaut 2) — Identifiant du jeton utilisé pour la fin de flux dans le vocabulaire.
  • add_adapter (bool, facultatif, valeur par défaut False) — Indique s'il faut empiler un réseau d'attention convolutif au-dessus de l'encodeur Wav2Vec2Bert. Peut être très utile pour amorcer Wav2Vec2Bert pour les modèles SpeechEncoderDecoder.
  • adapter_kernel_size (int, facultatif, valeur par défaut 3) — Taille du noyau des couches convolutives du réseau adaptateur. Ne concerne que le cas où add_adapter is True.
  • adapter_stride (int, facultatif, valeur par défaut 2) — Pas des couches de convolution dans le réseau adaptateur. Ne concerne que le cas où add_adapter is True.
  • 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.
  • adapter_act (str ou function, facultatif, par défaut "relu") — Fonction d'activation non linéaire (fonction ou chaîne de caractères) des couches d'adaptateur. Si c'est une chaîne de caractères, "gelu", "relu", "selu", "swish" et "gelu_new" sont pris en charge.
  • use_intermediate_ffn_before_adapter (bool, facultatif, valeur par défaut False) — Indique s'il faut empiler un bloc feed-forward intermédiaire au-dessus de l'encodeur Wav2Vec2Bert et avant le réseau adaptateur. Pertinent uniquement si add_adapter is True.
  • output_hidden_size (int, facultatif) — Dimensionnalité de la couche de sortie de l'encodeur. Si non définie, cette valeur est par défaut hidden-size. N'est pertinent que si add_adapter is True.
  • position_embeddings_type (str, facultatif, valeur par défaut "relative_key") — Peut être spécifié comme :
  • 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 de l'embedding.
  • max_source_positions (int, facultatif, par défaut 5000) — si des embeddings de position "relative" sont utilisés, définit les positions d’entrée source maximales.
  • left_max_position_embeddings (int, facultatif, par défaut 64) — Si des embeddings de position "relative_key" (alias Shaw) sont utilisés, définit la valeur de rognage à gauche pour les positions relatives.
  • right_max_position_embeddings (int, facultatif, valeur par défaut : 8) — Si des embeddings de position "relative_key" (alias Shaw) sont utilisés, définit la valeur de rognage à droite pour les positions relatives.
  • conv_depthwise_kernel_size (int, facultatif, valeur par défaut : 31) — Taille du noyau de la couche convolutive 1D en profondeur (depthwise) dans les blocs Conformer.
  • conformer_conv_dropout (float, facultatif, valeur par défaut 0.1) — Probabilité de dropout pour toutes les couches de convolution dans les blocs Conformer.

Ceci est la classe de configuration destinée à stocker la configuration d'un Wav2Vec2 BertModel. Elle est utilisée pour instancier un modèle Wav2Vec2 Bert en fonction des arguments spécifiés, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de facebook/w2v-bert-2.0

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.

Exemple :

>>> from transformers import Wav2Vec2BertConfig, Wav2Vec2BertModel

>>> # Initializing a Wav2Vec2Bert facebook/wav2vec2-bert-rel-pos-large style configuration
>>> configuration = Wav2Vec2BertConfig()

>>> # Initializing a model (with random weights) from the facebook/wav2vec2-bert-rel-pos-large style configuration
>>> model = Wav2Vec2BertModel(configuration)

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

Wav2Vec2BertProcessor

classe transformers.Wav2Vec2BertProcessor

< >

( feature_extractortokenizer )

Paramètres

  • feature_extractor (Wav2Vec2FeatureExtractor) — L’extracteur de caractéristiques est une entrée obligatoire.
  • tokenizer (Wav2Vec2CTCTokenizer) — Le tokenizer est une entrée obligatoire.

Construit un Wav2Vec2BertProcessor qui encapsule un extracteur de caractéristiques et un tokeniseur dans un seul processeur.

Wav2Vec2BertProcessor offre toutes les fonctionnalités de Wav2Vec2FeatureExtractor et de Wav2Vec2CTCTokenizer. Consultez ~Wav2Vec2FeatureExtractor et ~Wav2Vec2CTCTokenizer pour plus d’informations.

__call__

< >

( audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], NoneType] = Nonetext: str | list[str] | None = None**kwargs: *<class 'transformers.models.wav2vec2_bert.processing_wav2vec2_bert.Wav2Vec2BertProcessorKwargs'> ) → BatchEncoding

Paramètres

  • audio (Union[numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor]], facultatif) — L’audio ou le lot d’audios à préparer. Chaque audio peut être un tableau NumPy ou un tenseur PyTorch. En cas de 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.
  • text (Union[str, 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.
  • 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_features — Audio input features to be fed to a model. Returned when audio is not None.
  • attention_mask — Liste d’indices indiquant les horodatages auxquels le modèle doit prêter attention lorsque audio n’est pas None. Lorsque seul text est spécifié, renvoie le masque d’attention des jetons.
  • labels — Liste des identifiants de jetons à fournir au modèle. Renvoyée lorsque text et audio ne sont pas None.
  • input_ids — Liste des identifiants de jetons à fournir au modèle. Renvoyé lorsque text n'est pas None et que audio est None.

pad

< >

( input_features = Nonelabels = None**kwargs )

Si input_features n'est pas None, cette méthode transmet les arguments input_features et kwargs à la méthode pad() de SeamlessM4TFeatureExtractor pour mettre en place les caractéristiques d'entrée. Si labels n'est pas None, cette méthode transmet les arguments labels et kwargs à la méthode pad() de PreTrainedTokenizer pour mettre en place les étiquette(s). Veuillez consulter la docstring des deux méthodes ci-dessus pour plus d'informations.

from_pretrained

< >

( pretrained_model_name_or_path: str | os.PathLikecache_dir: str | os.PathLike | None = Noneforce_download: bool = Falselocal_files_only: bool = Falsetoken: str | bool | None = Nonerevision: str = 'main'**kwargs )

Paramètres

  • pretrained_model_name_or_path (str ou os.PathLike) — Cela peut être soit :
    • une chaîne de caractères, l'identifiant du modèle d'un feature_extractor pré-entraîné hébergé dans un dépôt de modèles sur huggingface.co.
    • un chemin vers un dossier contenant un fichier d’extracteur de caractéristiques enregistré à l’aide de la méthode save_pretrained(), par exemple ./my_model_directory/.
    • un chemin vers un fichier JSON d’extracteur de caractéristiques enregistré fichier, par exemple ./my_model_directory/preprocessor_config.json.
  • **kwargs — Arguments supplémentaires passés à la fois à from_pretrained() et à ~tokenization_utils_base.PreTrainedTokenizer.from_pretrained.

Instanciez un processeur associé à un modèle pré-entraîné.

Cette méthode d’appel de classe invoque simplement la méthode from_pretrained() de l’extracteur de caractéristiques, la méthode de la classe ImageProcessingMixin du processeur d’images et la méthode ~tokenization_utils_base.PreTrainedTokenizer.from_pretrained du tokeniseur. Veuillez consulter les docstrings des méthodes ci-dessus pour plus d’informations.

save_pretrained

< >

( save_directorypush_to_hub: bool = False**kwargs )

Paramètres

  • save_directory (str ou os.PathLike) — Répertoire où le fichier JSON de l'extracteur de caractéristiques et les fichiers du tokenizer seront enregistrés (le répertoire sera créé s'il n'existe pas).
  • push_to_hub (bool, facultatif, par défaut False) — Indique s'il faut ou non pousser votre modèle sur le hub de modèles Hugging Face après l'avoir enregistré. Vous pouvez spécifier le dépôt auquel vous souhaitez pousser avec repo_id (par défaut, il s'agit du nom de save_directory dans votre espace de noms).
  • kwargs (dict[str, Any], facultatif) — Arguments supplémentaires passés à la méthode push_to_hub().

Enregistre les attributs de ce processeur (extracteur de caractéristiques, tokeniseur…) dans le répertoire spécifié afin qu’il puisse être rechargé à l’aide de la méthode from_pretrained().

Cette méthode de classe appelle simplement save_pretrained() et save_pretrained(). Veuillez consulter les docstrings des méthodes ci-dessus pour plus d'informations.

batch_decode

< >

( *args**kwargs )

Cette méthode transmet tous ses arguments à batch_decode() de PreTrainedTokenizer. Veuillez consulter la docstring de cette méthode pour plus d’informations.

décoder

< >

( *args**kwargs )

Cette méthode transmet tous ses arguments à decode() de PreTrainedTokenizer. Veuillez consulter la docstring de cette méthode pour plus d’informations.

Wav2Vec2BertModel

classe transformers.Wav2Vec2BertModel

< >

( config: Wav2Vec2BertConfig )

Paramètres

  • config (Wav2Vec2BertConfig) — 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 Wav2Vec2 Bert brut, qui produit des états cachés bruts sans aucune tête spécifique au sommet.

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.Tensor]attention_mask: typing.Optional[torch.Tensor] = Nonemask_time_indices: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Wav2Vec2BaseModelOutput or tuple(torch.Tensor)

Paramètres

  • input_features (torch.Tensor de forme (batch_size, sequence_length, feature_dim), facultatif) — Les tenseurs correspondant aux caractéristiques audio d'entrée. Les caractéristiques audio peuvent être obtenues à l'aide de Wav2Vec2FeatureExtractor. Voir Wav2Vec2FeatureExtractor.call() pour plus de détails (Wav2Vec2BertProcessor utilise Wav2Vec2FeatureExtractor pour le traitement des audios).
  • 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 ?

  • mask_time_indices (torch.BoolTensor de forme (batch_size, sequence_length), facultatif) — Indices à masquer pour les fonctionnalités extraites afin de calculer la perte contrastive. En mode d’entraînement, le modèle apprend à prédire les fonctionnalités extraites masquées dans l’espace config.proj_codevector_dim.

Retourne

Wav2Vec2BaseModelOutput ou tuple(torch.Tensor)

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

La méthode forward de Wav2Vec2BertModel redéfinit la méthode spéciale __call__.

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

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

  • extract_features (torch.Tensor de forme (batch_size, sequence_length, conv_dim[-1])) — Séquence de vecteurs de caractéristiques extraits de la dernière couche convolutive du modèle.

  • 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 + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

    États cachés du modèle à la sortie de chaque couche, ainsi que les sorties des embeddings initiaux.

  • 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 des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Wav2Vec2BertForCTC

classe transformers.Wav2Vec2BertForCTC

< >

( config: Wav2Vec2BertConfigtarget_lang: str | None = None )

Paramètres

  • config (Wav2Vec2BertConfig) — 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.
  • target_lang (str, facultatif) — Identifiant de langue des poids de l’adaptateur. Les poids de l’adaptateur sont stockés au format adapter..safetensors ou adapter..bin. Pertinent uniquement lors de l’utilisation d’une instance de UniSpeechSatForCTC avec des adaptateurs. La valeur par défaut est « eng ».

Modèle Wav2Vec2Bert avec une tête de language modeling pour la Classification Temporelle Connectiviste (CTC).

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.Tensor]attention_mask: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → CausalLMOutput or tuple(torch.Tensor)

Paramètres

  • input_features (torch.Tensor de forme (batch_size, sequence_length, feature_dim), facultatif) — Les tenseurs correspondant aux caractéristiques audio d'entrée. Les caractéristiques audio peuvent être obtenues à l'aide de Wav2Vec2FeatureExtractor. Voir Wav2Vec2FeatureExtractor.call() pour plus de détails (Wav2Vec2BertProcessor utilise Wav2Vec2FeatureExtractor pour le traitement des audios).
  • 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 ?

  • labels (torch.LongTensor de forme (batch_size, target_length), facultatif) — Étiquettes pour la classification temporelle connexionniste. Notez que target_length doit être inférieur ou égal à la longueur de séquence des logits de sortie. Les indices sont sélectionnés dans [-100, 0, ..., config.vocab_size - 1]. Toutes les étiquettes définies sur -100 sont ignorées (masquées) ; la perte n'est calculée que pour les étiquettes comprises dans [0, ..., config.vocab_size - 1].

Retourne

CausalLMOutput ou tuple(torch.Tensor)

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

La méthode forward de Wav2Vec2BertForCTC 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 (pour la prédiction du jeton suivant).

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

  • hidden_states (tuple(torch.Tensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

    États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

  • attentions (tuple(torch.Tensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

    Poids des attentions 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, Wav2Vec2BertForCTC
>>> 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/w2v-bert-2.0")
>>> model = Wav2Vec2BertForCTC.from_pretrained("facebook/w2v-bert-2.0")

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

Wav2Vec2BertForSequenceClassification

classe transformers.Wav2Vec2BertForSequenceClassification

< >

( config: Wav2Vec2BertConfig )

Paramètres

  • config (Wav2Vec2BertConfig) — 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.

Modèle Wav2Vec2Bert avec une tête de classification de séquences au sommet (une couche linéaire sur la sortie agrégée) pour des tâches telles que SUPERB Keyword Spotting.

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.Tensor]attention_mask: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → SequenceClassifierOutput or tuple(torch.Tensor)

Paramètres

  • input_features (torch.Tensor de forme (batch_size, sequence_length, feature_dim), facultatif) — Les tenseurs correspondant aux caractéristiques audio d'entrée. Les caractéristiques audio peuvent être obtenues à l'aide de Wav2Vec2FeatureExtractor. Voir Wav2Vec2FeatureExtractor.call() pour plus de détails (Wav2Vec2BertProcessor utilise Wav2Vec2FeatureExtractor pour le traitement des audios).
  • 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 ?

  • labels (torch.LongTensor de forme (batch_size,), facultatif) — Étiquettes pour le calcul de la perte de classification/régression de séquence. Les indices doivent être dans [0, ..., config.num_labels - 1]. Si config.num_labels == 1, une perte de régression est calculée (perte du carré moyen). Si config.num_labels > 1, une perte de classification est calculée (entropie croisée).

Retourne

SequenceClassifierOutput ou tuple(torch.Tensor)

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

La méthode forward de Wav2Vec2BertForSequenceClassification 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 classification (ou de régression si config.num_labels==1).

  • logits (torch.Tensor de forme (batch_size, config.num_labels)) — Scores de classification (ou de régression si config.num_labels==1) (avant SoftMax).

  • hidden_states (tuple(torch.Tensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

    États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

  • attentions (tuple(torch.Tensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

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

Exemple de classification mono-étiquette :

>>> import torch
>>> from transformers import AutoTokenizer, Wav2Vec2BertForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/w2v-bert-2.0")
>>> model = Wav2Vec2BertForSequenceClassification.from_pretrained("facebook/w2v-bert-2.0")

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

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
...

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = Wav2Vec2BertForSequenceClassification.from_pretrained("facebook/w2v-bert-2.0", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...

Exemple de classification multi-étiquettes :

>>> import torch
>>> from transformers import AutoTokenizer, Wav2Vec2BertForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/w2v-bert-2.0")
>>> model = Wav2Vec2BertForSequenceClassification.from_pretrained("facebook/w2v-bert-2.0", problem_type="multi_label_classification")

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

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = Wav2Vec2BertForSequenceClassification.from_pretrained(
...     "facebook/w2v-bert-2.0", num_labels=num_labels, problem_type="multi_label_classification"
... )

>>> labels = torch.sum(
...     torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).loss

Wav2Vec2BertForAudioFrameClassification

classe transformers.Wav2Vec2BertForAudioFrameClassification

< >

( config: Wav2Vec2BertConfig )

Paramètres

  • config (Wav2Vec2BertConfig) — 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 Wav2Vec2 Bert avec une tête de classification de trame au sommet, pour des tâches telles que la diarisation de locuteurs.

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.Tensor]attention_mask: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → TokenClassifierOutput or tuple(torch.Tensor)

Paramètres

  • input_features (torch.Tensor de forme (batch_size, sequence_length, feature_dim), facultatif) — Les tenseurs correspondant aux caractéristiques audio d'entrée. Les caractéristiques audio peuvent être obtenues à l'aide de Wav2Vec2FeatureExtractor. Voir Wav2Vec2FeatureExtractor.call() pour plus de détails (Wav2Vec2BertProcessor utilise Wav2Vec2FeatureExtractor pour le traitement des audios).
  • 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 ?

  • labels (torch.LongTensor de forme (batch_size,), facultatif) — Étiquettes pour le calcul de la perte de classification/régression de séquence. Les indices doivent être dans [0, ..., config.num_labels - 1]. Si config.num_labels == 1, une perte de régression est calculée (perte du carré moyen). Si config.num_labels > 1, une perte de classification est calculée (entropie croisée).

Retourne

TokenClassifierOutput ou tuple(torch.Tensor)

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

La méthode forward de Wav2Vec2BertForAudioFrameClassification 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 classification.

  • logits (torch.Tensor de forme (batch_size, sequence_length, config.num_labels)) — Scores de classification (avant SoftMax).

  • hidden_states (tuple(torch.Tensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

    États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

  • attentions (tuple(torch.Tensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

    Poids des attentions 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 AutoFeatureExtractor, Wav2Vec2BertForAudioFrameClassification
>>> 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

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/w2v-bert-2.0")
>>> model = Wav2Vec2BertForAudioFrameClassification.from_pretrained("facebook/w2v-bert-2.0")

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

>>> probabilities = torch.sigmoid(logits[0])
>>> # labels is a one-hot array of shape (num_frames, num_speakers)
>>> labels = (probabilities > 0.5).long()
>>> labels[0].tolist()
...

Wav2Vec2BertForXVector

classe transformers.Wav2Vec2BertForXVector

< >

( config: Wav2Vec2BertConfig )

Paramètres

  • config (Wav2Vec2BertConfig) — 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.

Modèle Wav2Vec2Bert avec une tête d'extraction de caractéristiques XVector au sommet, pour des tâches telles que la vérification d'orateur.

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.Tensor]attention_mask: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → XVectorOutput or tuple(torch.Tensor)

Paramètres

  • input_features (torch.Tensor de forme (batch_size, sequence_length, feature_dim), facultatif) — Les tenseurs correspondant aux caractéristiques audio d'entrée. Les caractéristiques audio peuvent être obtenues à l'aide de Wav2Vec2FeatureExtractor. Voir Wav2Vec2FeatureExtractor.call() pour plus de détails (Wav2Vec2BertProcessor utilise Wav2Vec2FeatureExtractor pour le traitement des audios).
  • 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 ?

  • labels (torch.LongTensor de forme (batch_size,), facultatif) — Étiquettes pour le calcul de la perte de classification/régression de séquence. Les indices doivent être dans [0, ..., config.num_labels - 1]. Si config.num_labels == 1, une perte de régression est calculée (perte du carré moyen). Si config.num_labels > 1, une perte de classification est calculée (entropie croisée).

Retourne

XVectorOutput ou tuple(torch.Tensor)

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

La méthode forward de Wav2Vec2BertForXVector 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 classification.

  • logits (torch.Tensor de forme (batch_size, config.xvector_output_dim)) — États cachés de classification avant AMSoftmax.

  • embeddings (torch.Tensor de forme (batch_size, config.xvector_output_dim)) — Embeddings d'énoncés utilisés pour la récupération basée sur la similarité vectorielle.

  • 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 + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

    États cachés du modèle à la sortie de chaque couche, ainsi que les sorties des embeddings initiaux.

  • 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 des attentions 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 AutoFeatureExtractor, Wav2Vec2BertForXVector
>>> 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

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/w2v-bert-2.0")
>>> model = Wav2Vec2BertForXVector.from_pretrained("facebook/w2v-bert-2.0")

>>> # audio file is decoded on the fly
>>> inputs = feature_extractor(
...     [d["array"] for d in dataset[:2]["audio"]], sampling_rate=sampling_rate, return_tensors="pt", padding=True
... )
>>> with torch.no_grad():
...     embeddings = model(**inputs).embeddings

>>> embeddings = torch.nn.functional.normalize(embeddings, dim=-1).cpu()

>>> # the resulting embeddings can be used for cosine similarity-based retrieval
>>> cosine_sim = torch.nn.CosineSimilarity(dim=-1)
>>> similarity = cosine_sim(embeddings[0], embeddings[1])
>>> threshold = 0.7  # the optimal threshold is dataset-dependent
>>> if similarity < threshold:
...     print("Speakers are not the same!")
>>> round(similarity.item(), 2)
...
Update on GitHub

←Wav2Vec2 Wav2Vec2-Conformer→