# Wav2Vec2-BERT

## Aperçu

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

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

## 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 embedding de position relative, soit des embeddings de position de type Shaw, soit des embeddings de position de type Transformer-XL, soit des embeddings 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

- Vous pouvez également adapter ces notebooks sur [la façon d’affiner un modèle de reconnaissance vocale en anglais](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/speech_recognition.ipynb) et [la façon d’affiner un modèle de reconnaissance vocale dans n’importe quelle langue](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/multi_lingual_speech_recognition.ipynb).

- Voir aussi : [Guide de la tâche de classification audio](../tasks/audio_classification)

## Wav2Vec2BertConfig[[transformers.Wav2Vec2BertConfig]]

#### transformers.Wav2Vec2BertConfig[[transformers.Wav2Vec2BertConfig]]

```python
transformers.Wav2Vec2BertConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int | None = None, hidden_size: int = 1024, num_hidden_layers: int = 24, num_attention_heads: int = 16, intermediate_size: int = 4096, feature_projection_input_dim: int = 160, hidden_act: str = 'swish', hidden_dropout: float | int = 0.0, activation_dropout: float | int = 0.0, attention_dropout: float | int = 0.0, feat_proj_dropout: float | int = 0.0, final_dropout: float | int = 0.1, layerdrop: float | int = 0.1, initializer_range: float = 0.02, layer_norm_eps: float = 1e-05, apply_spec_augment: bool = True, mask_time_prob: float | int = 0.05, mask_time_length: int = 10, mask_time_min_masks: int = 2, mask_feature_prob: float | int = 0.0, mask_feature_length: int = 10, mask_feature_min_masks: int = 0, ctc_loss_reduction: str = 'sum', ctc_zero_infinity: bool = False, use_weighted_layer_sum: bool = False, classifier_proj_size: int = 768, tdnn_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 = 512, pad_token_id: int | None = 0, bos_token_id: int | None = 1, eos_token_id: int | list[int] | None = 2, add_adapter: bool = False, adapter_kernel_size: int = 3, adapter_stride: int = 2, num_adapter_layers: int = 1, adapter_act: str = 'relu', use_intermediate_ffn_before_adapter: bool = False, output_hidden_size: int | None = None, position_embeddings_type: typing.Optional[typing.Literal['rotary', 'relative', 'relative_key']] = 'relative_key', rotary_embedding_base: int = 10000, max_source_positions: int = 5000, left_max_position_embeddings: int = 64, right_max_position_embeddings: int = 8, conv_depthwise_kernel_size: int = 31, conformer_conv_dropout: float | int = 0.1)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/configuration_wav2vec2_bert.py#L26)

**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*, valeur par défaut `1024`) : Dimension des représentations cachées.

num_hidden_layers (`int`, *facultatif*, valeur 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*, valeur par défaut `4096`) : Dimension des représentations 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 le traitement des audios d'entrée avec [SeamlessM4TFeatureExtractor](/docs/transformers/main/fr/model_doc/seamless_m4t#transformers.SeamlessM4TFeatureExtractor) ou [Wav2Vec2BertProcessor](/docs/transformers/main/fr/model_doc/wav2vec2-bert#transformers.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`) : La 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 pour les 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) : La probabilité de dropout pour la projection des caractéristiques.

final_dropout (`float`, *facultatif*, par défaut 0.1) : La probabilité de dropout pour la couche de projection finale de [Wav2Vec2BertForCTC](/docs/transformers/main/fr/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertForCTC).

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

initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids.

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

