# Processeurs

Les modèles multimodaux nécessitent un préprocesseur capable de traiter des entrées combinant plusieurs modalités. Selon la modalité d’entrée, un processeur doit convertir le texte en un tableau de tenseurs, les images en valeurs de pixels et l’audio en un tableau de tenseurs avec le taux d’échantillonnage approprié.

Par exemple, [PaliGemma](./model_doc/paligemma) est un modèle vision-langage qui utilise le processeur d’images [SigLIP](./model_doc/siglip) et le tokeniseur [Llama](./model_doc/llama). Une classe [ProcessorMixin](/docs/transformers/main/fr/main_classes/processors#transformers.ProcessorMixin) encapsule ces deux types de préprocesseurs, offrant ainsi une classe de processeur unique et unifiée pour un modèle multimodal.

Appel de [from_pretrained()](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2Processor.from_pretrained) pour charger un processeur. Transmettez le type d’entrée au processeur afin de générer les entrées attendues par le modèle, les identifiants d’entrée et les valeurs de pixels.

```py
from transformers import AutoProcessor, PaliGemmaForConditionalGeneration
from PIL import Image
import requests

processor = AutoProcessor.from_pretrained("google/paligemma-3b-pt-224")

prompt = "answer en Where is the cat standing?"
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"
image = Image.open(requests.get(url, stream=True).raw)

inputs = processor(text=prompt, images=image, return_tensors="pt")
inputs
```

Ce guide décrit la classe de processeur et la façon de prétraiter les entrées multimodales.

## Classes de processeur

Tous les processeurs héritent de la classe [ProcessorMixin](/docs/transformers/main/fr/main_classes/processors#transformers.ProcessorMixin), qui fournit des méthodes telles que [from_pretrained()](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2Processor.from_pretrained), [save_pretrained()](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2Processor.save_pretrained) et [push_to_hub()](/docs/transformers/main/fr/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub) pour charger, enregistrer et partager des processeurs sur le Hub.

Il existe deux façons de charger un processeur, avec [AutoProcessor](/docs/transformers/main/fr/model_doc/auto#transformers.AutoProcessor) et avec une classe de processeur spécifique au modèle.

L’API [AutoClass](./model_doc/auto) fournit une interface simple pour charger des processeurs sans avoir à spécifier directement la classe de modèle à laquelle ils appartiennent.

Utilisez [from_pretrained()](/docs/transformers/main/fr/model_doc/auto#transformers.AutoProcessor.from_pretrained) pour charger un processeur.

```py
from transformers import AutoProcessor

processor = AutoProcessor.from_pretrained("google/paligemma-3b-pt-224")
```

Les processeurs sont également associés à une classe de modèle multimodal préentraînée spécifique. Vous pouvez charger un processeur directement depuis la classe de modèle avec [from_pretrained()](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2Processor.from_pretrained).

```py
from transformers import WhisperProcessor

processor = WhisperProcessor.from_pretrained("openai/whisper-tiny")
```

Vous pouvez également charger séparément les deux types de préprocesseurs, [WhisperTokenizerFast](/docs/transformers/main/fr/model_doc/whisper#transformers.WhisperTokenizer) et [WhisperFeatureExtractor](/docs/transformers/main/fr/model_doc/whisper#transformers.WhisperFeatureExtractor).

```py
from transformers import WhisperTokenizerFast, WhisperFeatureExtractor, WhisperProcessor

tokenizer = WhisperTokenizerFast.from_pretrained("openai/whisper-tiny")
feature_extractor = WhisperFeatureExtractor.from_pretrained("openai/whisper-tiny")
processor = WhisperProcessor(feature_extractor=feature_extractor, tokenizer=tokenizer)
```

## Enregistrer et charger un processeur

[save_pretrained()](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2Processor.save_pretrained) écrit la configuration du processeur dans un fichier unique `processor_config.json`. Le tokeniseur et le modèle de discussion sont enregistrés dans leurs propres fichiers.

```py
from transformers import AutoProcessor

processor = AutoProcessor.from_pretrained("llava-hf/llava-onevision-qwen2-0.5b-ov-hf")
processor.save_pretrained("./llava-onevision")
```

```text
llava-onevision/
├── chat_template.jinja
├── processor_config.json
├── tokenizer.json
└── tokenizer_config.json
```

Chaque sous-processeur, à l’exception du tokenizer, est imbriqué dans `processor_config.json` sous le nom de son attribut, tel que `image_processor`, `video_processor` ou `feature_extractor`. Les paramètres qui appartiennent au processeur lui-même, comme `image_token`, se trouvent au niveau supérieur. L’exemple ci-dessous est raccourci.

```json
{
  "image_processor": {
    "image_processor_type": "LlavaOnevisionImageProcessor",
    "do_resize": true,
    "size": {"height": 384, "width": 384},
    "image_mean": [0.5, 0.5, 0.5]
  },
  "image_token": "<image>",
  "processor_class": "LlavaOnevisionProcessor",
  "video_processor": {
    "video_processor_type": "LlavaOnevisionVideoProcessor",
    "do_resize": true,
    "size": {"height": 384, "width": 384},
    "image_mean": [0.5, 0.5, 0.5]
  },
  "video_token": "<video>"
}
```

Les autres fichiers sont enregistrés séparément.

- Le tokenizer écrit ses fichiers habituels, comme `tokenizer.json` et `tokenizer_config.json`. Si un processeur possède un second tokenizer, celui-ci est enregistré dans un sous-dossier portant le nom de son attribut, comme `decoder_tokenizer/`.
- Le modèle de conversation est enregistré dans `chat_template.jinja`. Si un processeur possède plusieurs modèles de conversation, le modèle `default` est placé dans `chat_template.jinja` et les autres dans un dossier `chat_templates/`.

Lorsque vous chargez un processeur avec [from_pretrained()](/docs/transformers/main/fr/model_doc/wav2vec2#transformers.Wav2Vec2Processor.from_pretrained), chaque sous-processeur recherche d'abord sa clé imbriquée dans `processor_config.json`. Si la clé n'y figure pas, il se rabat sur un fichier autonome. Les processeurs d'images et les extracteurs de caractéristiques lisent `preprocessor_config.json`, et les processeurs de vidéos lisent `video_preprocessor_config.json` puis `preprocessor_config.json`. Les anciens points de contrôle qui stockent chaque sous-processeur dans son propre fichier se chargent toujours de cette manière.

> [!NOTE]
> Une configuration imbriquée a la priorité sur un fichier autonome. Si un point de contrôle contient les deux, la modification de `preprocessor_config.json` ou de `video_preprocessor_config.json` n’a aucun effet. Modifiez plutôt l’entrée imbriquée dans `processor_config.json`.

## Prétraitement

Les processeurs prétraitent les entrées multimodales pour les convertir au format attendu par Transformers. Un processeur peut gérer plusieurs combinaisons de modalités d'entrée, telles que le texte et l'audio, ou le texte et l'image.

Les tâches de reconnaissance automatique de la parole (ASR) nécessitent un processeur capable de gérer les entrées texte et audio. Chargez un jeu de données et examinez les colonnes `audio` et `text` (vous pouvez supprimer les autres colonnes qui ne sont pas nécessaires).

```py
from datasets import load_dataset

dataset = load_dataset("keithito/lj_speech", split="train")
dataset = dataset.map(remove_columns=["file", "id", "normalized_text"])
dataset[0]["audio"]
{'array': array([-7.3242188e-04, -7.6293945e-04, -6.4086914e-04, ...,
         7.3242188e-04,  2.1362305e-04,  6.1035156e-05], dtype=float32),
 'path': '/root/.cache/huggingface/datasets/downloads/extracted/917ece08c95cf0c4115e45294e3cd0dee724a1165b7fc11798369308a465bd26/LJSpeech-1.1/wavs/LJ001-0001.wav',
 'sampling_rate': 22050}

dataset[0]["text"]
'Printing, in the only sense with which we are at present concerned, differs from most if not from all the arts and crafts represented in the Exhibition'
```

N'oubliez pas de rééchantillonner le taux d'échantillonnage pour qu'il corresponde au taux d'échantillonnage requis par les modèles pré-entraînés.

```py
from datasets import Audio

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

Chargez un processeur et passez-lui les colonnes `array` et `text`.

```py
from transformers import AutoProcessor

processor = AutoProcessor.from_pretrained("openai/whisper-tiny")

def prepare_dataset(example):
    audio = example["audio"]
    example.update(processor(audio=audio["array"], text=example["text"], sampling_rate=16000))
    return example
```

Appliquez la fonction `prepare_dataset` pour prétraiter le jeu de données. Le processeur renvoie `input_features` pour la colonne `audio` et `labels` pour la colonne de texte.

```py
prepare_dataset(dataset[0])
```