# 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 leur décrivant les images.

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 :

```bash
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 :

```python
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 dans PyTorch, vous pouvez suivre [ce notebook](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/GIT/Fine_tune_GIT_on_an_image_captioning_dataset.ipynb).

```python
from datasets import load_dataset

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

```bash
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](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset.train_test_split) :

```python
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.

```python
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.

```python
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.

```python
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 le ["microsoft/git-base"](https://huggingface.co/microsoft/git-base) dans un objet [AutoModelForCausalLM](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoModelForCausalLM).

```python
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](https://huggingface.co/spaces/evaluate-metric/rouge) ou du [Word Error Rate](https://huggingface.co/spaces/evaluate-metric/wer). 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](https://huggingface.co/spaces/evaluate-metric/wer).

```python
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](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer) 🤗 pour cela.

Tout d'abord, définissez les arguments d'entraînement à l'aide de [TrainingArguments](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.TrainingArguments).

```python
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.

```python
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()](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer.train) sur l’objet [Trainer](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer).

```python
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()](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer.push_to_hub) afin que chacun puisse l’utiliser :

```python
trainer.push_to_hub()
```

## Inférence

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

```python
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.

```python
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.

```python
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)
```

```bash
a drawing of a pink and blue pokemon
```

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

