# Extracteurs de caractéristiques

Les extracteurs de caractéristiques prétraitent les données audio pour les mettre au format approprié à un modèle donné. Ils prennent le signal audio brut et le convertissent en un tenseur pouvant être transmis à un modèle. La forme du tenseur dépend du modèle, mais l'extracteur de caractéristiques prétraitera correctement les données audio en fonction du modèle utilisé. Les extracteurs de caractéristiques incluent également des méthodes pour le bourrage (padding), la troncature et le rééchantillonnage.

Appel de [from_pretrained()](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoFeatureExtractor.from_pretrained) pour charger un extracteur de caractéristiques et sa configuration de préprocesseur depuis le [Hub](https://hf.co/models) Hugging Face ou un répertoire local. La configuration de l'extracteur de caractéristiques et du préprocesseur est enregistrée dans un fichier [preprocessor_config.json](https://hf.co/openai/whisper-tiny/blob/main/preprocessor_config.json).

Transmettez le signal audio, généralement stocké dans `array`, à l’extracteur de caractéristiques et définissez le paramètre `sampling_rate` sur la fréquence d’échantillonnage du modèle audio préentraîné. Il est important que la fréquence d’échantillonnage des données audio corresponde à celle des données sur lesquelles le modèle audio préentraîné a été entraîné.

```py
from transformers import AutoFeatureExtractor

feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base")
dataset = load_dataset("PolyAI/minds14", name="en-US", split="train")
processed_sample = feature_extractor(dataset[0]["audio"]["array"], sampling_rate=16000)
processed_sample
{'input_values': [array([ 9.4472744e-05,  3.0777880e-03, -2.8888427e-03, ...,
       -2.8888427e-03,  9.4472744e-05,  9.4472744e-05], dtype=float32)]}
```

L'extracteur de caractéristiques renvoie une entrée, `input_values`, prête à être consommée par le modèle.

Ce guide vous présente les classes d'extracteurs de caractéristiques et la façon de prétraiter les données audio.

## Classes d'extracteurs de caractéristiques

Les extracteurs de fonctionnalités de Transformers héritent de la classe de base [SequenceFeatureExtractor](/docs/transformers/v5.23.0/fr/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), qui est une sous-classe de [FeatureExtractionMixin](/docs/transformers/v5.23.0/fr/main_classes/feature_extractor#transformers.FeatureExtractionMixin).

- [SequenceFeatureExtractor](/docs/transformers/v5.23.0/fr/main_classes/feature_extractor#transformers.SequenceFeatureExtractor) fournit une méthode pour [pad()](/docs/transformers/v5.23.0/fr/main_classes/feature_extractor#transformers.SequenceFeatureExtractor.pad) les séquences à une longueur donnée afin d'éviter des longueurs de séquences inégales.
- [FeatureExtractionMixin](/docs/transformers/v5.23.0/fr/main_classes/feature_extractor#transformers.FeatureExtractionMixin) fournit [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/feature_extractor#transformers.FeatureExtractionMixin.from_pretrained) et [save_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/feature_extractor#transformers.FeatureExtractionMixin.save_pretrained) pour charger et enregistrer un extracteur de caractéristiques.

Il existe deux façons de charger un extracteur de caractéristiques : [AutoFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoFeatureExtractor) et une classe d'extracteur de caractéristiques spécifique à un modèle.

L'API [AutoClass](./model_doc/auto) charge automatiquement le bon extracteur de caractéristiques pour un modèle donné.

Utilisez [from_pretrained()](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoFeatureExtractor.from_pretrained) pour charger un extracteur de caractéristiques.

```py
from transformers import AutoFeatureExtractor

feature_extractor = AutoFeatureExtractor.from_pretrained("openai/whisper-tiny")
```

Chaque modèle audio préentraîné possède un extracteur de caractéristiques associé spécifique pour traiter correctement les données audio. Lors du chargement d'un extracteur de caractéristiques, celui-ci récupère la configuration de l'extracteur de caractéristiques (taille des caractéristiques, longueur des blocs, etc.) depuis [preprocessor_config.json](https://hf.co/openai/whisper-tiny/blob/main/preprocessor_config.json).

Un extracteur de caractéristiques peut être chargé directement depuis sa classe spécifique au modèle.

```py
from transformers import WhisperFeatureExtractor

feature_extractor = WhisperFeatureExtractor.from_pretrained("openai/whisper-tiny")
```

## Prétraitement

Un extracteur de caractéristiques s'attend à recevoir l'entrée sous forme de tenseur PyTorch d'une forme donnée. La forme exacte de l'entrée peut varier selon le modèle audio spécifique que vous utilisez.

Par exemple, [Whisper](./model_doc/whisper) s'attend à ce que `input_features` soit un tenseur de forme `(batch_size, feature_size, sequence_length)` tandis que [Wav2Vec2](https://hf.co/docs/transformers/model_doc/wav2vec2) s'attend à ce que `input_values` soit un tenseur de forme `(batch_size, sequence_length)`.

Le feature extractor génère la forme d'entrée correcte pour le modèle audio que vous utilisez.

Un extracteur de caractéristiques définit également le taux d'échantillonnage (le nombre de valeurs du signal audio capturées par seconde) des fichiers audio. Le taux d'échantillonnage de vos données audio doit correspondre au taux d'échantillonnage du jeu de données sur lequel le modèle pré-entraîné a été entraîné. Cette valeur est généralement indiquée dans la fiche du modèle.

Chargez un jeu de données et un extracteur de caractéristiques avec [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/feature_extractor#transformers.FeatureExtractionMixin.from_pretrained).

```py
from datasets import load_dataset, Audio
from transformers import AutoFeatureExtractor

dataset = load_dataset("PolyAI/minds14", name="en-US", split="train")
feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base")
```

Consultez le premier exemple du jeu de données et accédez à la colonne `audio` qui contient `array`, le signal audio brut.

```py
dataset[0]["audio"]["array"]
array([ 0.        ,  0.00024414, -0.00024414, ..., -0.00024414,
        0.        ,  0.        ])
```

L'extracteur de caractéristiques prétraite `array` dans le format d'entrée attendu pour un modèle audio donné. Utilisez le paramètre `sampling_rate` pour définir le taux d'échantillonnage approprié.

```py
processed_dataset = feature_extractor(dataset[0]["audio"]["array"], sampling_rate=16000)
processed_dataset
{'input_values': [array([ 9.4472744e-05,  3.0777880e-03, -2.8888427e-03, ...,
       -2.8888427e-03,  9.4472744e-05,  9.4472744e-05], dtype=float32)]}
```

### Remplissage

Les longueurs de séquences audio différentes posent problème, car Transformers s'attend à ce que toutes les séquences aient la même longueur afin de pouvoir être regroupées en lots. Les séquences de longueurs inégales ne peuvent pas être regroupées en lots.

```py
dataset[0]["audio"]["array"].shape
(86699,)

dataset[1]["audio"]["array"].shape
(53248,)
```

Le padding ajoute un *jeton de padding* spécial pour garantir que toutes les séquences ont la même longueur. L'extracteur de caractéristiques ajoute un `0` - interprété comme du silence - à `array` pour le compléter. Définissez `padding=True` pour compléter les séquences jusqu'à la longueur de la séquence la plus longue du lot.

```py
def preprocess_function(examples):
    audio_arrays = [x["array"] for x in examples["audio"]]
    inputs = feature_extractor(
        audio_arrays,
        sampling_rate=16000,
        padding=True,
    )
    return inputs

processed_dataset = preprocess_function(dataset[:5])
processed_dataset["input_values"][0].shape
(86699,)

processed_dataset["input_values"][1].shape
(86699,)
```

### Troncature

Les modèles ne peuvent traiter que des séquences d'une longueur maximale avant de planter.

La troncature est une stratégie visant à supprimer les jetons superflus d'une séquence afin de s'assurer qu'elle ne dépasse pas la longueur maximale. Définissez `truncation=True` pour tronquer une séquence à la longueur spécifiée dans le paramètre `max_length`.

```py
def preprocess_function(examples):
    audio_arrays = [x["array"] for x in examples["audio"]]
    inputs = feature_extractor(
        audio_arrays,
        sampling_rate=16000,
        max_length=50000,
        truncation=True,
    )
    return inputs

processed_dataset = preprocess_function(dataset[:5])
processed_dataset["input_values"][0].shape
(50000,)

processed_dataset["input_values"][1].shape
(50000,)
```

### Rééchantillonnage

La bibliothèque [Datasets](https://hf.co/docs/datasets/index) permet également de rééchantillonner les données audio afin de les adapter à la fréquence d'échantillonnage attendue par un modèle audio. Cette méthode rééchantillonne les données audio à la volée lors de leur chargement, ce qui peut être plus rapide que de rééchantillonner l'ensemble du jeu de données sur place.

Le jeu de données audio sur lequel vous travaillez a un taux d'échantillonnage de 8 kHz, tandis que le modèle préentraîné en attend un de 16 kHz.

```py
dataset[0]["audio"]
{'path': '/root/.cache/huggingface/datasets/downloads/extracted/f507fdca7f475d961f5bb7093bcc9d544f16f8cab8608e772a2ed4fbeb4d6f50/en-US~JOINT_ACCOUNT/602ba55abb1e6d0fbce92065.wav',
 'array': array([ 0.        ,  0.00024414, -0.00024414, ..., -0.00024414,
         0.        ,  0.        ]),
 'sampling_rate': 8000}
```

Appel de [cast_column](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset.cast_column) sur la colonne `audio` pour remonter le taux d'échantillonnage à 16 kHz.

```py
dataset = dataset.cast_column("audio", Audio(sampling_rate=16000))
```

Lorsque vous chargez l'échantillon du jeu de données, il est désormais rééchantillonné à 16 kHz.

```py
dataset[0]["audio"]
{'path': '/root/.cache/huggingface/datasets/downloads/extracted/f507fdca7f475d961f5bb7093bcc9d544f16f8cab8608e772a2ed4fbeb4d6f50/en-US~JOINT_ACCOUNT/602ba55abb1e6d0fbce92065.wav',
 'array': array([ 1.70562416e-05,  2.18727451e-04,  2.28099874e-04, ...,
         3.43842403e-05, -5.96364771e-06, -1.76846661e-05]),
 'sampling_rate': 16000}
```

