# Görsel açıklama

Görsel açıklama (image captioning), verilen bir görsel için bir açıklama tahmin etme görevidir. Bu alanın yaygın gerçek dünya uygulamaları arasında, farklı durumlarda hareket etmelerine yardımcı olarak görme engelli kişilere destek olmak yer alır. Bu nedenle görsel açıklama, görselleri tanımlayarak kişilerin içeriklere erişimini iyileştirmeye yardımcı olur.

Bu kılavuz size şunları gösterecektir:

* Bir görüntü açıklama modelini ince ayar yapın.
* İnce ayarlanmış modeli çıkarım için kullanın.

Başlamadan önce, gerekli tüm kütüphanelerin yüklendiğinden emin olun:

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

Modelinizi yükleyip toplulukla paylaşabilmeniz için Hugging Face hesabınıza giriş yapmanızı öneririz. İstendiğinde giriş yapmak için token'ınızı girin:

```python
from huggingface_hub import notebook_login

notebook_login()
```

## Pokémon BLIP altyazı veri setini yükleyin

{image-caption} çiftlerinden oluşan bir veri setini yüklemek için 🤗 Dataset kütüphanesini kullanın. PyTorch'ta kendi görüntü açıklama veri setinizi oluşturmak için [bu defterdeki](https://github.com/NielsRogge/Transformers-Tutorials/blob/master/GIT/Fine_tune_GIT_on_an_image_captioning_dataset.ipynb) adımları izleyebilirsiniz.

```python
from datasets import load_dataset

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

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

Veri setinin iki özelliği vardır: `image` ve `text`.

Birçok görüntü açıklama veri seti, her görüntü için birden fazla açıklama içerir. Bu durumlarda, yaygın bir strateji, eğitim sırasında mevcut açıklamalardan rastgele bir tane örneklemektir.

Veri setinin eğitim bölümünü [train_test_split](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset.train_test_split) yöntemiyle eğitim ve test kümesine ayırın:

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

Eğitim setinden birkaç örnek görselleştirelim.

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

    

## Veri setini ön işleme

Veri setinin iki modu (görsel ve metin) olduğundan, ön işleme hattı görselleri ve açıklamaları ön işler.

Bunu yapmak için, ince ayarını yapacağınız modelle ilişkili işlemci sınıfını yükleyin.

```python
from transformers import AutoProcessor

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

İşleyici, görüntüyü dahili olarak ön işler (bu, yeniden boyutlandırma ve piksel ölçeklemeyi içerir) ve başlığı belirteçlere ayırır.

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

Veri seti hazır olduğuna göre, şimdi modeli ince ayar için yapılandırabilirsiniz.

## Bir temel model yükleyin

["microsoft/git-base"](https://huggingface.co/microsoft/git-base) modelini bir [AutoModelForCausalLM](/docs/transformers/v5.23.0/tr/model_doc/auto#transformers.AutoModelForCausalLM) nesnesine yükleyin.

```python
from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained(checkpoint)
```

## Değerlendir

Görsel açıklama modelleri genellikle [Rouge Score](https://huggingface.co/spaces/evaluate-metric/rouge) veya [Word Error Rate](https://huggingface.co/spaces/evaluate-metric/wer) ile değerlendirilir. Bu kılavuzda Word Error Rate (WER) kullanacaksınız.

Bunu yapmak için 🤗 Evaluate kütüphanesini kullanıyoruz. WER'in olası kısıtlamaları ve diğer tuzakları için [bu kılavuza](https://huggingface.co/spaces/evaluate-metric/wer) başvurun.

```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}
```

## Eğit

Şimdi, modeli ince ayar yapmaya hazırsınız. Bunun için 🤗 [Trainer](/docs/transformers/v5.23.0/tr/main_classes/trainer#transformers.Trainer) kullanacaksınız.

Önce, eğitim argümanlarını [TrainingArguments](/docs/transformers/v5.23.0/tr/main_classes/trainer#transformers.TrainingArguments) kullanarak tanımlayın.

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

Ardından bunları veri setleri ve model ile birlikte 🤗 Trainer'a iletin.

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

Eğitime başlamak için [Trainer](/docs/transformers/v5.23.0/tr/main_classes/trainer#transformers.Trainer) nesnesinde [train()](/docs/transformers/v5.23.0/tr/main_classes/trainer#transformers.Trainer.train) fonksiyonunu çağırmanız yeterlidir.

```python
trainer.train()
```

Eğitim ilerledikçe eğitim kaybının (training loss) sorunsuz bir şekilde düşmesini görmelisiniz.

Eğitim tamamlandıktan sonra, modelinizi herkesin kullanabilmesi için [push_to_hub()](/docs/transformers/v5.23.0/tr/main_classes/trainer#transformers.Trainer.push_to_hub) yöntemiyle Hub'a paylaşın:

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

## Çıkarım

Modeli test etmek için `test_ds` içinden örnek bir görüntü alın.

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

    

Model için görüntüyü hazırlayın.

```python
from accelerate import Accelerator

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

`generate` çağrısını yapın ve tahminleri çözümlen.

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

Görünüşe göre ince ayarı yapılmış model oldukça iyi bir başlık üretti!

