Légende d'image

La légende d’image est la tâche qui consiste à prédire une légende pour une image donnée. Ses applications courantes dans le monde réel incluent l’aide aux personnes malvoyantes, ce qui peut les aider à naviguer dans différentes situations. Par conséquent, la légende d’image contribue à améliorer l’accessibilité du contenu pour les personnes en décrivant les images à leur attention.

Ce guide vous montre comment :

Ajuster finement un modèle de légende d'images.
Utilisez le modèle affiné pour l'inférence.

Avant de commencer, assurez-vous d'avoir installé toutes les bibliothèques nécessaires :

pip install transformers datasets evaluate -q
pip install jiwer -q

Nous vous encourage à vous connecter à votre compte Hugging Face afin de pouvoir téléverser et partager votre modèle avec la communauté. Lorsque le système vous le demande, saisissez votre jeton pour vous connecter :

from huggingface_hub import notebook_login

notebook_login()

Charger le jeu de données de légendes BLIP Pokémon

Utilisez la bibliothèque 🤗 Dataset pour charger un jeu de données composé de paires {image-caption}. Pour créer votre propre jeu de données de légende d’images en PyTorch, vous pouvez suivre ce notebook.

from datasets import load_dataset

ds = load_dataset("lambdalabs/pokemon-blip-captions")
ds

DatasetDict({
    train: Dataset({
        features: ['image', 'text'],
        num_rows: 833
    })
})

Le jeu de données comporte deux caractéristiques, image et text.

De nombreux jeux de données de légende d’images contiennent plusieurs légendes par image. Dans ces cas, une stratégie courante consiste à échantillonner aléatoirement une légende parmi celles disponibles lors de l’entraînement.

Divisez la partie d’entraînement du jeu de données en un ensemble d’entraînement et un ensemble de test à l’aide de la méthode train_test_split :

ds = ds["train"].train_test_split(test_size=0.1)
train_ds = ds["train"]
test_ds = ds["test"]

Visualisons quelques échantillons du jeu d’entraînement.

from textwrap import wrap
import matplotlib.pyplot as plt
import numpy as np


def plot_images(images, captions):
    plt.figure(figsize=(20, 20))
    for i in range(len(images)):
        ax = plt.subplot(1, len(images), i + 1)
        caption = captions[i]
        caption = "\n".join(wrap(caption, 12))
        plt.title(caption)
        plt.imshow(images[i])
        plt.axis("off")


sample_images_to_visualize = [np.array(train_ds[i]["image"]) for i in range(5)]
sample_captions = [train_ds[i]["text"] for i in range(5)]
plot_images(sample_images_to_visualize, sample_captions)

Prétraiter le jeu de données

Comme le jeu de données comporte deux modalités (image et texte), le pipeline de prétraitement prétraitera les images et les légendes.

Pour ce faire, chargez la classe de processeur associée au modèle que vous êtes sur le point d'ajuster finement.

from transformers import AutoProcessor

checkpoint = "microsoft/git-base"
processor = AutoProcessor.from_pretrained(checkpoint)

Le processeur prétraite l'image en interne (ce qui inclut le redimensionnement et le mise à l'échelle des pixels) et tokenise la légende.

def transforms(example_batch):
    images = [x for x in example_batch["image"]]
    captions = [x for x in example_batch["text"]]
    inputs = processor(images=images, text=captions, padding="max_length")
    inputs.update({"labels": inputs["input_ids"]})
    return inputs


train_ds.set_transform(transforms)
test_ds.set_transform(transforms)

Une fois le jeu de données prêt, vous pouvez maintenant configurer le modèle pour le fine-tuning.

Charger un modèle de base

Chargez “microsoft/git-base” dans un objet AutoModelForCausalLM.

from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained(checkpoint)

Évaluer

Les modèles de légende d’image sont généralement évalués à l’aide du Rouge Score ou du Word Error Rate. Pour ce guide, vous utiliserez le Word Error Rate (WER).

Nous utilisons la bibliothèque 🤗 Evaluate pour ce faire. Pour connaître les éventuelles limitations et autres pièges du WER, reportez-vous à ce guide.

from evaluate import load
import torch

wer = load("wer")


def compute_metrics(eval_pred):
    logits, labels = eval_pred
    predicted = logits.argmax(-1)
    decoded_labels = processor.batch_decode(labels, skip_special_tokens=True)
    decoded_predictions = processor.batch_decode(predicted, skip_special_tokens=True)
    wer_score = wer.compute(predictions=decoded_predictions, references=decoded_labels)
    return {"wer_score": wer_score}

Entraînement

Vous êtes maintenant prêt à commencer le fine-tuning du modèle. Vous utiliserez le Trainer 🤗 pour cela.

Tout d'abord, définissez les arguments d'entraînement à l'aide de TrainingArguments.

from transformers import TrainingArguments, Trainer

model_name = checkpoint.split("/")[1]

training_args = TrainingArguments(
    output_dir=f"{model_name}-pokemon",
    learning_rate=5e-5,
    num_train_epochs=50,
    fp16=True,
    per_device_train_batch_size=32,
    per_device_eval_batch_size=32,
    gradient_accumulation_steps=2,
    save_total_limit=3,
    eval_strategy="steps",
    eval_steps=50,
    save_strategy="steps",
    save_steps=50,
    logging_steps=50,
    remove_unused_columns=False,
    push_to_hub=True,
    label_names=["labels"],
    load_best_model_at_end=True,
)

Puis, transmettez-les, ainsi que les jeux de données et le modèle, à 🤗 Trainer.

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_ds,
    eval_dataset=test_ds,
    compute_metrics=compute_metrics,
)

Pour démarrer l’entraînement, il suffit d’appeler train() sur l’objet Trainer.

trainer.train()

Vous devriez observer une baisse régulière de la perte d'entraînement au fil de la formation.

Une fois l’entraînement terminé, partagez votre modèle sur le Hub à l’aide de la méthode push_to_hub() afin que chacun puisse l’utiliser :

trainer.push_to_hub()

Inférence

Prenez une image d'exemple dans test_ds pour tester le modèle.

from PIL import Image
import requests

url = "https://huggingface.co/datasets/sayakpaul/sample-datasets/resolve/main/pokemon.png"
image = Image.open(requests.get(url, stream=True).raw)
image

Préparez l'image pour le modèle.

from accelerate import Accelerator

device = Accelerator().device
inputs = processor(images=image, return_tensors="pt").to(device)
pixel_values = inputs.pixel_values

Appel de generate et décodage des prédictions.

generated_ids = model.generate(pixel_values=pixel_values, max_length=50)
generated_caption = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
print(generated_caption)

a drawing of a pink and blue pokemon

Il semble que le modèle affiné ait généré une légende assez bonne !

Update on GitHub

Transformers

Légende d'image

Charger le jeu de données de légendes BLIP Pokémon

Prétraiter le jeu de données

Charger un modèle de base

Évaluer

Entraînement

Inférence