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:

Lakukan fine-tuning pada ViT menggunakan dataset Food-101 untuk mengklasifikasikan item makanan dalam sebuah gambar.
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

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

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:

>>> from huggingface_hub import notebook_login

>>> notebook_login()

Muat dataset Food-101

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

>>> from datasets import load_dataset

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

Bagi split train dari dataset menjadi set train dan test dengan metode train_test_split:

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

Lalu, lihatlah sebuah contoh:

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

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

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

Pra-pemrosesan

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

>>> 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 dari torchvision, tetapi Anda juga dapat menggunakan pustaka gambar apa pun yang Anda inginkan.

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

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

>>> 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 dari 🤗 Datasets. Transformasi diterapkan secara langsung saat Anda memuat elemen dari dataset:

>>> food = food.with_transform(transforms)

Sekarang buat satu batch contoh menggunakan DefaultDataCollator. Berbeda dengan data collator lainnya di 🤗 Transformers, DefaultDataCollator tidak menerapkan pra-pemrosesan tambahan seperti padding.

>>> from transformers import DefaultDataCollator

>>> data_collator = DefaultDataCollator()

Evaluasi

Menyertakan metrik selama pelatihan sering kali membantu untuk mengevaluasi kinerja model Anda. Anda dapat dengan cepat memuat metode evaluasi dengan pustaka 🤗 Evaluate. Untuk tugas ini, muat metrik accuracy (lihat quick tour 🤗 Evaluate untuk mempelajari lebih lanjut tentang cara memuat dan menghitung metrik):

>>> import evaluate

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

Lalu buat fungsi yang meneruskan prediksi dan label Anda ke compute untuk menghitung akurasi:

>>> 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 menyiapkan pelatihan.

Latih

Jika Anda belum familiar dengan finetuning model menggunakan Trainer, silakan lihat tutorial dasar di sini!

Anda siap untuk mulai melatih model Anda sekarang! Muat ViT dengan AutoModelForImageClassification. Tentukan jumlah label beserta jumlah label yang diharapkan, serta pemetaan label:

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

Definisikan hiperparameter pelatihan Anda di 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 harus masuk ke Hugging Face untuk mengunggah model Anda). Di akhir setiap epoch, Trainer akan mengevaluasi akurasi dan menyimpan checkpoint pelatihan.
Lewatkan argumen pelatihan ke Trainer bersama dengan model, dataset, tokenizer, data collator, dan fungsi compute_metrics.
Panggil train() untuk melakukan finetuning pada model Anda.

>>> 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() agar semua orang dapat menggunakan model Anda:

>>> trainer.push_to_hub()

Untuk contoh yang lebih mendalam tentang cara melakukan finetuning model untuk klasifikasi gambar, lihat notebook PyTorch yang sesuai.

Inferensi

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

Muat gambar yang ingin Anda gunakan untuk menjalankan inferensi:

>>> 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(). Buat instans pipeline untuk klasifikasi gambar dengan model Anda, lalu berikan gambar Anda ke dalamnya:

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

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

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

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

Update on GitHub