# Wav2Vec2

## Aperçu

Le modèle Wav2Vec2 a été proposé dans [wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations](https://huggingface.co/papers/2006.11477) par Alexei Baevski, Henry Zhou, Abdelrahman Mohamed, Michael Auli.

L'abstract de l'article est le suivant :

*Nous démontrons pour la première fois qu’apprendre des représentations puissantes à partir uniquement d’audio vocal, suivies d’un fine-tuning sur des transcriptions vocales, peut surpasser les meilleures méthodes semi-supervisées tout en étant conceptuellement plus simple. wav2vec 2.0 masque l’entrée vocale dans l’espace latent et résout une tâche contrastive définie sur une quantification des représentations latentes, qui sont apprises conjointement. Les expériences utilisant toutes les données étiquetées de Librispeech atteignent un WER de 1,8/3,3 sur les ensembles de test clean/other. En réduisant la quantité de données étiquetées à une heure, wav2vec 2.0 surpasse l’état de l’art précédent sur le sous-ensemble de 100 heures, tout en utilisant 100 fois moins de données étiquetées. En utilisant seulement dix minutes de données étiquetées et un pré-entraînement sur 53 000 heures de données non étiquetées, on obtient toujours un WER de 4,8/8,2. Cela démontre la faisabilité de la reconnaissance vocale avec des quantités limitées de données étiquetées.*

Ce modèle a été contribué par [patrickvonplaten](https://huggingface.co/patrickvonplaten).

Remarque : Meta (FAIR) a publié une nouvelle version de [Wav2Vec2-BERT 2.0](./wav2vec2-bert) - elle est pré-entraînée sur 4,5 millions d'heures d'audio. Nous recommandons en particulier de l'utiliser pour les tâches de fine-tuning, par exemple conformément à [ce guide](https://huggingface.co/blog/fine-tune-w2v2-bert).

> [!TIP]
> Définissez `use_kernels=True` dans [from_pretrained()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour remplacer les couches prises en charge par des noyaux optimisés du Hub. Consultez [Chargement des noyaux](../kernel_doc/loading_kernels) pour en savoir plus.

## Conseils d'utilisation

- Wav2Vec2 est un modèle de parole qui accepte un tableau de nombres à virgule flottante correspondant à la forme d’onde brute du signal de parole.
- Le modèle Wav2Vec2 a été entraîné à l'aide de la classification temporelle connexionniste (CTC), il est donc nécessaire de décoder sa sortie à l'aide de [Wav2Vec2CTCTokenizer](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer).

## Utilisation de Flash Attention 2

Flash Attention 2 est une version plus rapide et optimisée du modèle.

### Installation

Vérifiez d'abord si votre matériel est compatible avec Flash Attention 2. La liste la plus récente du matériel compatible se trouve dans la [documentation officielle](https://github.com/Dao-AILab/flash-attention#installation-and-features).

Ensuite, [installez](https://github.com/Dao-AILab/flash-attention#installation-and-features) la dernière version de Flash Attention 2 :

```bash
pip install -U flash-attn --no-build-isolation
```

### Utilisation

Pour charger un modèle en utilisant Flash Attention 2, nous pouvons passer l'argument `attn_implementation="flash_attention_2"` à [from_pretrained()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained). Nous chargerons également le modèle en demi-précision (par exemple `torch.float16`), car cela entraîne une dégradation quasi nulle de la qualité audio, mais une consommation mémoire nettement réduite et une inférence plus rapide :

```python
from transformers import Wav2Vec2Model

model = Wav2Vec2Model.from_pretrained("facebook/wav2vec2-large-960h-lv60-self", attn_implementation="flash_attention_2", device_map="auto")
...
```

### Accélérations attendues

Le diagramme ci-dessous présente l'accélération attendue en comparant le temps d'inférence pur entre l'implémentation native dans transformers du modèle `facebook/wav2vec2-large-960h-lv60-self` et les versions flash-attention-2 et sdpa (scale-dot-product-attention). Nous affichons l'accélération moyenne obtenue sur le sous-ensemble de validation `librispeech_asr` `clean` :

## Ressources

Une liste de ressources officielles Hugging Face et de la communauté (indiquées par 🌎) pour vous aider à démarrer avec Wav2Vec2. Si vous souhaitez soumettre une ressource pour qu'elle soit incluse ici, n'hésitez pas à ouvrir une Pull Request et nous la examinerons ! La ressource devrait idéalement démontrer quelque chose de nouveau plutôt que de dupliquer une ressource existante.

- Un notebook sur la manière de [mettre à profit un modèle Wav2Vec2 pré-entraîné pour la classification des émotions](https://colab.research.google.com/github/m3hrdadfi/soxan/blob/main/notebooks/Emotion_recognition_in_Greek_speech_using_Wav2Vec2.ipynb). 🌎
- [Wav2Vec2ForCTC](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC) est pris en charge par ce [notebook](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/audio_classification.ipynb).
- [Guide de la tâche de classification audio](../tasks/audio_classification)

- Un article de blog sur [l'amélioration de Wav2Vec2 avec des n-grammes dans 🤗 Transformers](https://huggingface.co/blog/wav2vec2-with-ngram).
- Un article de blog sur la façon de [réentraîner Wav2Vec2 pour l'ASR en anglais avec 🤗 Transformers](https://huggingface.co/blog/fine-tune-wav2vec2-english).
- Un article de blog sur [l’ajustement fin de XLS-R pour l’ASR multilingue avec 🤗 Transformers](https://huggingface.co/blog/fine-tune-xlsr-wav2vec2).
- Un notebook expliquant comment [créer des sous-titres YouTube à partir de n’importe quelle vidéo en transcrivant l’audio avec Wav2Vec2](https://colab.research.google.com/github/Muennighoff/ytclipcc/blob/main/wav2vec_youtube_captions.ipynb). 🌎
- [Wav2Vec2ForCTC](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC) est pris en charge par un notebook 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).
- [Guide de la tâche de reconnaissance automatique de la parole](../tasks/asr)

🚀 Déployer

- Un article de blog sur la manière de déployer Wav2Vec2 pour la [Reconnaissance Automatique de la Parole avec Transformers de Hugging Face & Amazon SageMaker](https://www.philschmid.de/automatic-speech-recognition-sagemaker).

## Wav2Vec2Config[[transformers.Wav2Vec2Config]]

#### transformers.Wav2Vec2Config[[transformers.Wav2Vec2Config]]

```python
transformers.Wav2Vec2Config(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 = 32, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout: float | int = 0.1, activation_dropout: float | int = 0.1, attention_dropout: float | int = 0.1, feat_proj_dropout: float | int = 0.0, feat_quantizer_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, feat_extract_norm: str = 'group', feat_extract_activation: str = 'gelu', conv_dim: list[int] | tuple[int, ...] = (512, 512, 512, 512, 512, 512, 512), conv_stride: list[int] | tuple[int, ...] = (5, 2, 2, 2, 2, 2, 2), conv_kernel: list[int] | tuple[int, ...] = (10, 3, 3, 3, 3, 2, 2), conv_bias: bool = False, num_conv_pos_embeddings: int = 128, num_conv_pos_embedding_groups: int = 16, do_stable_layer_norm: bool = False, 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, num_codevectors_per_group: int = 320, num_codevector_groups: int = 2, contrastive_logits_temperature: float = 0.1, num_negatives: int = 100, codevector_dim: int = 256, proj_codevector_dim: int = 256, diversity_loss_weight: float = 0.1, ctc_loss_reduction: str = 'sum', ctc_zero_infinity: bool = False, use_weighted_layer_sum: bool = False, classifier_proj_size: int = 256, 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 = 3, output_hidden_size: int | None = None, adapter_attn_dim: int | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/configuration_wav2vec2.py#L27)

**Paramètres :**

vocab_size (`int`, *facultatif*, valeur par défaut `32`) : 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 `768`) : Dimension des représentations cachées.

num_hidden_layers (`int`, *facultatif*, par défaut `12`) : Nombre de couches cachées dans le décodeur Transformer.

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

intermediate_size (`int`, *facultatif*, par défaut `3072`) : Dimension des représentations MLP.

hidden_act (`str`, *facultatif*, par défaut `gelu`) : 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.1`) : 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.1`) : 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.1`) : 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 sortie de l'encodeur de caractéristiques.

feat_quantizer_dropout (`float`, *facultatif*, valeur par défaut 0.0) : La probabilité de dropout pour la sortie de l'encodeur de caractéristiques utilisée par le quantificateur.

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

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.

feat_extract_norm (`str`, *facultatif*, valeur par défaut `"group"`) : La normalisation à appliquer aux couches de convolution 1D de l'encodeur de caractéristiques. Soit `"group"` pour une normalisation par groupe appliquée uniquement à la première couche de convolution 1D, soit `"layer"` pour une normalisation par couche appliquée à toutes les couches de convolution 1D.

feat_extract_activation (`str, `optional`, defaults to `"gelu"`) : The non-linear activation function (function or string) in the 1D convolutional layers of the feature extractor. If string, `"gelu"`, `"relu"`, `"selu"` and `"gelu_new"` are supported.

conv_dim (`tuple[int]` ou `list[int]`, *facultatif*, valeur par défaut `(512, 512, 512, 512, 512, 512, 512)`) : Un tuple d'entiers définissant le nombre de canaux d'entrée et de sortie de chaque couche convolutive 1D dans l'encodeur de caractéristiques. La longueur de *conv_dim* définit le nombre de couches convolutives 1D.

conv_stride (`tuple[int]` ou `list[int]`, *facultatif*, valeur par défaut `(5, 2, 2, 2, 2, 2, 2)`) : Un tuple d'entiers définissant le pas de chaque couche de convolution 1D dans l'encodeur de caractéristiques. La longueur de *conv_stride* définit le nombre de couches de convolution et doit correspondre à la longueur de *conv_dim*.

conv_kernel (`tuple[int]` ou `list[int]`, *facultatif*, valeur par défaut `(10, 3, 3, 3, 3, 3, 3)`) : Un tuple d'entiers définissant la taille du noyau de chaque couche convolutive 1D dans l'encodeur de caractéristiques. La longueur de *conv_kernel* définit le nombre de couches convolutives et doit correspondre à la longueur de *conv_dim*.

conv_bias (`bool`, *facultatif*, par défaut `False`) : Indique si les couches de convolution 1D ont un biais.

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

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

do_stable_layer_norm (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut appliquer l'architecture de normalisation de couche *stable* de l'encodeur Transformer. `do_stable_layer_norm is True` correspond à l'application de la normalisation de couche avant la couche d'attention, tandis que `do_stable_layer_norm is False` correspond à l'application de la normalisation de couche après la couche d'attention.

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`, *facultatif*, valeur par défaut 0.05) : Pourcentage (compris entre 0 et 1) de tous les vecteurs de caractéristiques le long de l'axe temporel qui seront masqués. La procédure de masquage génère ''mask_time_prob*len(time_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_time_prob* doit être `prob_vector_start*mask_time_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_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), : 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 du vecteur à 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_prob (`Union[float, int]`, *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 l'étendue 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` est `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''

num_codevectors_per_group (`int`, *facultatif*, valeur par défaut : 320) : Nombre d'entrées dans chaque codebook de quantification (groupe).

num_codevectors_per_group (`int`, *facultatif*, valeur par défaut : 320) : Nombre d'entrées dans chaque codebook de quantification (groupe).

num_codevector_groups (`int`, *facultatif*, valeur par défaut : 2) : Nombre de groupes de codevectors pour la quantification par codevectors produit.

contrastive_logits_temperature (`float`, *facultatif*, valeur par défaut 0,1) : la température *kappa* dans la perte contrastive.

num_negatives (`int`, *facultatif*, valeur par défaut 100) : Nombre d'échantillons négatifs pour la perte contrastive.

codevector_dim (`int`, *facultatif*, par défaut 256) : Dimension des vecteurs de caractéristiques quantifiés.

proj_codevector_dim (`int`, *facultatif*, valeur par défaut : 256) : Dimension de la projection finale des fonctionnalités quantifiées et des fonctionnalités du transformeur.

diversity_loss_weight (`int`, *facultatif*, valeur par défaut 0,1) : Le poids de la composante de perte de diversité du codebook.

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 d'une instance de [Wav2Vec2ForCTC](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC).

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. Pertinent uniquement lors de l'entraînement d'une instance de [Wav2Vec2ForCTC](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC).

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 [Wav2Vec2ForSequenceClassification](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2ForSequenceClassification).

classifier_proj_size (`int`, *facultatif*, valeur par défaut 256) : 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 convolutif doit être empilé au-dessus de l'encodeur Wav2Vec2. Peut être très utile pour amorcer Wav2Vec2 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 3) : Nombre de couches de convolution à utiliser dans 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`.

adapter_attn_dim (`int`, *facultatif*) : Dimension des poids de l'adaptateur d'attention à utiliser dans chaque bloc d'attention. Un exemple de modèle utilisant des adaptateurs d'attention est [facebook/mms-1b-all](https://huggingface.co/facebook/mms-1b-all).

Ceci est la classe de configuration destinée à stocker la configuration d'un Wav2Vec2Model. Elle est utilisée pour instancier un modèle Wav2Vec2 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/wav2vec2-base-960h](https://huggingface.co/facebook/wav2vec2-base-960h)

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 Wav2Vec2Config, Wav2Vec2Model

>>> # Initializing a Wav2Vec2 facebook/wav2vec2-base-960h style configuration
>>> configuration = Wav2Vec2Config()

>>> # Initializing a model (with random weights) from the facebook/wav2vec2-base-960h style configuration
>>> model = Wav2Vec2Model(configuration)

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

## Wav2Vec2CTCTokenizer[[transformers.Wav2Vec2CTCTokenizer]]

#### transformers.Wav2Vec2CTCTokenizer[[transformers.Wav2Vec2CTCTokenizer]]

```python
transformers.Wav2Vec2CTCTokenizer(vocab_file, bos_token = '<s>', eos_token = '</s>', unk_token = '<unk>', pad_token = '<pad>', word_delimiter_token = '|', replace_word_delimiter_char = ' ', do_lower_case = False, target_lang = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/tokenization_wav2vec2.py#L101)

**Paramètres :**

vocab_file (`str`) : Fichier contenant le vocabulaire.

bos_token (`str`, *facultatif*, par défaut `"<s>"`) : Jeton de début de phrase.

eos_token (`str`, *facultatif*, valeur par défaut `"</s>"`) : Jeton de fin de phrase.

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

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

word_delimiter_token (`str`, *facultatif*, valeur par défaut `"|"`) : Le jeton utilisé pour définir la fin d'un mot.

do_lower_case (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut accepter une entrée en minuscules et mettre la sortie en minuscules lors du décodage.

target_lang (`str`, *facultatif*) : La langue cible que le tokenizer doit définir par défaut. `target_lang` doit être défini pour les vocabulaires imbriqués multilingues tels que [facebook/mms-1b-all](https://huggingface.co/facebook/mms-1b-all).

- ****kwargs** : Arguments supplémentaires passés à [PreTrainedTokenizer](/docs/transformers/main/fr/main_classes/tokenizer#transformers.PythonBackend)

Construit un tokeniseur Wav2Vec2CTC.

Ce tokenizer hérite de [PreTrainedTokenizer](/docs/transformers/main/fr/main_classes/tokenizer#transformers.PythonBackend), qui contient certaines des principales méthodes. Les utilisateurs doivent se reporter à la classe parente pour plus d’informations sur ces méthodes.

#### __appel__[[transformers.Wav2Vec2CTCTokenizer.__call__]]

```python
__call__(text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, add_special_tokens: bool = True, padding: bool | str | PaddingStrategy = False, truncation: bool | str | TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, is_split_into_words: bool = False, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, tokenizer_kwargs: dict[str, Any] | None = None, **kwargs)
```

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

**Paramètres :**

text (`str`, `list[str]`, `list[list[str]]`, *facultatif*) : La séquence ou le lot de séquences à encoder. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes de caractères (chaînes pré-tokenisées). Si les séquences sont fournies sous forme de liste de chaînes de caractères (pré-tokenisées), vous devez définir `is_split_into_words=True` (pour lever l'ambiguïté avec un lot de séquences).

text_pair (`str`, `list[str]`, `list[list[str]]`, *facultatif*) : La séquence ou le lot de séquences à encoder. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes de caractères (chaînes pré-tokenisées). Si les séquences sont fournies sous forme de liste de chaînes de caractères (pré-tokenisées), vous devez définir `is_split_into_words=True` (pour lever l'ambiguïté avec un lot de séquences).

text_target (`str`, `list[str]`, `list[list[str]]`, *facultatif*) : La séquence ou le lot de séquences à encoder en tant que textes cibles. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes de caractères (chaîne pré-tokenisée). Si les séquences sont fournies sous forme de liste de chaînes de caractères (pré-tokenisées), vous devez définir `is_split_into_words=True` (pour lever l’ambiguïté avec un lot de séquences).

text_pair_target (`str`, `list[str]`, `list[list[str]]`, *facultatif*) : La séquence ou le lot de séquences à encoder en tant que textes cibles. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes de caractères (chaîne pré-tokenisée). Si les séquences sont fournies sous forme de liste de chaînes de caractères (pré-tokenisées), vous devez définir `is_split_into_words=True` (pour lever l’ambiguïté avec un lot de séquences).

tokenizer_kwargs (`dict[str, Any]`, *facultatif*) : kwargs supplémentaires à passer au tokenizer. Ils seront fusionnés avec les paramètres explicites et les autres kwargs, les paramètres explicites ayant la priorité.

add_special_tokens (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ajouter des jetons spéciaux lors de l'encodage des séquences. Cette opération utilise la fonction sous-jacente `PretrainedTokenizerBase.build_inputs_with_special_tokens`, qui définit les jetons ajoutés automatiquement aux identifiants d'entrée. Cela est utile si vous souhaitez ajouter automatiquement des jetons `bos` ou `eos`.

padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/main/fr/internal/file_utils#transformers.utils.PaddingStrategy), *facultatif*, par défaut `False`) : Active et contrôle le bourrage. Accepte les valeurs suivantes :  - `True` ou `'longest'` : Bourrage jusqu'à la séquence la plus longue du lot (ou aucun bourrage si une seule séquence est fournie). - `'max_length'` : Bourrage jusqu'à une longueur maximale spécifiée avec l'argument `max_length` ou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. - `False` ou `'do_not_pad'` (par défaut) : Aucun bourrage (c'est-à-dire, peut produire un lot avec des séquences de longueurs différentes).

truncation (`bool`, `str` ou [TruncationStrategy](/docs/transformers/main/fr/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *facultatif*, par défaut `False`) : Active et contrôle la troncature. Accepte les valeurs suivantes :  - `True` ou `'longest_first'` : Tronque à une longueur maximale spécifiée par l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela tronque jeton par jeton, en supprimant un jeton de la séquence la plus longue de la paire si une paire de séquences (ou un lot de paires) est fournie. - `'only_first'` : Tronque à une longueur maximale spécifiée par l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronque que la première séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie. - `'only_second'` : Tronque à une longueur maximale spécifiée par l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronque que la deuxième séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie. - `False` ou `'do_not_truncate'` (par défaut) : Aucune troncature (c'est-à-dire, peut produire un lot avec des longueurs de séquences supérieures à la taille d'entrée maximale admissible du modèle).

max_length (`int`, *facultatif*) : Permet de contrôler la longueur maximale à utiliser par l'un des paramètres de troncature/remplissage. S'il n'est pas défini ou s'il est défini sur `None`, la longueur maximale prédéfinie du modèle sera utilisée si l'un des paramètres de troncature/remplissage exige une longueur maximale. Si le modèle n'a pas de longueur d'entrée maximale spécifique (comme XLNet), la troncature/remplissage à une longueur maximale sera désactivée.

stride (`int`, *facultatif*, valeur par défaut 0) : Si défini avec une valeur numérique en plus de `max_length`, les jetons en dépassement renvoyés lorsque `return_overflowing_tokens=True` contiendront certains jetons de la fin de la séquence tronquée renvoyée, afin d'assurer un chevauchement entre les séquences tronquées et celles en dépassement. La valeur de cet argument définit le nombre de jetons en chevauchement.

is_split_into_words (`bool`, *facultatif*, valeur par défaut `False`) : Indique si l'entrée est déjà pré-tokenisée (par exemple, découpée en mots). Si défini sur `True`, le tokenizer suppose que l'entrée est déjà découpée en mots (par exemple, en la séparant sur les espaces) et procède à sa tokenisation. Cela est utile pour la NER ou la classification de tokens.

pad_to_multiple_of (`int`, *facultatif*) : Si défini, la séquence sera rembourdie jusqu'à un multiple de la valeur fournie. Nécessite l'activation de `padding`. Cela est particulièrement utile pour permettre l'utilisation des Tensor Cores sur le matériel NVIDIA avec une capacité de calcul `>= 7.5` (Volta).

padding_side (`str`, *facultatif*) : Le côté sur lequel le modèle doit appliquer le bourrage. Doit être sélectionné parmi ['right', 'left']. La valeur par défaut est choisie à partir de l'attribut de classe du même nom.

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

return_token_type_ids (`bool`, *facultatif*) : Indique s'il faut renvoyer les identifiants de type de jeton. Si la valeur par défaut est conservée, les identifiants de type de jeton seront renvoyés selon la valeur par défaut du tokeniseur spécifique, définie par l'attribut `return_outputs`.  [Qu'est-ce que les identifiants de type de jeton ?](../glossary#token-type-ids)

return_attention_mask (`bool`, *facultatif*) : Indique s'il faut retourner le masque d'attention. Si la valeur par défaut est conservée, le masque d'attention est retourné selon la valeur par défaut du tokenizer spécifique, définie par l'attribut `return_outputs`.  [Qu'est-ce que les masques d'attention ?](../glossary#attention-mask)

return_overflowing_tokens (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non renvoyer les séquences de jetons en dépassement. Si une paire de séquences d'identifiants d'entrée (ou un lot de paires) est fournie avec `truncation_strategy = longest_first` ou `True`, une erreur est levée au lieu de renvoyer les jetons en dépassement.

return_special_tokens_mask (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non retourner les informations du masque des jetons spéciaux.

return_offsets_mapping (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non retourner `(char_start, char_end)` pour chaque jeton. Cette option n'est disponible que pour les tokenizers rapides héritant de [PreTrainedTokenizerFast](/docs/transformers/main/fr/main_classes/tokenizer#transformers.TokenizersBackend) ; si vous utilisez le tokenizer Python, cette méthode lèvera `NotImplementedError`.

return_length  (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut retourner les longueurs des entrées encodées.

verbose (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut afficher plus d'informations et d'avertissements.

- ****kwargs** : transmis à la méthode `self.tokenize()`

**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_ids** -- Liste des identifiants de jetons à fournir au modèle.

  [Qu'est-ce que les identifiants d'entrée ?](../glossary#input-ids)

- **token_type_ids** -- Liste des identifiants de type de jeton à fournir au modèle (lorsque `return_token_type_ids=True` ou si *"token_type_ids"* est présent dans `self.model_input_names`).

  [Qu'est-ce que les identifiants de type de jeton ?](../glossary#token-type-ids)

- **attention_mask** -- Liste d'indices spécifiant les jetons auxquels le modèle doit prêter attention (lorsque `return_attention_mask=True` ou si *"attention_mask"* est présent dans `self.model_input_names`).

  [Qu'est-ce que les masques d'attention ?](../glossary#attention-mask)

- **overflowing_tokens** -- Liste des séquences de jetons en dépassement (lorsqu'une `max_length` est spécifiée et `return_overflowing_tokens=True`).
- **num_truncated_tokens** -- Nombre de jetons tronqués (lorsqu'une `max_length` est spécifiée et `return_overflowing_tokens=True`).
- **special_tokens_mask** -- Liste de 0 et de 1, où 1 indique les jetons spéciaux ajoutés et 0 indique les jetons de séquence réguliers (lorsque `add_special_tokens=True` et `return_special_tokens_mask=True`).
- **length** -- La longueur des entrées (lorsque `return_length=True`)

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

#### save_vocabulary[[transformers.Wav2Vec2CTCTokenizer.save_vocabulary]]

```python
save_vocabulary(save_directory: str, filename_prefix: str | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/tokenization_wav2vec2.py#L643)

#### decode[[transformers.Wav2Vec2CTCTokenizer.decode]]

```python
decode(token_ids: typing.Union[int, list[int], numpy.ndarray, ForwardRef('torch.Tensor')], skip_special_tokens: bool = False, clean_up_tokenization_spaces: bool | None = None, output_char_offsets: bool = False, output_word_offsets: bool = False, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/tokenization_wav2vec2.py#L538)

**Paramètres :**

token_ids (`Union[int, list[int], np.ndarray, torch.Tensor]`) : Liste des identifiants d'entrée tokenisés. Peut être obtenue à l'aide de la méthode `__call__`.

skip_special_tokens (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut supprimer les jetons spéciaux lors du décodage.

clean_up_tokenization_spaces (`bool`, *facultatif*) : Indique s'il faut nettoyer ou non les espaces de tokenisation.

output_char_offsets (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non afficher les décalages de caractères. Les décalages de caractères peuvent être utilisés en combinaison avec le taux d'échantillonnage et le taux de sous-échantillonnage du modèle pour calculer les horodatages des caractères transcrits. Veuillez consulter l'exemple ci-dessous pour mieux comprendre comment utiliser `output_char_offsets`.

output_word_offsets (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non afficher les décalages des mots. Les décalages des mots peuvent être utilisés en combinaison avec le taux d'échantillonnage et le taux de sous-échantillonnage du modèle pour calculer les horodatages des mots transcrits. Veuillez consulter l'exemple ci-dessous pour mieux comprendre comment utiliser `output_word_offsets`.

kwargs (arguments supplémentaires, *facultatifs*) : Seront transmis à la méthode de décodage spécifique du modèle sous-jacent.

**Retourne :** `str` ou `Wav2Vec2CTCTokenizerOutput`

La liste des phrases décodées. Sera un `Wav2Vec2CTCTokenizerOutput` lorsque `output_char_offsets == True` ou `output_word_offsets == True`.

Convertit une séquence d’identifiants en chaîne de caractères, en utilisant le tokenizer et le vocabulaire, avec des options pour supprimer les jetons spéciaux et nettoyer les espaces de tokenization.

Similaire à l'exécution de `self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))`.

Exemple :

```python
>>> # Let's see how to retrieve time steps for a model
>>> from transformers import AutoTokenizer, AutoFeatureExtractor, AutoModelForCTC
>>> from datasets import load_dataset
>>> import datasets
>>> import torch

>>> # import model, feature extractor, tokenizer
>>> model = AutoModelForCTC.from_pretrained("facebook/wav2vec2-base-960h")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/wav2vec2-base-960h")
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base-960h")

>>> # load first sample of English common_voice
>>> dataset = load_dataset("mozilla-foundation/common_voice_11_0", "en", split="train", streaming=True)
>>> dataset = dataset.cast_column("audio", datasets.Audio(sampling_rate=16_000))
>>> dataset_iter = iter(dataset)
>>> sample = next(dataset_iter)

>>> # forward sample through model to get greedily predicted transcription ids
>>> input_values = feature_extractor(sample["audio"]["array"], return_tensors="pt").input_values
>>> logits = model(input_values).logits[0]
>>> pred_ids = torch.argmax(logits, axis=-1)

>>> # retrieve word stamps (analogous commands for `output_char_offsets`)
>>> outputs = tokenizer.decode(pred_ids, output_word_offsets=True)
>>> # compute `time_offset` in seconds as product of downsampling ratio and sampling_rate
>>> time_offset = model.config.inputs_to_logits_ratio / feature_extractor.sampling_rate

>>> word_offsets = [
...     {
...         "word": d["word"],
...         "start_time": round(d["start_offset"] * time_offset, 2),
...         "end_time": round(d["end_offset"] * time_offset, 2),
...     }
...     for d in outputs.word_offsets
... ]
>>> # compare word offsets with audio `en_train_0/common_voice_en_19121553.mp3` online on the dataset viewer:
>>> # https://huggingface.co/datasets/mozilla-foundation/common_voice_11_0/viewer/en
>>> word_offsets[:3]
[{'word': 'THE', 'start_time': 0.7, 'end_time': 0.78}, {'word': 'TRICK', 'start_time': 0.88, 'end_time': 1.08}, {'word': 'APPEARS', 'start_time': 1.2, 'end_time': 1.64}]
```

#### batch_decode[[transformers.Wav2Vec2CTCTokenizer.batch_decode]]

```python
batch_decode(sequences: typing.Union[list[int], list[list[int]], numpy.ndarray, ForwardRef('torch.Tensor')], skip_special_tokens: bool = False, clean_up_tokenization_spaces: bool | None = None, output_char_offsets: bool = False, output_word_offsets: bool = False, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/tokenization_wav2vec2.py#L468)

**Paramètres :**

sequences (`Union[list[int], list[list[int]], np.ndarray, torch.Tensor]`) : Liste des identifiants d'entrée tokenisés. Peut être obtenue à l'aide de la méthode `__call__`.

skip_special_tokens (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut supprimer les jetons spéciaux lors du décodage.

clean_up_tokenization_spaces (`bool`, *facultatif*) : Indique s'il faut nettoyer ou non les espaces de tokenisation.

output_char_offsets (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non afficher les décalages de caractères. Les décalages de caractères peuvent être utilisés en combinaison avec le taux d'échantillonnage et le taux de sous-échantillonnage du modèle pour calculer les horodatages des caractères transcrits.    Veuillez consulter l'exemple de [decode()](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer.decode) pour mieux comprendre comment utiliser `output_char_offsets`. [batch_decode()](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer.batch_decode) fonctionne de la même manière avec une sortie par lot.

output_word_offsets (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut ou non afficher les décalages des mots. Les décalages des mots peuvent être utilisés en combinaison avec le taux d'échantillonnage et le taux de sous-échantillonnage du modèle pour calculer les horodatages des mots transcrits. Veuillez consulter l'exemple de [decode()](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer.decode) pour mieux comprendre comment utiliser `output_word_offsets`. [batch_decode()](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer.batch_decode) fonctionne de la même manière avec une sortie par lot.

kwargs (arguments supplémentaires, *facultatifs*) : Seront transmis à la méthode de décodage spécifique du modèle sous-jacent.

**Retourne :** `list[str]` ou `Wav2Vec2CTCTokenizerOutput`

La liste des phrases décodées. Sera un `Wav2Vec2CTCTokenizerOutput` lorsque `output_char_offsets == True` ou `output_word_offsets == True`.

Convertir une liste de listes d'identifiants de jetons en une liste de chaînes en appelant decode.

#### set_target_lang[[transformers.Wav2Vec2CTCTokenizer.set_target_lang]]

```python
set_target_lang(target_lang: str)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/tokenization_wav2vec2.py#L184)

Définir la langue cible d'un dictionnaire multi-langue imbriqué

## Wav2Vec2FeatureExtractor[[transformers.Wav2Vec2FeatureExtractor]]

#### transformers.Wav2Vec2FeatureExtractor[[transformers.Wav2Vec2FeatureExtractor]]

```python
transformers.Wav2Vec2FeatureExtractor(feature_size = 1, sampling_rate = 16000, padding_value = 0.0, return_attention_mask = False, do_normalize = True, **kwargs)
```

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

**Paramètres :**

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

sampling_rate (`int`, *facultatif*, valeur par défaut 16000) : Le taux d'échantillonnage auquel les fichiers audio doivent être numérisés, exprimé en hertz (Hz).

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

do_normalize (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut normaliser l'entrée en moyenne nulle et variance unitaire. La normalisation peut contribuer à améliorer considérablement les performances de certains modèles, *par ex.*, [wav2vec2-lv60](https://huggingface.co/models?search=lv60).

return_attention_mask (`bool`, *facultatif*, valeur par défaut `False`) : Indique si [__call__()](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2FeatureExtractor.__call__) doit retourner `attention_mask`.    Les modèles Wav2Vec2 ayant défini `config.feat_extract_norm == "group"`, tels que [wav2vec2-base](https://huggingface.co/facebook/wav2vec2-base-960h), n'**ont** pas été entraînés en utilisant `attention_mask`. Pour ce type de modèles, `input_values` doit simplement être complété avec des 0 et aucun `attention_mask` ne doit être transmis.  Pour les modèles Wav2Vec2 ayant défini `config.feat_extract_norm == "layer"`, tels que [wav2vec2-lv60](https://huggingface.co/facebook/wav2vec2-large-960h-lv60-self), `attention_mask` doit être transmis pour une inférence par lots.

Construit un extracteur de fonctionnalités Wav2Vec2.

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

#### __appel__[[transformers.Wav2Vec2FeatureExtractor.__call__]]

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

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/feature_extraction_wav2vec2.py#L99)

**Paramètres :**

raw_speech (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`) : La séquence ou le lot de séquences à rembourrer. Chaque séquence peut être un tableau numpy, une liste de valeurs flottantes, une liste de tableaux numpy ou une liste de listes de valeurs flottantes. Doit être un audio mono, pas stéréo, c'est-à-dire un seul flottant par pas de temps.

padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/main/fr/internal/file_utils#transformers.utils.PaddingStrategy), *facultatif*, valeur par défaut `False`) : Sélectionne une stratégie pour mettre en place le padding des séquences renvoyées (selon le côté de padding et l'index de padding du modèle) parmi :  - `True` ou `'longest'` : Met en place le padding jusqu'à la séquence la plus longue du lot (ou aucun padding si une seule séquence est fournie). - `'max_length'` : Met en place le padding jusqu'à une longueur maximale spécifiée avec l'argument `max_length` ou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. - `False` ou `'do_not_pad'` (par défaut) : Aucun padding (c'est-à-dire, peut renvoyer un lot avec des séquences de longueurs différentes).

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

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

pad_to_multiple_of (`int`, *facultatif*) : Si défini, la séquence sera rembourdie jusqu'à un multiple de la valeur fournie. Cela est particulièrement utile pour permettre l'utilisation des Tensor Cores sur le matériel NVIDIA avec une capacité de calcul `>= 7.5` (Volta), ou sur les TPU qui bénéficient de longueurs de séquence multiples de 128.

return_attention_mask (`bool`, *facultatif*) : Indique s'il faut retourner le masque d'attention. Si la valeur par défaut est conservée, le masque d'attention est retourné selon la valeur par défaut du feature_extractor spécifique.  [Qu'est-ce que les masques d'attention ?](../glossary#attention-mask)    Les modèles Wav2Vec2 pour lesquels `config.feat_extract_norm == "group"` est défini, tels que [wav2vec2-base](https://huggingface.co/facebook/wav2vec2-base-960h), n'**ont pas** été entraînés en utilisant `attention_mask`. Pour ce type de modèles, `input_values` doit simplement être complété avec des 0 et aucun `attention_mask` ne doit être transmis.  Pour les modèles Wav2Vec2 pour lesquels `config.feat_extract_norm == "layer"` est défini, tels que [wav2vec2-lv60](https://huggingface.co/facebook/wav2vec2-large-960h-lv60-self), `attention_mask` doit être transmis pour une inférence par lots.

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

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

padding_value (`float`, *facultatif*, valeur par défaut 0.0) --

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

## Wav2Vec2Processor[[transformers.Wav2Vec2Processor]]

#### transformers.Wav2Vec2Processor[[transformers.Wav2Vec2Processor]]

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

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/processing_wav2vec2.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 Wav2Vec2Processor qui encapsule un extracteur de caractéristiques et un tokenizer en un seul processeur.

[Wav2Vec2Processor](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2Processor) 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.Wav2Vec2Processor.__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.processing_wav2vec2.Wav2Vec2ProcessorKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/processing_wav2vec2.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 :**

Cette méthode renvoie les résultats de chaque méthode `call`. Si les deux sont utilisées, la sortie est un dictionnaire contenant les résultats des deux.

#### pad[[transformers.Wav2Vec2Processor.pad]]

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

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/processing_wav2vec2.py#L65)

**Paramètres :**

input_features : Lorsque le premier argument est un dictionnaire contenant un lot de tenseurs, ou lorsque l'argument `input_features` est présent, il est transmis à [Wav2Vec2FeatureExtractor.pad()](/docs/transformers/main/fr/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad).

labels : Lorsque l'argument `label` est présent, il est transmis à [PreTrainedTokenizer.pad()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.pad).

**Retourne :**

Cette méthode renvoie les résultats de chaque méthode `pad`. Si les deux sont utilisées, la sortie est un dictionnaire contenant les résultats des deux.

Cette méthode opère sur des lots de caractéristiques extraites et/ou de texte tokenisé. Elle transmet tous les arguments à [Wav2Vec2FeatureExtractor.pad()](/docs/transformers/main/fr/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad) et/ou à [PreTrainedTokenizer.pad()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.pad) selon la modalité d'entrée, et renvoie leurs sorties. Si les deux modalités sont transmises, [Wav2Vec2FeatureExtractor.pad()](/docs/transformers/main/fr/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad) et [PreTrainedTokenizer.pad()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.pad) sont appelés.

#### from_pretrained[[transformers.Wav2Vec2Processor.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.Wav2Vec2Processor.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.Wav2Vec2Processor.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.Wav2Vec2Processor.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.

## Wav2Vec2ProcessorWithLM[[transformers.Wav2Vec2ProcessorWithLM]]

#### transformers.Wav2Vec2ProcessorWithLM[[transformers.Wav2Vec2ProcessorWithLM]]

```python
transformers.Wav2Vec2ProcessorWithLM(feature_extractor: FeatureExtractionMixin, tokenizer: PreTrainedTokenizerBase, decoder: BeamSearchDecoderCTC)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L69)

**Paramètres :**

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

tokenizer (`tokenizer_class`) : Le tokenizer est une entrée obligatoire.

decoder (`BeamSearchDecoderCTC`) : une instance de `pyctcdecode.BeamSearchDecoderCTC`. Le décodeur est une entrée obligatoire.

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

[Wav2Vec2ProcessorWithLM](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM) offre toutes les fonctionnalités de `feature_extractor_class` et de `tokenizer_class`. Consultez `~feature_extractor_class` et `~tokenizer_class` pour plus d'informations.

#### __appel__[[transformers.Wav2Vec2ProcessorWithLM.__call__]]

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

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L208)

**Paramètres :**

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.

#### pad[[transformers.Wav2Vec2ProcessorWithLM.pad]]

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

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L233)

Lorsqu'elle est utilisée en mode normal, cette méthode transmet tous ses arguments à `~FeatureExtractionMixin.pad` de l'extracteur de caractéristiques et renvoie sa sortie. Si elle est utilisée dans le contexte `~Wav2Vec2ProcessorWithLM.as_target_processor`, cette méthode transmet tous ses arguments à [pad()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.pad) du Wav2Vec2CTCTokenizer. Veuillez consulter la docstring des deux méthodes ci-dessus pour plus d'informations.

#### from_pretrained[[transformers.Wav2Vec2ProcessorWithLM.from_pretrained]]

```python
from_pretrained(pretrained_model_name_or_path, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L106)

**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 à [SequenceFeatureExtractor](/docs/transformers/main/fr/main_classes/feature_extractor#transformers.SequenceFeatureExtractor) et à [PreTrainedTokenizer](/docs/transformers/main/fr/main_classes/tokenizer#transformers.PythonBackend)

Instanciez un [Wav2Vec2ProcessorWithLM](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM) à partir d'un processeur Wav2Vec2 pré-entraîné.

Cette méthode de classe appelle simplement [from_pretrained()](/docs/transformers/main/fr/main_classes/feature_extractor#transformers.FeatureExtractionMixin.from_pretrained) de l'extracteur de caractéristiques, [from_pretrained()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.from_pretrained) de Wav2Vec2CTCTokenizer et `pyctcdecode.BeamSearchDecoderCTC.load_from_hf_hub`.

Veuillez consulter les docstrings des méthodes ci-dessus pour plus d'informations.

#### save_pretrained[[transformers.Wav2Vec2ProcessorWithLM.save_pretrained]]

```python
save_pretrained(save_directory)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L102)

#### batch_decode[[transformers.Wav2Vec2ProcessorWithLM.batch_decode]]

```python
batch_decode(logits: ndarray, pool: multiprocessing.pool.Pool | None = None, num_processes: int | None = None, beam_width: int | None = None, beam_prune_logp: float | None = None, token_min_logp: float | None = None, hotwords: collections.abc.Iterable[str] | None = None, hotword_weight: float | None = None, alpha: float | None = None, beta: float | None = None, unk_score_offset: float | None = None, lm_score_boundary: bool | None = None, output_word_offsets: bool = False, n_best: int = 1)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L260)

**Paramètres :**

logits (`np.ndarray`) : Vecteur de sortie des logits du modèle représentant les log-probabilités pour chaque jeton.

pool (`multiprocessing.Pool`, *facultatif*) : Un pool géré par l'utilisateur, facultatif. S'il n'est pas défini, un pool sera automatiquement créé puis fermé. Le pool doit être instancié *après* `Wav2Vec2ProcessorWithLM`. Sinon, le LM ne sera pas disponible pour les sous-processus du pool.    Actuellement, seuls les pools créés avec un contexte « fork » peuvent être utilisés. Si un pool « spawn » est transmis, il sera ignoré et un décodage séquentiel sera utilisé à la place.

num_processes (`int`, *facultatif*) : Si `pool` n'est pas défini, nombre de processus sur lesquels la fonction doit être parallélisée. Par défaut, correspond au nombre de CPU disponibles.

beam_width (`int`, *facultatif*) : Nombre maximal de faisceaux à chaque étape du décodage. Par défaut, la valeur est DEFAULT_BEAM_WIDTH de pyctcdecode.

beam_prune_logp (`int`, *facultatif*) : Les faisceaux beaucoup moins bons que le meilleur faisceau seront élagués. La valeur par défaut est DEFAULT_PRUNE_LOGP de pyctcdecode.

token_min_logp (`int`, *facultatif*) : Les jetons dont le logp est inférieur à cette valeur sont ignorés, sauf s'ils sont l'argmax de la trame. La valeur par défaut est DEFAULT_MIN_TOKEN_LOGP de pyctcdecode.

hotwords (`list[str]`, *facultatif*) : Liste de mots ayant une importance accrue, pouvant être OOV pour le LM

hotword_weight (`int`, *facultatif*) : Facteur de pondération de l'importance des mots-clés. La valeur par défaut est DEFAULT_HOTWORD_WEIGHT de pyctcdecode.

alpha (`float`, *facultatif*) : Poids du modèle de langage lors de la fusion superficielle

beta (`float`, *facultatif*) : Poids pour l'ajustement de la longueur lors de la notation

unk_score_offset (`float`, *facultatif*) : Quantité de décalage du score de journalisation pour les jetons inconnus

lm_score_boundary (`bool`, *facultatif*) : Indique si kenlm doit respecter les limites lors de l'évaluation

output_word_offsets (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non afficher les décalages des mots. Les décalages des mots peuvent être utilisés en combinaison avec le taux d'échantillonnage et le taux de sous-échantillonnage du modèle pour calculer les horodatages des mots transcrits.

n_best (`int`, *facultatif*, valeur par défaut `1`) : Nombre d'hypothèses optimales à retourner. Si `n_best` est supérieur à 1, le `text` retourné sera une liste de listes de chaînes de caractères, `logit_score` sera une liste de listes de flottants, et `lm_score` sera une liste de listes de flottants, où la longueur de la liste externe correspondra à la taille du lot et la longueur de la liste interne correspondra au nombre d'hypothèses retournées. La valeur doit être >= 1. Veuillez consulter l'exemple de [decode()](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM.decode) pour mieux comprendre comment utiliser `output_word_offsets`. [batch_decode()](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM.batch_decode) fonctionne de la même manière avec une sortie par lot.

**Retourne :**

`~models.wav2vec2.Wav2Vec2DecoderWithLMOutput`.

Décoder par lots les logits de sortie en transcription audio avec prise en charge des modèles de langage.

Cette fonction utilise le module multiprocessing de Python. Actuellement, multiprocessing n'est disponible que sur les systèmes Unix (voir ce [billet](https://github.com/kensho-technologies/pyctcdecode/issues/65)).

Si vous décodez plusieurs lots, envisagez de créer un `Pool` et de le passer à `batch_decode`. Sinon, `batch_decode` sera très lent, car il créera un `Pool` neuf pour chaque appel. Consultez l’exemple d’utilisation ci-dessous.

Exemple : voir [Décodage de plusieurs audios](#decoding-multiple-audios).

#### decode[[transformers.Wav2Vec2ProcessorWithLM.decode]]

```python
decode(logits: ndarray, beam_width: int | None = None, beam_prune_logp: float | None = None, token_min_logp: float | None = None, hotwords: collections.abc.Iterable[str] | None = None, hotword_weight: float | None = None, alpha: float | None = None, beta: float | None = None, unk_score_offset: float | None = None, lm_score_boundary: bool | None = None, output_word_offsets: bool = False, n_best: int = 1)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L445)

**Paramètres :**

logits (`np.ndarray`) : Vecteur de sortie des logits du modèle représentant les log-probabilités pour chaque jeton.

beam_width (`int`, *facultatif*) : Nombre maximal de faisceaux à chaque étape du décodage. Par défaut, la valeur est DEFAULT_BEAM_WIDTH de pyctcdecode.

beam_prune_logp (`int`, *facultatif*) : Un seuil pour élaguer les faisceaux dont les log-probabilités sont inférieures à best_beam_logp + beam_prune_logp. La valeur doit être <= 0. Par défaut, la valeur de DEFAULT_PRUNE_LOGP de pyctcdecode est utilisée.

token_min_logp (`int`, *facultatif*) : Les jetons dont la log-probabilité est inférieure à token_min_logp sont ignorés, sauf s'ils ont la log-probabilité maximale pour une énonciation. La valeur par défaut est DEFAULT_MIN_TOKEN_LOGP de pyctcdecode.

hotwords (`list[str]`, *facultatif*) : Liste de mots ayant une importance particulière qui peuvent être absents du vocabulaire du LM, par exemple ["huggingface"]

hotword_weight (`int`, *facultatif*) : Multiplicateur de poids qui augmente les scores des mots-clés. Par défaut, la valeur est DEFAULT_HOTWORD_WEIGHT de pyctcdecode.

alpha (`float`, *facultatif*) : Poids du modèle de langage lors de la fusion superficielle

beta (`float`, *facultatif*) : Poids pour l'ajustement de la longueur lors de la notation

unk_score_offset (`float`, *facultatif*) : Quantité de décalage du score de journalisation pour les jetons inconnus

lm_score_boundary (`bool`, *facultatif*) : Indique si kenlm doit respecter les limites lors de l'évaluation

output_word_offsets (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non afficher les décalages des mots. Les décalages des mots peuvent être utilisés en combinaison avec le taux d'échantillonnage et le taux de sous-échantillonnage du modèle pour calculer les horodatages des mots transcrits.

n_best (`int`, *facultatif*, valeur par défaut `1`) : Nombre d'hypothèses les plus probables à retourner. Si `n_best` est supérieur à 1, le `text` retourné sera une liste de chaînes de caractères, `logit_score` sera une liste de flottants et `lm_score` sera une liste de flottants, la longueur de ces listes correspondant au nombre d'hypothèses retournées. La valeur doit être >= 1.    Consultez l'exemple ci-dessous pour mieux comprendre comment utiliser `output_word_offsets`.

**Retourne :**

`~models.wav2vec2.Wav2Vec2DecoderWithLMOutput`.

Décoder les logits de sortie en transcription audio avec prise en charge des modèles de langage.

Exemple :

```python
>>> # Let's see how to retrieve time steps for a model
>>> from transformers import AutoTokenizer, AutoProcessor, AutoModelForCTC
>>> from datasets import load_dataset
>>> import datasets
>>> import torch

>>> # import model, feature extractor, tokenizer
>>> model = AutoModelForCTC.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm")
>>> processor = AutoProcessor.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm")

>>> # load first sample of English common_voice
>>> dataset = load_dataset("mozilla-foundation/common_voice_11_0", "en", split="train", streaming=True)
>>> dataset = dataset.cast_column("audio", datasets.Audio(sampling_rate=16_000))
>>> dataset_iter = iter(dataset)
>>> sample = next(dataset_iter)

>>> # forward sample through model to get greedily predicted transcription ids
>>> input_values = processor(sample["audio"]["array"], return_tensors="pt").input_values
>>> with torch.no_grad():
...     logits = model(input_values).logits[0].cpu().numpy()

>>> # retrieve word stamps (analogous commands for `output_char_offsets`)
>>> outputs = processor.decode(logits, output_word_offsets=True)
>>> # compute `time_offset` in seconds as product of downsampling ratio and sampling_rate
>>> time_offset = model.config.inputs_to_logits_ratio / processor.feature_extractor.sampling_rate

>>> word_offsets = [
...     {
...         "word": d["word"],
...         "start_time": round(d["start_offset"] * time_offset, 2),
...         "end_time": round(d["end_offset"] * time_offset, 2),
...     }
...     for d in outputs.word_offsets
... ]
>>> # compare word offsets with audio `en_train_0/common_voice_en_19121553.mp3` online on the dataset viewer:
>>> # https://huggingface.co/datasets/mozilla-foundation/common_voice_11_0/viewer/en
>>> word_offsets[:4]
[{'word': 'THE', 'start_time': 0.68, 'end_time': 0.78}, {'word': 'TRACK', 'start_time': 0.88, 'end_time': 1.1}, {'word': 'APPEARS', 'start_time': 1.18, 'end_time': 1.66}, {'word': 'ON', 'start_time': 1.86, 'end_time': 1.92}]
```

### Décodage de plusieurs audios

Si vous prévoyez de décoder plusieurs lots d’audios, il est recommandé d’utiliser [batch_decode()](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM.batch_decode) et de transmettre une instance de `multiprocessing.Pool`. Sinon, les performances de [batch_decode()](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM.batch_decode) seront inférieures à celles obtenues en appelant [decode()](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM.decode) pour chaque audio individuellement, car une nouvelle instance de `Pool` est créée à chaque appel. Voir l’exemple ci-dessous :

```python
# Let's see how to use a user-managed pool for batch decoding multiple audios
from multiprocessing import get_context

import datasets
import torch
from datasets import load_dataset

from transformers import AutoModelForCTC, AutoProcessor

# import model, feature extractor, tokenizer
model = AutoModelForCTC.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm", device_map="auto")
processor = AutoProcessor.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm")

# load example dataset
dataset = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
dataset = dataset.cast_column("audio", datasets.Audio(sampling_rate=16_000))

def map_to_array(example):
    example["speech"] = example["audio"]["array"]
    return example

# prepare speech data for batch inference
dataset = dataset.map(map_to_array, remove_columns=["audio"])

def map_to_pred(batch, pool):
    inputs = processor(batch["speech"], sampling_rate=16_000, padding=True, return_tensors="pt").to(model.device)
    inputs = {k: v.to(model.device) for k, v in inputs.items()}

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

    transcription = processor.batch_decode(logits.cpu().numpy(), pool).text
    batch["transcription"] = transcription
    return batch

# note: pool should be instantiated *after* `Wav2Vec2ProcessorWithLM`.
#       otherwise, the LM won't be available to the pool's sub-processes
# select number of processes and batch_size based on number of CPU cores available and on dataset size
with get_context("fork").Pool(processes=2) as pool:
    result = dataset.map(
        map_to_pred, batched=True, batch_size=2, fn_kwargs={"pool": pool}, remove_columns=["speech"]
    )

result["transcription"][:2]
['MISTER QUILTER IS THE APOSTLE OF THE MIDDLE CLASSES AND WE ARE GLAD TO WELCOME HIS GOSPEL', "NOR IS MISTER COULTER'S MANNER LESS INTERESTING THAN HIS MATTER"]
```

## Sorties spécifiques à Wav2Vec2[[transformers.models.wav2vec2_with_lm.processing_wav2vec2_with_lm.Wav2Vec2DecoderWithLMOutput]]

#### transformers.models.wav2vec2_with_lm.processing_wav2vec2_with_lm.Wav2Vec2DecoderWithLMOutput[[transformers.models.wav2vec2_with_lm.processing_wav2vec2_with_lm.Wav2Vec2DecoderWithLMOutput]]

```python
transformers.models.wav2vec2_with_lm.processing_wav2vec2_with_lm.Wav2Vec2DecoderWithLMOutput(text: list[list[str]] | list[str] | str, logit_score: list[list[float]] | list[float] | float = None, lm_score: list[list[float]] | list[float] | float = None, word_offsets: list[list[list[dict[str, int | str]]]] | list[list[dict[str, int | str]]] | list[dict[str, int | str]] = None)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_with_lm/processing_wav2vec2_with_lm.py#L46)

**Paramètres :**

text (liste de `str` ou `str`) : Logits décodés en texte. Généralement, la transcription vocale.

logit_score (liste de `float` ou `float`) : Score logit total des faisceaux associés au texte produit.

lm_score (liste de `float`) : lm_score fusionné des faisceaux associés au texte produit.

word_offsets (liste de `list[dict[str, Union[int, str]]]` ou `list[dict[str, Union[int, str]]]`) : Décalages des mots décodés. Combinés au taux d'échantillonnage et au taux de sous-échantillonnage du modèle, les décalages des mots permettent de calculer les horodatages de chaque mot.

Type de sortie de `Wav2Vec2DecoderWithLM`, avec transcription.

#### transformers.modeling_outputs.Wav2Vec2BaseModelOutput[[transformers.modeling_outputs.Wav2Vec2BaseModelOutput]]

```python
transformers.modeling_outputs.Wav2Vec2BaseModelOutput(last_hidden_state: typing.Optional[torch.Tensor] = None, extract_features: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

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

**Paramètres :**

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.

Classe de base pour les modèles entraînés avec l'objectif de perte Wav2Vec2.

#### transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput[[transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput]]

```python
transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput(loss: typing.Optional[torch.Tensor] = None, projected_states: typing.Optional[torch.Tensor] = None, projected_quantized_states: typing.Optional[torch.Tensor] = None, codevector_perplexity: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor] | None = None, attentions: tuple[torch.Tensor] | None = None, contrastive_loss: typing.Optional[torch.Tensor] = None, diversity_loss: typing.Optional[torch.Tensor] = None)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L75)

**Paramètres :**

loss (`*optional*`, returned when `sample_negative_indices` are passed, `torch.Tensor` of shape `(1,)`) : Perte totale, définie comme la somme de la perte contrastive (L_m) et de la perte de diversité (L_d), conformément au [papier officiel](https://huggingface.co/papers/2006.11477).

projected_states (`torch.Tensor` de forme `(batch_size, sequence_length, config.proj_codevector_dim)`) : États cachés du modèle projetés sur *config.proj_codevector_dim* qui peuvent être utilisés pour prédire les états quantifiés projetés masqués.

projected_quantized_states (`torch.Tensor` de forme `(batch_size, sequence_length, config.proj_codevector_dim)`) : Vecteurs de caractéristiques extraites quantifiés et projetés sur *config.proj_codevector_dim*, représentant les vecteurs cibles positifs pour la perte contrastive.

codevector_perplexity (`torch.Tensor` de forme `(1,)`) : La perplexité de la distribution des codevectors, utilisée pour mesurer la diversité du codebook.

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’embedding 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.

contrastive_loss (`*optional*`, returned when `sample_negative_indices` are passed, `torch.Tensor` of shape `(1,)`) : The contrastive loss (L_m) as stated in the [official paper](https://huggingface.co/papers/2006.11477).

diversity_loss (`*optional*`, returned when `sample_negative_indices` are passed, `torch.Tensor` of shape `(1,)`) : The diversity loss (L_d) as stated in the [official paper](https://huggingface.co/papers/2006.11477).

Type de sortie de [Wav2Vec2ForPreTraining](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2ForPreTraining), avec états cachés et attentions éventuels.

## Wav2Vec2Model[[transformers.Wav2Vec2Model]]

#### transformers.Wav2Vec2Model[[transformers.Wav2Vec2Model]]

```python
transformers.Wav2Vec2Model(config: Wav2Vec2Config)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1194)

**Paramètres :**

config ([Wav2Vec2Config](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2Config)) : 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 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.Wav2Vec2Model.forward]]

```python
forward(input_values: 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/modeling_wav2vec2.py#L1268)

**Paramètres :**

input_values (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Valeurs flottantes de la forme d'onde brute de l'entrée audio. Les valeurs peuvent être obtenues en chargeant un fichier audio `.flac` ou `.wav` dans un tableau de type `list[float]`, un `numpy.ndarray` ou un `torch.Tensor`, *par exemple* via la bibliothèque torchcodec (`pip install torchcodec`) ou la bibliothèque soundfile (`pip install soundfile`). Pour préparer le tableau en `input_values`, le [AutoProcessor](/docs/transformers/main/fr/model_doc/auto#transformers.AutoProcessor) doit être utilisé pour le bourrage (padding) et la conversion en un tenseur de type `torch.Tensor`. Voir [Wav2Vec2Processor.__call__()](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) pour plus de détails.

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

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 ([Wav2Vec2Config](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2Config)) et les entrées.

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

## Wav2Vec2ForCTC[[transformers.Wav2Vec2ForCTC]]

#### transformers.Wav2Vec2ForCTC[[transformers.Wav2Vec2ForCTC]]

```python
transformers.Wav2Vec2ForCTC(config: Wav2Vec2Config, target_lang: str | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1522)

**Paramètres :**

config ([Wav2Vec2Config](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2Config)) : 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 [Wav2Vec2ForCTC](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC) avec des adaptateurs. Utilise 'eng' par défaut.

Modèle Wav2Vec2 avec une tête de `language modeling` en haut 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.Wav2Vec2ForCTC.forward]]

```python
forward(input_values: 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/modeling_wav2vec2.py#L1591)

**Paramètres :**

input_values (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Valeurs flottantes de la forme d'onde brute de l'entrée audio. Les valeurs peuvent être obtenues en chargeant un fichier audio `.flac` ou `.wav` dans un tableau de type `list[float]`, un `numpy.ndarray` ou un `torch.Tensor`, *par exemple* via la bibliothèque torchcodec (`pip install torchcodec`) ou la bibliothèque soundfile (`pip install soundfile`). Pour préparer le tableau en `input_values`, le [AutoProcessor](/docs/transformers/main/fr/model_doc/auto#transformers.AutoProcessor) doit être utilisé pour le bourrage (padding) et la conversion en un tenseur de type `torch.Tensor`. Voir [Wav2Vec2Processor.__call__()](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) pour plus de détails.

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

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 selon la configuration ([Wav2Vec2Config](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2Config)) et les entrées.

La méthode forward de [Wav2Vec2ForCTC](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2ForCTC) 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, Wav2Vec2ForCTC
>>> 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/wav2vec2-base-960h")
>>> model = Wav2Vec2ForCTC.from_pretrained("facebook/wav2vec2-base-960h")

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

#### load_adapter[[transformers.Wav2Vec2ForCTC.load_adapter]]

```python
load_adapter(target_lang: str, force_load = True, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1017)

**Paramètres :**

target_lang (`str`) : Doit être un identifiant de langue d'un poids d'adaptateur existant. Les poids d'adaptateur sont stockés au format adapter..safetensors ou adapter..bin

force_load (`bool`, par défaut `True`) : Indique si les poids doivent être chargés même si `target_lang` correspond à `self.target_lang`.

cache_dir (`Union[str, os.PathLike]`, *facultatif*) : Chemin vers un répertoire dans lequel la configuration d'un modèle pré-entraîné téléchargé doit être mise en cache si le cache standard ne doit pas être utilisé.

force_download (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut forcer le (re)téléchargement des poids du modèle et des fichiers de configuration, en ignorant les versions mises en cache le cas échéant.

proxies (`dict[str, str]`, *facultatif*) : Un dictionnaire de serveurs proxy à utiliser par protocole ou point de terminaison, par exemple `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. Les proxys sont utilisés pour chaque requête.

local_files_only(`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut uniquement consulter les fichiers locaux (c'est-à-dire ne pas tenter de télécharger le modèle).

token (`str` ou `bool`, *facultatif*) : Jeton à utiliser comme autorisation HTTP bearer pour les fichiers distants. Si `True`, ou non spécifié, le jeton généré lors de l'exécution de `hf auth login` (stocké dans `~/.huggingface`) sera utilisé.

revision (`str`, *facultatif*, valeur par défaut `"main"`) : La version spécifique du modèle à utiliser. Il peut s'agir d'un nom de branche, d'un nom de tag ou d'un identifiant de commit, car nous utilisons un système basé sur git pour stocker les modèles et autres artefacts sur huggingface.co, de sorte que `revision` peut être n'importe quel identifiant autorisé par git. Pour tester une pull request que vous avez créée sur le Hub, vous pouvez passer `revision="refs/pr/<pr_number>"`.

mirror (`str`, *facultatif*) : Source miroir pour accélérer les téléchargements en Chine. Si vous êtes en Chine et rencontrez des problèmes d'accès, vous pouvez définir cette option pour les résoudre. Veuillez noter que nous ne garantissons ni la réactivité ni la sécurité. Reportez-vous au site miroir pour plus d'informations.

Charger un modèle d’adaptateur de langage à partir d’un modèle d’adaptateur pré-entraîné.

Activez le mode spécial ["offline-mode"](https://huggingface.co/transformers/installation.html#offline-mode) pour utiliser cette méthode dans un environnement protégé par un pare-feu.

Exemples :

```python
>>> from transformers import Wav2Vec2ForCTC, AutoProcessor

>>> ckpt = "facebook/mms-1b-all"
>>> processor = AutoProcessor.from_pretrained(ckpt)
>>> model = Wav2Vec2ForCTC.from_pretrained(ckpt, target_lang="eng")
>>> # set specific language
>>> processor.tokenizer.set_target_lang("spa")
>>> model.load_adapter("spa")
```

## Wav2Vec2ForSequenceClassification[[transformers.Wav2Vec2ForSequenceClassification]]

#### transformers.Wav2Vec2ForSequenceClassification[[transformers.Wav2Vec2ForSequenceClassification]]

```python
transformers.Wav2Vec2ForSequenceClassification(config: Wav2Vec2Config)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1649)

**Paramètres :**

config ([Wav2Vec2Config](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2Config)) : 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 Wav2Vec2 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 la détection de mots-clés SUPERB.

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

```python
forward(input_values: 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/modeling_wav2vec2.py#L1682)

**Paramètres :**

input_values (`torch.Tensor` de forme `(batch_size, sequence_length)`) : Valeurs flottantes de la forme d'onde brute de l'audio d'entrée. Les valeurs peuvent être obtenues en chargeant un fichier audio `.flac` ou `.wav` dans un tableau de type `list[float]`, un `numpy.ndarray` ou un `torch.Tensor`, *par exemple* via la bibliothèque torchcodec (`pip install torchcodec`) ou la bibliothèque soundfile (`pip install soundfile`). Pour préparer le tableau en `input_values`, le [AutoProcessor](/docs/transformers/main/fr/model_doc/auto#transformers.AutoProcessor) doit être utilisé pour le bourrage (padding) et la conversion en un tenseur de type `torch.Tensor`. Voir [Wav2Vec2Processor.__call__()](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) pour plus de détails.

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

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 ([Wav2Vec2Config](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2Config)) et les entrées.

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

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = Wav2Vec2ForSequenceClassification.from_pretrained("facebook/wav2vec2-base-960h")

>>> 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 = Wav2Vec2ForSequenceClassification.from_pretrained("facebook/wav2vec2-base-960h", 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, Wav2Vec2ForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = Wav2Vec2ForSequenceClassification.from_pretrained("facebook/wav2vec2-base-960h", 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 = Wav2Vec2ForSequenceClassification.from_pretrained(
...     "facebook/wav2vec2-base-960h", 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
```

## Wav2Vec2ForAudioFrameClassification[[transformers.Wav2Vec2ForAudioFrameClassification]]

#### transformers.Wav2Vec2ForAudioFrameClassification[[transformers.Wav2Vec2ForAudioFrameClassification]]

```python
transformers.Wav2Vec2ForAudioFrameClassification(config: Wav2Vec2Config)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1742)

**Paramètres :**

config ([Wav2Vec2Config](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2Config)) : 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 avec une tête de classification par 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.Wav2Vec2ForAudioFrameClassification.forward]]

```python
forward(input_values: 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/modeling_wav2vec2.py#L1774)

**Paramètres :**

input_values (`torch.Tensor` de forme `(batch_size, sequence_length)`) : Valeurs flottantes de la forme d'onde brute de l'audio d'entrée. Les valeurs peuvent être obtenues en chargeant un fichier audio `.flac` ou `.wav` dans un tableau de type `list[float]`, un `numpy.ndarray` ou un `torch.Tensor`, *par exemple* via la bibliothèque torchcodec (`pip install torchcodec`) ou la bibliothèque soundfile (`pip install soundfile`). Pour préparer le tableau en `input_values`, le [AutoProcessor](/docs/transformers/main/fr/model_doc/auto#transformers.AutoProcessor) doit être utilisé pour le bourrage (padding) et la conversion en un tenseur de type `torch.Tensor`. Voir [Wav2Vec2Processor.__call__()](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) pour plus de détails.

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

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 ([Wav2Vec2Config](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2Config)) et les entrées.

La méthode forward de [Wav2Vec2ForAudioFrameClassification](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2ForAudioFrameClassification) 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, Wav2Vec2ForAudioFrameClassification
>>> 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/wav2vec2-base-960h")
>>> model = Wav2Vec2ForAudioFrameClassification.from_pretrained("facebook/wav2vec2-base-960h")

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

## Wav2Vec2ForXVector[[transformers.Wav2Vec2ForXVector]]

#### transformers.Wav2Vec2ForXVector[[transformers.Wav2Vec2ForXVector]]

```python
transformers.Wav2Vec2ForXVector(config: Wav2Vec2Config)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1888)

**Paramètres :**

config ([Wav2Vec2Config](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2Config)) : 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 Wav2Vec2 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.Wav2Vec2ForXVector.forward]]

```python
forward(input_values: 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/modeling_wav2vec2.py#L1938)

**Paramètres :**

input_values (`torch.Tensor` de forme `(batch_size, sequence_length)`) : Valeurs flottantes de la forme d'onde brute de l'audio d'entrée. Les valeurs peuvent être obtenues en chargeant un fichier audio `.flac` ou `.wav` dans un tableau de type `list[float]`, un `numpy.ndarray` ou un `torch.Tensor`, *par exemple* via la bibliothèque torchcodec (`pip install torchcodec`) ou la bibliothèque soundfile (`pip install soundfile`). Pour préparer le tableau en `input_values`, le [AutoProcessor](/docs/transformers/main/fr/model_doc/auto#transformers.AutoProcessor) doit être utilisé pour le bourrage (padding) et la conversion en un tenseur de type `torch.Tensor`. Voir [Wav2Vec2Processor.__call__()](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) pour plus de détails.

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

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 ([Wav2Vec2Config](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2Config)) et les entrées.

La méthode forward de [Wav2Vec2ForXVector](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2ForXVector) 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, Wav2Vec2ForXVector
>>> 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/wav2vec2-base-960h")
>>> model = Wav2Vec2ForXVector.from_pretrained("facebook/wav2vec2-base-960h")

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

## Wav2Vec2ForPreTraining[[transformers.Wav2Vec2ForPreTraining]]

#### transformers.Wav2Vec2ForPreTraining[[transformers.Wav2Vec2ForPreTraining]]

```python
transformers.Wav2Vec2ForPreTraining(config: Wav2Vec2Config)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1319)

**Paramètres :**

config ([Wav2Vec2Config](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2Config)) : 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 Wav2Vec2 avec un quantificateur et une tête `VQ` 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.Wav2Vec2ForPreTraining.forward]]

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

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2/modeling_wav2vec2.py#L1367)

**Paramètres :**

input_values (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Valeurs flottantes de la forme d'onde brute de l'entrée audio. Les valeurs peuvent être obtenues en chargeant un fichier audio `.flac` ou `.wav` dans un tableau de type `list[float]`, un `numpy.ndarray` ou un `torch.Tensor`, *par exemple* via la bibliothèque torchcodec (`pip install torchcodec`) ou la bibliothèque soundfile (`pip install soundfile`). Pour préparer le tableau en `input_values`, le [AutoProcessor](/docs/transformers/main/fr/model_doc/auto#transformers.AutoProcessor) doit être utilisé pour le bourrage (padding) et la conversion en un tenseur de type `torch.Tensor`. Voir [Wav2Vec2Processor.__call__()](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) pour plus de détails.

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

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

sampled_negative_indices (`torch.BoolTensor` de forme `(batch_size, sequence_length, num_negatives)`, *facultatif*) : Indices indiquant quels vecteurs cibles quantifiés sont utilisés comme vecteurs négatifs échantillonnés dans la perte contrastive. Entrée requise pour la pré-formation.

**Retourne :** [Wav2Vec2ForPreTrainingOutput](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput) ou `tuple(torch.Tensor)`

Un [Wav2Vec2ForPreTrainingOutput](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput) 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 ([Wav2Vec2Config](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2Config)) et les entrées.

La méthode forward de [Wav2Vec2ForPreTraining](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2ForPreTraining) 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** (`*optional*`, returned when `sample_negative_indices` are passed, `torch.Tensor` of shape `(1,)`) -- Total loss as the sum of the contrastive loss (L_m) and the diversity loss (L_d) as stated in the [official paper](https://huggingface.co/papers/2006.11477).
- **projected_states** (`torch.Tensor` de forme `(batch_size, sequence_length, config.proj_codevector_dim)`) -- États cachés du modèle projetés sur *config.proj_codevector_dim*, utilisables pour prédire les états quantifiés masqués projetés.
- **projected_quantized_states** (`torch.Tensor` de forme `(batch_size, sequence_length, config.proj_codevector_dim)`) -- Vecteurs de caractéristiques extraits et quantifiés, projetés sur *config.proj_codevector_dim*, représentant les vecteurs cibles positifs pour la perte contrastive.
- **codevector_perplexity** (`torch.Tensor` de forme `(1,)`) -- La perplexité de la distribution des codevectors, utilisée pour mesurer la diversité du codebook.
- **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.
- **contrastive_loss** (`*optional*`, returned when `sample_negative_indices` are passed, `torch.Tensor` of shape `(1,)`) -- La perte contrastive (L_m) telle que définie dans l'[article officiel](https://huggingface.co/papers/2006.11477).
- **diversity_loss** (`*optional*`, returned when `sample_negative_indices` are passed, `torch.Tensor` of shape `(1,)`) -- The diversity loss (L_d) as stated in the [official paper](https://huggingface.co/papers/2006.11477).

Exemple :

```python
>>> import torch
>>> from transformers import AutoFeatureExtractor, Wav2Vec2ForPreTraining
>>> from transformers.models.wav2vec2.modeling_wav2vec2 import _compute_mask_indices, _sample_negative_indices
>>> from datasets import load_dataset

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base")
>>> model = Wav2Vec2ForPreTraining.from_pretrained("facebook/wav2vec2-base")

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> input_values = feature_extractor(ds[0]["audio"]["array"], return_tensors="pt").input_values  # Batch size 1

>>> # compute masked indices
>>> batch_size, raw_sequence_length = input_values.shape
>>> sequence_length = model._get_feat_extract_output_lengths(raw_sequence_length).item()
>>> mask_time_indices = _compute_mask_indices(
...     shape=(batch_size, sequence_length), mask_prob=0.2, mask_length=2
... )
>>> sampled_negative_indices = _sample_negative_indices(
...     features_shape=(batch_size, sequence_length),
...     num_negatives=model.config.num_negatives,
...     mask_time_indices=mask_time_indices,
... )
>>> mask_time_indices = torch.tensor(data=mask_time_indices, device=input_values.device, dtype=torch.long)
>>> sampled_negative_indices = torch.tensor(
...     data=sampled_negative_indices, device=input_values.device, dtype=torch.long
... )

>>> with torch.no_grad():
...     outputs = model(input_values, mask_time_indices=mask_time_indices)

>>> # compute cosine similarity between predicted (=projected_states) and target (=projected_quantized_states)
>>> cosine_sim = torch.cosine_similarity(outputs.projected_states, outputs.projected_quantized_states, dim=-1)

>>> # show that cosine similarity is much higher than random
>>> cosine_sim[mask_time_indices.to(torch.bool)].mean() > 0.5
tensor(True)

>>> # for contrastive loss training model should be put into train mode
>>> model = model.train()
>>> loss = model(
...     input_values, mask_time_indices=mask_time_indices, sampled_negative_indices=sampled_negative_indices
... ).loss
```