# Klasifikasi gambar

Klasifikasi gambar memberikan label atau kelas pada sebuah gambar. Berbeda dengan klasifikasi teks atau audio, inputnya adalah nilai piksel yang membentuk sebuah gambar. Klasifikasi gambar memiliki banyak aplikasi, seperti mendeteksi kerusakan setelah bencana alam, memantau kesehatan tanaman, atau membantu menyaring gambar medis untuk tanda-tanda penyakit.

Panduan ini mengilustrasikan cara:

1. Lakukan fine-tuning pada [ViT](../model_doc/vit) menggunakan dataset [Food-101](https://huggingface.co/datasets/ethz/food101) untuk mengklasifikasikan item makanan dalam sebuah gambar.
2. Gunakan model yang telah Anda fine-tune untuk inferensi.

Untuk melihat semua arsitektur dan checkpoint yang kompatibel dengan tugas ini, kami menyarankan untuk memeriksa [halaman tugas](https://huggingface.co/tasks/image-classification)

Sebelum memulai, pastikan Anda telah menginstal semua pustaka yang diperlukan:

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

Kami mendorong Anda untuk masuk ke akun Hugging Face Anda untuk mengunggah dan membagikan model Anda dengan komunitas. Saat diminta, masukkan token Anda untuk masuk:

```py
>>> from huggingface_hub import notebook_login

>>> notebook_login()
```

## Muat dataset Food-101

Mulai dengan memuat subset kecil dari dataset Food-101 dari pustaka 🤗 Datasets. Ini akan memberi Anda kesempatan untuk bereksperimen dan memastikan semuanya berfungsi sebelum menghabiskan lebih banyak waktu untuk pelatihan pada dataset lengkap.

```py
>>> from datasets import load_dataset

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

Pisahkan split `train` dari dataset menjadi set train dan test dengan metode [train_test_split](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset.train_test_split):

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

Lalu, lihatlah sebuah contoh:

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

Setiap contoh dalam dataset memiliki dua bidang:

- `image`: gambar PIL dari item makanan
- `label`: kelas label dari item makanan

Untuk memudahkan model mendapatkan nama label dari id label, buat kamus yang memetakan nama label ke bilangan bulat dan sebaliknya:

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

Sekarang Anda dapat mengonversi id label menjadi nama label:

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

## Pra-pemrosesan

Langkah selanjutnya adalah memuat pemroses gambar ViT untuk memproses gambar menjadi tensor:

```py
>>> from transformers import AutoImageProcessor

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

Terapkan beberapa transformasi gambar pada gambar untuk membuat model lebih robust terhadap overfitting. Di sini Anda akan menggunakan modul [`transforms`](https://pytorch.org/vision/stable/transforms.html) dari torchvision, tetapi Anda juga dapat menggunakan pustaka gambar apa pun yang Anda sukai.

Potong bagian acak dari gambar, ubah ukurannya, dan normalisasikan dengan mean dan deviasi standar gambar:

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

Lalu buat fungsi pra-pemrosesan untuk menerapkan transformasi dan mengembalikan `pixel_values` — yaitu masukan ke model — dari gambar:

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

Untuk menerapkan fungsi pra-pemrosesan ke seluruh dataset, gunakan metode [with_transform](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset.with_transform) dari 🤗 Datasets. Transformasi diterapkan secara langsung saat Anda memuat elemen dari dataset:

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

Sekarang buat satu batch contoh menggunakan [DefaultDataCollator](/docs/transformers/v5.23.0/id/main_classes/data_collator#transformers.DefaultDataCollator). Berbeda dengan data collator lainnya di 🤗 Transformers, `DefaultDataCollator` tidak menerapkan pra-pemrosesan tambahan seperti padding.

```py
>>> from transformers import DefaultDataCollator

>>> data_collator = DefaultDataCollator()
```

## Evaluasi

Termasuk metrik selama pelatihan sering kali membantu untuk mengevaluasi kinerja model Anda. Anda dapat dengan cepat memuat metode evaluasi dengan pustaka 🤗 [Evaluate](https://huggingface.co/docs/evaluate/index). Untuk tugas ini, muat metrik [accuracy](https://huggingface.co/spaces/evaluate-metric/accuracy) (lihat [quick tour](https://huggingface.co/docs/evaluate/a_quick_tour) 🤗 Evaluate untuk mempelajari lebih lanjut tentang cara memuat dan menghitung metrik):

```py
>>> import evaluate

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

Lalu buat fungsi yang meneruskan prediksi dan label Anda ke [compute](https://huggingface.co/docs/evaluate/v0.4.6/en/package_reference/main_classes#evaluate.EvaluationModule.compute) untuk menghitung akurasi:

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

Fungsi `compute_metrics` Anda sudah siap digunakan, dan Anda akan kembali ke fungsi ini saat mengatur pelatihan.

## Latih

Jika Anda belum familiar dengan finetuning model menggunakan [Trainer](/docs/transformers/v5.23.0/id/main_classes/trainer#transformers.Trainer), silakan lihat tutorial dasar [di sini](../training)!

Anda siap untuk mulai melatih model Anda sekarang! Muat ViT dengan [AutoModelForImageClassification](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoModelForImageClassification). Tentukan jumlah label beserta jumlah label yang diharapkan, dan pemetaan label:

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

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

Pada titik ini, hanya tersisa tiga langkah:

1. Definisikan hiperparameter pelatihan Anda di [TrainingArguments](/docs/transformers/v5.23.0/id/main_classes/trainer#transformers.TrainingArguments). Penting untuk tidak menghapus kolom yang tidak digunakan karena hal itu akan membuang kolom `image`. Tanpa kolom `image`, Anda tidak dapat membuat `pixel_values`. Atur `remove_unused_columns=False` untuk mencegah perilaku ini! Parameter wajib lainnya adalah `output_dir` yang menentukan di mana model Anda disimpan. Anda akan mendorong model ini ke Hub dengan mengatur `push_to_hub=True` (Anda perlu masuk ke Hugging Face untuk mengunggah model Anda). Di akhir setiap epoch, [Trainer](/docs/transformers/v5.23.0/id/main_classes/trainer#transformers.Trainer) akan mengevaluasi akurasi dan menyimpan checkpoint pelatihan.
2. Lewatkan argumen pelatihan ke [Trainer](/docs/transformers/v5.23.0/id/main_classes/trainer#transformers.Trainer) bersama dengan model, dataset, tokenizer, data collator, dan fungsi `compute_metrics`.
3. Panggil [train()](/docs/transformers/v5.23.0/id/main_classes/trainer#transformers.Trainer.train) untuk melakukan finetuning pada model Anda.

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

Setelah pelatihan selesai, bagikan model Anda ke Hub dengan metode [push_to_hub()](/docs/transformers/v5.23.0/id/main_classes/trainer#transformers.Trainer.push_to_hub) agar semua orang dapat menggunakan model Anda:

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

Untuk contoh yang lebih mendalam tentang cara melakukan finetuning model untuk klasifikasi gambar, lihat [notebook PyTorch](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/image_classification.ipynb) yang sesuai.

## Inferensi

Bagus, sekarang setelah Anda melakukan fine-tuning pada model, Anda dapat menggunakannya untuk inferensi!

Muat gambar yang ingin Anda jalankan inferensinya:

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

    

Cara termudah untuk mencoba model finetune Anda untuk inferensi adalah dengan menggunakannya dalam [pipeline()](/docs/transformers/v5.23.0/id/main_classes/pipelines#transformers.pipeline). Buat instans `pipeline` untuk klasifikasi gambar dengan model Anda, lalu berikan gambar Anda ke dalamnya:

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

Anda juga dapat mereplikasi hasil dari `pipeline` secara manual jika Anda mau:

Muat image processor untuk memproses praproses gambar dan mengembalikan `input` sebagai tensor PyTorch:

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

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

Lewatkan input Anda ke model dan kembalikan logits:

```py
>>> from transformers import AutoModelForImageClassification

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

Dapatkan label prediksi dengan probabilitas tertinggi, dan gunakan pemetaan `id2label` model untuk mengubahnya menjadi label:

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

