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 est un modèle vision-langage qui utilise le processeur d’images SigLIP et le tokeniseur Llama. Une classe 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() 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.

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, qui fournit des méthodes telles que from_pretrained(), save_pretrained() et push_to_hub() pour charger, enregistrer et partager des processeurs sur le Hub.

Il existe deux façons de charger un processeur, avec AutoProcessor et avec une classe de processeur spécifique au modèle.

AutoProcessor

processeur spécifique au modèle

Enregistrer et charger un processeur

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.

from transformers import AutoProcessor

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

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.

{
  "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(), 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.

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

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.

from datasets import Audio

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

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

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.

prepare_dataset(dataset[0])

Update on GitHub