apply_spec_augment (`bool`, *facultatif*, valeur 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](https://huggingface.co/papers/1904.08779).

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 n'est pertinent que si `apply_spec_augment is True`.

mask_feature_length (`int`, *facultatif*, 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) : Le nombre minimal de masques de longueur `mask_feature_length` générés le long de l'axe des caractéristiques, à chaque pas de temps, 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*, valeur par défaut `sum`) : Spécifie la réduction à appliquer à la sortie de `torch.nn.CTCLoss`. Ne concerne que l'entraînement.

ctc_zero_infinity (`bool`, *facultatif*, 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](/docs/transformers/main/fr/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertForCTC).

use_weighted_layer_sum (`bool`, *facultatif*, 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](/docs/transformers/main/fr/model_doc/wav2vec2-bert#transformers.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*, valeur par défaut `(512, 512, 512, 512, 1500)`) : Un tuple d'entiers définissant le nombre de canaux de sortie de chaque couche convolutive 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*, valeur 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*, valeur 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*, valeur par défaut `0`) : Identifiant du jeton utilisé pour le bourrage dans le vocabulaire.

bos_token_id (`int`, *facultatif*, valeur 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*, valeur par défaut `2`) : Identifiant de jeton utilisé pour la fin de flux dans le vocabulaire.

add_adapter (`bool`, *facultatif*, valeur par défaut `False`) : Indique si un réseau d'attention convolutif doit être empilé 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 convolutives du 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 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. Ne concerne que le cas où `add_adapter is True`.

output_hidden_size (`int`, *facultatif*) : Dimensionnalité de la couche de sortie de l'encodeur. Si non définie, la valeur par défaut est *hidden-size*. Ne concerne que le cas où `add_adapter is True`.

position_embeddings_type (`str`, *facultatif*, valeur par défaut `"relative_key"`) : Peut être spécifié pour : - `rotary`, pour les embeddings de position rotatifs. - `relative`, pour les embeddings de position relatifs. - `relative_key`, pour les embeddings de position relatifs tels que définis par Shaw dans [Self-Attention with Relative Position Representations (Shaw et al.)](https://huggingface.co/papers/1803.02155). S'il est laissé à `None`, aucun embedding de position relatif n'est appliqué.

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*, valeur 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*, valeur 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"` (aka 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 dans les blocs Conformer.

conformer_conv_dropout (`float`, *facultatif*, valeur par défaut 0,1) : La probabilité de dropout pour toutes les couches de convolution dans les blocs Conformer.

Il s'agit de 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, 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/w2v-bert-2.0](https://huggingface.co/facebook/w2v-bert-2.0)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

Exemple :

```python
>>> 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[[transformers.Wav2Vec2BertProcessor]]

#### transformers.Wav2Vec2BertProcessor[[transformers.Wav2Vec2BertProcessor]]

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

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/processing_wav2vec2_bert.py#L28)

**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](/docs/transformers/main/fr/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertProcessor) offre toutes les fonctionnalités de [Wav2Vec2FeatureExtractor](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor) et de [Wav2Vec2CTCTokenizer](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer). Consultez [~Wav2Vec2FeatureExtractor](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor) et [~Wav2Vec2CTCTokenizer](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer) pour plus d’informations.

#### __appel__[[transformers.Wav2Vec2BertProcessor.__call__]]

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

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/processing_wav2vec2_bert.py#L32)

**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. Dans le cas d'un tableau NumPy/d'un tenseur PyTorch, chaque audio doit avoir la forme (C, T), où C est le nombre de canaux et T est la longueur 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îne pré-tokenisée). Si vous transmettez une entrée pré-tokenisée, définissez `is_split_into_words=True` pour éviter toute ambiguïté avec les entrées en lot.

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

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

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

Un [BatchEncoding](/docs/transformers/main/fr/main_classes/tokenizer#transformers.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 spécifiant 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[[transformers.Wav2Vec2BertProcessor.pad]]

```python
pad(input_features = None, labels = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/processing_wav2vec2_bert.py#L70)

Si `input_features` n'est pas `None`, cette méthode transmet les arguments `input_features` et `kwargs` à la méthode [pad()](/docs/transformers/main/fr/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad) de SeamlessM4TFeatureExtractor pour mettre en forme 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()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.pad) de PreTrainedTokenizer pour mettre en forme les étiquette(s). Veuillez consulter la docstring des deux méthodes ci-dessus pour plus d'informations.

#### from_pretrained[[transformers.Wav2Vec2BertProcessor.from_pretrained]]

```python
from_pretrained(pretrained_model_name_or_path: str | os.PathLike, cache_dir: str | os.PathLike | None = None, force_download: bool = False, local_files_only: bool = False, token: str | bool | None = None, revision: str = 'main', **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L1750)

**Paramètres :**

pretrained_model_name_or_path (`str` or `os.PathLike`) : This can be either:  - a string, the *model id* of a pretrained feature_extractor hosted inside a model repo on huggingface.co. - a path to a *directory* containing a feature extractor file saved using the [save_pretrained()](/docs/transformers/main/fr/main_classes/feature_extractor#transformers.FeatureExtractionMixin.save_pretrained) method, e.g., `./my_model_directory/`. - a path to a saved feature extractor JSON *file*, e.g., `./my_model_directory/preprocessor_config.json`.

- ****kwargs** : Arguments supplémentaires passés à la fois à [from_pretrained()](/docs/transformers/main/fr/main_classes/feature_extractor#transformers.FeatureExtractionMixin.from_pretrained) et à `~tokenization_utils_base.PreTrainedTokenizer.from_pretrained`.

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

Cette méthode de classe appelle simplement la méthode [from_pretrained()](/docs/transformers/main/fr/main_classes/feature_extractor#transformers.FeatureExtractionMixin.from_pretrained) de l'extracteur de caractéristiques, le processeur d'images [ImageProcessingMixin](/docs/transformers/main/fr/internal/image_processing_utils#transformers.ImageProcessingMixin) 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[[transformers.Wav2Vec2BertProcessor.save_pretrained]]

```python
save_pretrained(save_directory, push_to_hub: bool = False, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L1165)

**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*, valeur par défaut `False`) : Indique s'il faut ou non publier votre modèle sur le Hugging Face model hub après l'avoir enregistré. Vous pouvez spécifier le dépôt de destination 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 par mot-clé transmis à la méthode [push_to_hub()](/docs/transformers/main/fr/main_classes/model#transformers.utils.PushToHubMixin.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()](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2Processor.from_pretrained).

Cette méthode de classe appelle simplement [save_pretrained()](/docs/transformers/main/fr/main_classes/feature_extractor#transformers.FeatureExtractionMixin.save_pretrained) et [save_pretrained()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.save_pretrained). Veuillez consulter les docstrings des méthodes ci-dessus pour plus d’informations.

#### batch_decode[[transformers.Wav2Vec2BertProcessor.batch_decode]]

```python
batch_decode(*args, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L2005)

Cette méthode transmet tous ses arguments à [batch_decode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.batch_decode) de PreTrainedTokenizer. Veuillez consulter la docstring de cette méthode pour plus d'informations.

#### decode[[transformers.Wav2Vec2BertProcessor.decode]]

```python
decode(*args, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L2014)

Cette méthode transmet tous ses arguments à [decode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) de PreTrainedTokenizer. Veuillez consulter la docstring de cette méthode pour plus d'informations.

## Wav2Vec2BertModel[[transformers.Wav2Vec2BertModel]]

#### transformers.Wav2Vec2BertModel[[transformers.Wav2Vec2BertModel]]

```python
transformers.Wav2Vec2BertModel(config: Wav2Vec2BertConfig)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/modeling_wav2vec2_bert.py#L940)

**Paramètres :**

config ([Wav2Vec2BertConfig](/docs/transformers/main/fr/model_doc/wav2vec2-bert#transformers.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()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.Wav2Vec2BertModel.forward]]

```python
forward(input_features: typing.Optional[torch.Tensor], attention_mask: typing.Optional[torch.Tensor] = None, mask_time_indices: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/modeling_wav2vec2_bert.py#L1007)

**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](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor). Voir [Wav2Vec2FeatureExtractor.__call__()](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor.__call__) pour plus de détails ([Wav2Vec2BertProcessor](/docs/transformers/main/fr/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertProcessor) utilise [Wav2Vec2FeatureExtractor](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.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 qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

mask_time_indices (`torch.BoolTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices pour masquer les fonctionnalités extraites pour 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](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.modeling_outputs.Wav2Vec2BaseModelOutput) ou `tuple(torch.Tensor)`

Un [Wav2Vec2BaseModelOutput](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.modeling_outputs.Wav2Vec2BaseModelOutput) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([Wav2Vec2BertConfig](/docs/transformers/main/fr/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertConfig)) et les entrées.

La méthode forward de [Wav2Vec2BertModel](/docs/transformers/main/fr/model_doc/wav2vec2-bert#transformers.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)`.

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

## Wav2Vec2BertForCTC[[transformers.Wav2Vec2BertForCTC]]

#### transformers.Wav2Vec2BertForCTC[[transformers.Wav2Vec2BertForCTC]]

```python
transformers.Wav2Vec2BertForCTC(config: Wav2Vec2BertConfig, target_lang: str | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/modeling_wav2vec2_bert.py#L1053)

**Paramètres :**

config ([Wav2Vec2BertConfig](/docs/transformers/main/fr/model_doc/wav2vec2-bert#transformers.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()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/fr/model_doc/unispeech-sat#transformers.UniSpeechSatForCTC) avec des adaptateurs. Utilise 'eng' par défaut.

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

Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.Wav2Vec2BertForCTC.forward]]

```python
forward(input_features: typing.Optional[torch.Tensor], attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/modeling_wav2vec2_bert.py#L1083)

**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](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor). Voir [Wav2Vec2FeatureExtractor.__call__()](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor.__call__) pour plus de détails ([Wav2Vec2BertProcessor](/docs/transformers/main/fr/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertProcessor) utilise [Wav2Vec2FeatureExtractor](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.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 qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

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](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.CausalLMOutput) ou `tuple(torch.Tensor)`

Un [CausalLMOutput](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/main/fr/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertConfig)) et des entrées.

La méthode forward de [Wav2Vec2BertForCTC](/docs/transformers/main/fr/model_doc/wav2vec2-bert#transformers.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)`.

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

Exemple :

```python
>>> from transformers import 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[[transformers.Wav2Vec2BertForSequenceClassification]]

#### transformers.Wav2Vec2BertForSequenceClassification[[transformers.Wav2Vec2BertForSequenceClassification]]

```python
transformers.Wav2Vec2BertForSequenceClassification(config: Wav2Vec2BertConfig)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/modeling_wav2vec2_bert.py#L1143)

**Paramètres :**

config ([Wav2Vec2BertConfig](/docs/transformers/main/fr/model_doc/wav2vec2-bert#transformers.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()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.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 comme le SUPERB Keyword Spotting.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.Wav2Vec2BertForSequenceClassification.forward]]

```python
forward(input_features: typing.Optional[torch.Tensor], attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/modeling_wav2vec2_bert.py#L1169)

**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](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor). Voir [Wav2Vec2FeatureExtractor.__call__()](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor.__call__) pour plus de détails ([Wav2Vec2BertProcessor](/docs/transformers/main/fr/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertProcessor) utilise [Wav2Vec2FeatureExtractor](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.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 qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

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](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) ou `tuple(torch.Tensor)`

Un [SequenceClassifierOutput](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([Wav2Vec2BertConfig](/docs/transformers/main/fr/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertConfig)) et les entrées.

La méthode forward de [Wav2Vec2BertForSequenceClassification](/docs/transformers/main/fr/model_doc/wav2vec2-bert#transformers.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)`.

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

Exemple de classification mono-étiquette :

```python
>>> 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 :

```python
>>> 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[[transformers.Wav2Vec2BertForAudioFrameClassification]]

#### transformers.Wav2Vec2BertForAudioFrameClassification[[transformers.Wav2Vec2BertForAudioFrameClassification]]

```python
transformers.Wav2Vec2BertForAudioFrameClassification(config: Wav2Vec2BertConfig)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/modeling_wav2vec2_bert.py#L1227)

**Paramètres :**

config ([Wav2Vec2BertConfig](/docs/transformers/main/fr/model_doc/wav2vec2-bert#transformers.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()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.Wav2Vec2BertForAudioFrameClassification.forward]]

```python
forward(input_features: typing.Optional[torch.Tensor], attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/modeling_wav2vec2_bert.py#L1252)

**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](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor). Voir [Wav2Vec2FeatureExtractor.__call__()](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor.__call__) pour plus de détails ([Wav2Vec2BertProcessor](/docs/transformers/main/fr/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertProcessor) utilise [Wav2Vec2FeatureExtractor](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.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 qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

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](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) ou `tuple(torch.Tensor)`

Un [TokenClassifierOutput](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([Wav2Vec2BertConfig](/docs/transformers/main/fr/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertConfig)) et les entrées.

La méthode forward de [Wav2Vec2BertForAudioFrameClassification](/docs/transformers/main/fr/model_doc/wav2vec2-bert#transformers.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)`.

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

Exemple :

```python
>>> from transformers import 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[[transformers.Wav2Vec2BertForXVector]]

#### transformers.Wav2Vec2BertForXVector[[transformers.Wav2Vec2BertForXVector]]

```python
transformers.Wav2Vec2BertForXVector(config: Wav2Vec2BertConfig)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/modeling_wav2vec2_bert.py#L1360)

**Paramètres :**

config ([Wav2Vec2BertConfig](/docs/transformers/main/fr/model_doc/wav2vec2-bert#transformers.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()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.Wav2Vec2BertForXVector.forward]]

```python
forward(input_features: typing.Optional[torch.Tensor], attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_bert/modeling_wav2vec2_bert.py#L1403)

**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](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor). Voir [Wav2Vec2FeatureExtractor.__call__()](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor.__call__) pour plus de détails ([Wav2Vec2BertProcessor](/docs/transformers/main/fr/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertProcessor) utilise [Wav2Vec2FeatureExtractor](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.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 qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

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](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.XVectorOutput) ou `tuple(torch.Tensor)`

Un [XVectorOutput](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.XVectorOutput) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([Wav2Vec2BertConfig](/docs/transformers/main/fr/model_doc/wav2vec2-bert#transformers.Wav2Vec2BertConfig)) et les entrées.

La méthode forward de [Wav2Vec2BertForXVector](/docs/transformers/main/fr/model_doc/wav2vec2-bert#transformers.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)`.

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

Exemple :

```python
>>> from transformers import 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)
...
```