# Görüntü sınıflandırma

Görüntü sınıflandırma, bir görüntüye etiket veya sınıf atar. Metin veya ses sınıflandırmadan farklı olarak girdiler, bir görüntüyü oluşturan piksel değerleridir. Görüntü sınıflandırmanın doğal afet sonrası hasar tespiti, tarla sağlığı izleme veya tıbbi görüntülerde hastalık belirtilerini taramaya yardımcı olma gibi birçok uygulaması vardır.

Bu kılavuz şunları gösterir:

1. Bir görüntüdeki yiyecek öğesini sınıflandırmak için [Food-101](https://huggingface.co/datasets/ethz/food101) veri setinde [ViT](../model_doc/vit) modelini ince ayarlayın.
2. İnce ayarladığınız modeli çıkarım için kullanın.

Bu görevle uyumlu tüm mimarileri ve denetim noktalarını görmek için [görev sayfasını](https://huggingface.co/tasks/image-classification) kontrol etmenizi öneririz.

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

```bash
pip install transformers datasets evaluate accelerate pillow torchvision scikit-learn trackio
```

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

```py
>>> from huggingface_hub import notebook_login

>>> notebook_login()
```

## Food-101 veri setini yükle

Önce 🤗 Datasets kütüphanesinden Food-101 veri setinin daha küçük bir alt kümesini yükleyerek başlayın. Bu, tam veri setinde eğitim için daha fazla zaman harcamadan önce deneyler yapmanıza ve her şeyin çalıştığını doğrulamanıza olanak tanır.

```py
>>> from datasets import load_dataset

>>> food = load_dataset("ethz/food101", split="train[:5000]")
```

Veri setinin `train` 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:

```py
>>> food = food.train_test_split(test_size=0.2)
```

Sonra bir örneğe göz atın:

```py
>>> food["train"][0]
{'image': <PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=512x512 at 0x7F52AFC8AC50>,
 'label': 79}
```

Veri setindeki her örnek iki alana sahiptir:

- `image`: Yiyecek öğesinin PIL görüntüsü
- `label`: yiyecek öğesinin etiket sınıfı

Modelin etiket adını etiket kimliğinden almasını kolaylaştırmak için, etiket adını bir tam sayıya ve tam sayıyı etiket adına eşleyen bir sözlük oluşturun:

```py
>>> labels = food["train"].features["label"].names
>>> label2id, id2label = dict(), dict()
>>> for i, label in enumerate(labels):
...     label2id[label] = str(i)
...     id2label[str(i)] = label
```

Şimdi etiket kimliğini etiket adına dönüştürebilirsiniz:

```py
>>> id2label[str(79)]
'prime_rib'
```

## Ön işleme

Bir sonraki adım, görüntüyü bir tensöre dönüştürmek için bir ViT görüntü işleyicisi yüklemektir:

```py
>>> from transformers import AutoImageProcessor

>>> checkpoint = "google/vit-base-patch16-224-in21k"
>>> image_processor = AutoImageProcessor.from_pretrained(checkpoint)
```

Modelin aşırı öğrenmeye karşı daha dayanıklı hale gelmesi için görüntülere bazı görüntü dönüşümleri uygulayın. Burada [`transforms`](https://pytorch.org/vision/stable/transforms.html) modülünü kullanacaksınız, ancak istediğiniz herhangi bir görüntü kütüphanesini de kullanabilirsiniz.

Görselin rastgele bir kısmını kırpın, yeniden boyutlandırın ve görsel ortalaması ile standart sapmasıyla normalize edin:

```py
>>> from torchvision.transforms import RandomResizedCrop, Compose, Normalize, ToTensor

>>> normalize = Normalize(mean=image_processor.image_mean, std=image_processor.image_std)
>>> size = (
...     image_processor.size["shortest_edge"]
...     if "shortest_edge" in image_processor.size
...     else (image_processor.size["height"], image_processor.size["width"])
... )
>>> _transforms = Compose([RandomResizedCrop(size), ToTensor(), normalize])
```

Ardından, dönüşümleri uygulayıp görüntünün `pixel_values` - modele girdi olarak verilen değerler - değerlerini döndüren bir ön işleme işlevi oluşturun:

```py
>>> def transforms(examples):
...     examples["pixel_values"] = [_transforms(img.convert("RGB")) for img in examples["image"]]
...     del examples["image"]
...     return examples
```

Tüm veri setine ön işleme fonksiyonunu uygulamak için 🤗 Datasets [with_transform](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset.with_transform) yöntemini kullanın. Dönüşümler, veri setinin bir öğesini yüklediğinizde anında uygulanır:

```py
>>> food = food.with_transform(transforms)
```

Şimdi [DefaultDataCollator](/docs/transformers/v5.23.0/tr/main_classes/data_collator#transformers.DefaultDataCollator) kullanarak örneklerden oluşan bir batch oluşturun. 🤗 Transformers'taki diğer veri toplayıcıların aksine, `DefaultDataCollator` padding gibi ek ön işleme uygulamaz.

```py
>>> from transformers import DefaultDataCollator

>>> data_collator = DefaultDataCollator()
```

## Değerlendir

Eğitim sırasında bir metrik kullanmak, modelinizin performansını değerlendirmek için genellikle faydalıdır. 🤗 [Evaluate](https://huggingface.co/docs/evaluate/index) kütüphanesiyle bir değerlendirme yöntemini hızla yükleyebilirsiniz. Bu görev için [accuracy](https://huggingface.co/spaces/evaluate-metric/accuracy) metrikini yükleyin (bir metriğin nasıl yükleneceğini ve hesaplanacağını öğrenmek için 🤗 Evaluate [hızlı turuna](https://huggingface.co/docs/evaluate/a_quick_tour) bakın):

```py
>>> import evaluate

>>> accuracy = evaluate.load("accuracy")
```

Ardından, tahminlerinizi ve etiketlerinizi [compute](https://huggingface.co/docs/evaluate/v0.4.6/en/package_reference/main_classes#evaluate.EvaluationModule.compute) işlevine geçirerek doğruluğu hesaplayan bir işlev oluşturun:

```py
>>> import numpy as np

>>> def compute_metrics(eval_pred):
...     predictions, labels = eval_pred
...     predictions = np.argmax(predictions, axis=1)
...     return accuracy.compute(predictions=predictions, references=labels)
```

`compute_metrics` fonksiyonunuz artık hazır ve eğitiminizi ayarladığınızda ona geri döneceksiniz.

## Eğit

[Trainer](/docs/transformers/v5.23.0/tr/main_classes/trainer#transformers.Trainer) ile bir modelin ince ayarını yapma konusunda deneyiminiz yoksa, temel öğreticiyi [burada](../training) inceleyebilirsiniz!

Modelinizi eğitmeye başlamak için hazırsınız! ViT'yi [AutoModelForImageClassification](/docs/transformers/v5.23.0/tr/model_doc/auto#transformers.AutoModelForImageClassification) ile yükleyin. Etiket sayısını, beklenen etiket sayısı ve etiket eşlemeleriyle birlikte belirtin:

```py
>>> from transformers import AutoModelForImageClassification, TrainingArguments, Trainer

>>> model = AutoModelForImageClassification.from_pretrained(
...     checkpoint,
...     num_labels=len(labels),
...     id2label=id2label,
...     label2id=label2id,
... )
```

Bu noktada yalnızca üç adım kaldı:

1. Eğitim hiperparametrelerinizi [TrainingArguments](/docs/transformers/v5.23.0/tr/main_classes/trainer#transformers.TrainingArguments) içinde tanımlayın. Kullanılmayan sütunları kaldırmamanız önemlidir, çünkü bu işlem `image` sütununu düşürür. `image` sütunu olmadan `pixel_values` oluşturamazsınız. Bu davranışı önlemek için `remove_unused_columns=False` ayarlayın! Tek diğer zorunlu parametre, modelinizi nereye kaydedeceğinizi belirten `output_dir`'dir. Modelinizi Hub'a `push_to_hub=True` ayarlayarak yükleyeceksiniz (modelinizi yüklemek için Hugging Face'e giriş yapmış olmanız gerekir). Her epoch sonunda [Trainer](/docs/transformers/v5.23.0/tr/main_classes/trainer#transformers.Trainer) doğruluğu değerlendirir ve eğitim checkpoint'ini kaydeder.
2. Eğitim argümanlarını, model, veri seti, tokenizer, veri toplayıcı ve `compute_metrics` fonksiyonuyla birlikte [Trainer](/docs/transformers/v5.23.0/tr/main_classes/trainer#transformers.Trainer)'a iletin.
3. Modelinizi ince ayar yapmak için [train()](/docs/transformers/v5.23.0/tr/main_classes/trainer#transformers.Trainer.train) çağrın.

```py
>>> training_args = TrainingArguments(
...     output_dir="my_awesome_food_model",
...     remove_unused_columns=False,
...     eval_strategy="epoch",
...     save_strategy="epoch",
...     learning_rate=5e-5,
...     per_device_train_batch_size=16,
...     gradient_accumulation_steps=4,
...     per_device_eval_batch_size=16,
...     num_train_epochs=3,
...     warmup_steps=0.1,
...     logging_steps=10,
...     report_to="trackio",
...     run_name="food101",
...     load_best_model_at_end=True,
...     metric_for_best_model="accuracy",
...     push_to_hub=True,
... )

>>> trainer = Trainer(
...     model=model,
...     args=training_args,
...     data_collator=data_collator,
...     train_dataset=food["train"],
...     eval_dataset=food["test"],
...     processing_class=image_processor,
...     compute_metrics=compute_metrics,
... )

>>> trainer.train()
```

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:

```py
>>> trainer.push_to_hub()
```

Görsel sınıflandırma için bir modeli nasıl ince ayar yapacağınızın daha ayrıntılı bir örneği için ilgili [PyTorch defterine](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/image_classification.ipynb) göz atın.

## Çıkarım

Harika, bir model ayarladıktan sonra artık çıkarım için kullanabilirsiniz!

Çıkarım yapmak istediğiniz bir görüntü yükleyin:

```py
>>> ds = load_dataset("ethz/food101", split="validation[:10]")
>>> image = ds["image"][0]
```

    

Eğitimini tamamladığınız modeli çıkarım için denemenin en basit yolu, onu bir [pipeline()](/docs/transformers/v5.23.0/tr/main_classes/pipelines#transformers.pipeline) içinde kullanmaktır. Modelinizle görüntü sınıflandırma için bir `pipeline` örneği oluşturun ve görüntünüzü ona iletin:

```py
>>> from transformers import pipeline

>>> classifier = pipeline("image-classification", model="my_awesome_food_model")
>>> classifier(image)
[{'score': 0.31856709718704224, 'label': 'beignets'},
 {'score': 0.015232225880026817, 'label': 'bruschetta'},
 {'score': 0.01519392803311348, 'label': 'chicken_wings'},
 {'score': 0.013022331520915031, 'label': 'pork_chop'},
 {'score': 0.012728818692266941, 'label': 'prime_rib'}]
```

İsterseniz `pipeline` sonuçlarını manuel olarak da yeniden üretebilirsiniz:

Görseli ön işlemek ve `input` değerini PyTorch tensörleri olarak döndürmek için bir görsel işleyici yükleyin:

```py
>>> from transformers import AutoImageProcessor
>>> import torch

>>> image_processor = AutoImageProcessor.from_pretrained("my_awesome_food_model")
>>> inputs = image_processor(image, return_tensors="pt")
```

Girdilerinizi modele iletin ve logitleri döndürün:

```py
>>> from transformers import AutoModelForImageClassification

>>> model = AutoModelForImageClassification.from_pretrained("my_awesome_food_model")
>>> with torch.no_grad():
...     logits = model(**inputs).logits
```

En yüksek olasılığa sahip tahmini etiketi alın ve modelin `id2label` eşlemesini kullanarak onu bir etikete dönüştürün:

```py
>>> predicted_label = logits.argmax(-1).item()
>>> model.config.id2label[predicted_label]
'beignets'
```