Klasifikasi Gambar dengan Hugging Face: Panduan Komprehensif Disertai Contoh

Di bidang kecerdasan buatan (AI) dan pembelajaran mesin (ML) yang berkembang pesat, klasifikasi gambar menonjol sebagai tugas fundamental yang mendukung berbagai aplikasi, mulai dari sistem pengenalan wajah hingga diagnosis citra medis.

Di antara banyak alat dan pustaka yang tersedia bagi data scientist dan praktisi AI, Hugging Face menjadi pemain utama, khususnya bagi mereka yang bekerja dengan pemrosesan bahasa alami (NLP) dan, semakin banyak, dengan tugas visi komputer seperti klasifikasi gambar.

Artikel ini akan membahas hal-hal penting dalam menggunakan Hugging Face untuk klasifikasi gambar, termasuk memahami dasar-dasar klasifikasi gambar, menyiapkan data, melatih model, menerapkan model ke hub Hugging Face, dan akhirnya berinteraksi dengan model yang diterapkan melalui API dan antarmuka Hugging Face.

Baik Anda pemula maupun praktisi berpengalaman, panduan ini akan memberikan wawasan berharga untuk memanfaatkan Hugging Face sesuai kebutuhan klasifikasi gambar Anda.

Memahami Klasifikasi Gambar dengan Hugging Face

Bagian ini memberikan wawasan tentang dasar-dasar klasifikasi gambar dan manfaat menggunakan Hugging Face.

Dasar-dasar klasifikasi gambar

Klasifikasi gambar mengacu pada pengkategorian gambar ke dalam salah satu dari beberapa kelas yang telah ditentukan.

Tugas ini dilakukan menggunakan algoritme yang menganalisis konten visual suatu gambar dan memprediksi kategorinya berdasarkan pola yang dipelajari dari himpunan data pelatihan. Model deep learning, khususnya convolutional neural networks (CNN), telah menjadi pendekatan standar untuk tugas ini karena kemampuannya menangkap pola relevan dalam data gambar.

Untuk mempelajari lebih lanjut tentang CNN, artikel kami Pengantar Convolutional Neural Networks (CNN) menyediakan panduan lengkap untuk memahami CNN, dampaknya pada analisis gambar, dan beberapa strategi kunci untuk mengatasi overfitting agar CNN tetap andal dalam aplikasi deep learning.

Selain itu, artikel Klasifikasi dalam Machine Learning: Pengantar membahas langkah demi langkah untuk mempelajari klasifikasi dalam machine learning, mencakup apa itu, bagaimana digunakan, dan beberapa contoh algoritme klasifikasi.

Mengapa memilih Hugging Face untuk klasifikasi gambar?

Hugging Face menawarkan ekosistem pembelajaran mesin yang luas, dengan antarmuka yang mudah digunakan, menampung repositori besar model pralatih, serta dokumentasi yang komprehensif.

Dibandingkan platform lain, Hugging Face memberikan beberapa keunggulan untuk klasifikasi gambar:

Tiga manfaat menggunakan Hugging Face (Gambar dihasilkan menggunakan GPT-4)

• Aksesibilitas: API yang ramah pengguna dan dokumentasi komprehensif dari Hugging Face membuatnya mudah diakses oleh pemula maupun ahli.
• Model pralatih: Akses ke beragam model pralatih yang dapat di-fine-tune pada dataset kustom, menghemat waktu dan sumber daya komputasi. Siapa pun yang memiliki akun dapat melatih dan menerapkan modelnya sendiri.
• Komunitas dan dukungan: Komunitas yang dinamis dan forum dukungan aktif membantu pengguna memecahkan masalah dan meningkatkan model mereka.

Selain itu, Hugging Face memudahkan penerapan model di berbagai platform cloud utama seperti AWS, Azure, dan Google Cloud Platform, beserta beragam tipe inferensi.

Opsi penerapan model pada platform Cloud

Menyiapkan Data Anda untuk Klasifikasi Gambar

Tugas utama yang dibahas dalam artikel ini adalah klasifikasi gambar, dan kami akan menggunakan himpunan data beans dari Hugging Face sebagai contoh. Setelah memuat dataset, kita akan melakukan beberapa visualisasi sebelum masuk ke prapemrosesan untuk pelatihan model.

Notebook beserta kodenya tersedia untuk diikuti di Google Colab.

Kode dalam artikel ini sangat terinspirasi dari situs web resmi Hugging Face.

Kebutuhan pustaka

Banyak pustaka digunakan dalam cakupan artikel ini, dan masing-masing memiliki peran tertentu. Sebagian pustaka memerlukan instalasi. Pustaka tersebut diinstal menggunakan manajer paket Python “pip” sebagai berikut:

%%bash
pip -q install datasets
pip -q install transformers=='4.29.0'
pip -q install tensorflow=='2.15' # At least this tensorflow version is required to use the "evaluate module"
pip -q install evaluate
pip -q install --upgrade accelerate

Penting untuk memulai ulang kernel setelah menginstal pustaka. Setelah instalasi berhasil, pustaka yang diperlukan dapat diimpor menggunakan pernyataan from dan import:

import torch
import torchvision
import numpy as np
import evaluate
from datasets import load_dataset
from huggingface_hub import notebook_login
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
from transformers import DefaultDataCollator
from transformers import AutoImageProcessor
from torchvision.transforms import RandomResizedCrop, Compose, Normalize, ToTensor
from transformers import AutoModelForImageClassification, TrainingArguments, Trainer
import matplotlib.pyplot as plt

Kebutuhan dan organisasi data

Memuat data dari Hugging Face mudah dilakukan menggunakan fungsi load_dataset .

beans_train = load_dataset("beans", split="train")

• beans adalah nama dataset yang digunakan.
• train sesuai dengan subset dari keseluruhan data yang digunakan.

Setelah data dimuat, kita dapat memeriksa karakteristiknya dengan cukup mencetak nama variabel di atas.

print(beans_train)

Ini menampilkan hasil berikut:

Dataset({
    features: ['image_file_path', 'image', 'labels'],
    num_rows: 1034
})

Terdapat total 1034 gambar, dan setiap gambar memiliki tiga field:

• image_path: path ke gambar sebenarnya.
• image: objek PIL dari gambar kacang.
• labels: label gambar, yang bisa berupa salah satu dari tiga jenis berikut:
• 0: angular_leaf_spot
• 1: bean_rust
• 2: healthy

Fungsi pembantu berikut memudahkan untuk memvisualisasikan sejumlah gambar acak dan menampilkan tipe gambar yang benar beserta label yang ada (0, 1, dan 2)

labels_names = {
   0: "angular_leaf_spot",
   1: "bean_rust",
   2: "healthy",
}

def display_random_images(dataset, num_images=4):

   num_rows = 2
   num_cols = np.ceil(num_images / num_rows).astype(int)

   plt.figure(figsize=(num_cols * 3, num_rows * 3))
   indices = np.random.choice(range(len(dataset)), size=num_images, replace=False)

   for i, idx in enumerate(indices, 1):
       idx = int(idx)
       image = dataset[idx]['image']
       label = dataset[idx]['labels']
       label_name = labels_names.get(label, "Unknown")

       plt.subplot(num_rows, num_cols, i)
       plt.imshow(image)
       plt.title(f"{label_name} ({label})")
       plt.axis('off')

   plt.tight_layout()
   plt.show()

Secara singkat, fungsi display_random_images memilih subset acak gambar dari suatu dataset dan menampilkannya dalam bentuk grid, dengan setiap gambar diberi label sesuai klasifikasinya (misalnya, "angular_leaf_spot", "bean_rust", "healthy").

Fungsi ini secara dinamis menyusun gambar menjadi dua baris dan menghitung jumlah kolom yang diperlukan berdasarkan total jumlah gambar yang akan ditampilkan, memastikan tidak ada duplikasi gambar dan setiap gambar disertai nama label serta label numeriknya.

Kita kemudian dapat menampilkan enam gambar acak menggunakan fungsi tersebut sebagai berikut:

display_random_images(beans_train, num_images=6)

Enam gambar acak dari dataset

Prapemrosesan data

Sebelum melatih model, penting untuk melakukan prapemrosesan yang relevan agar data sesuai dengan kebutuhan model.

Pertama, dataset asli dibagi menjadi data pelatihan dan validasi, masing-masing 80% dan 20%, dan ini dilakukan menggunakan fungsi train_test_split .

beans_train = beans_train.train_test_split(test_size=0.2)

Selanjutnya, dua kamus dibuat: label2id dan id2label. Ini penting untuk mengonversi antara nama label yang dapat dibaca manusia dan pengenal numerik yang dapat dipahami mesin.

Proses ini memudahkan proses pelatihan dan interpretasi prediksi akhir model.

labels = beans_train["train"].features["labels"].names
label2id, id2label = dict(), dict()

for i, label in enumerate(labels):
   label2id[label] = str(i)
   id2label[str(i)] = label

Berikut adalah hasil variabel id2label:

print(id2label)

{'0': 'angular_leaf_spot', '1': 'bean_rust', '2': 'healthy'}

Memuat model pralatih

Model klasifikasi kami memanfaatkan model vision transformer (ViT) pralatih dari Hugging Face.

Model ini diperkenalkan dalam makalah An Image is Worth 16x16 words: Transformers for Image Recognition at Scale, dan menandai penerapan pertama arsitektur transformer yang berhasil pada pengenalan gambar, yang dilatih pada dataset ImageNet.

Kode berikut menjelaskan semua langkah untuk memuat model pralatih, melakukan prapemrosesan data agar sesuai dengan kebutuhan model, serta langkah-langkah perantara untuk memastikan gambar diproses dengan benar dan siap dimasukkan ke model pralatih untuk fine-tuning dan evaluasi.

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

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

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

beans_transformed = beans_train.with_transform(transforms)

data_collator = DefaultDataCollator()

Mari pahami apa yang terjadi pada kode di atas:

• Pertama, kita memuat checkpoint model pemrosesan gambar pralatih dari google/vit-base-patch16-224-in21k.
• Kemudian, kita membuat image processor untuk model ini, yang mencakup parameter normalisasi dan ukuran gambar yang disukai.
• Selain itu, transformasi normalisasi didefinisikan menggunakan mean dan standar deviasi dari image processor.
• Ukuran gambar untuk transformasi ditentukan, default ke sisi terpendek atau tinggi dan lebar yang ditentukan.
• Serangkaian transformasi (_transforms) disusun, termasuk random cropping, konversi tensor, dan normalisasi.
• Fungsi pembantu transforms didefinisikan untuk menerapkan transformasi ini ke field "image" dari contoh masukan, mengonversi gambar ke RGB dan menghapus field "image" asli.
• Dataset beans_train ditransformasikan menggunakan fungsi transforms, menyiapkannya untuk pelatihan model.
• Terakhir, data collator bawaan diinstansiasi untuk membentuk batch data selama pelatihan.

Setelah penyiapan ini, metrik evaluasi yang digunakan untuk menilai kinerja model adalah accuracy, yang diimplementasikan menggunakan fungsi pembantu berikut.

accuracy = evaluate.load("accuracy")
def compute_metrics(eval_pred):
   predictions, labels = eval_pred
   predictions = np.argmax(predictions, axis=1)

   return accuracy.compute(predictions=predictions,
                           references=labels)

Melatih Model Anda dengan Hugging Face

Sebelum proses pelatihan model, model aktual didefinisikan dengan memanfaatkan model pralatih menggunakan fungsi .from_pretrained sebagai berikut

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

Fine-tuning dan evaluasi

Langkah selanjutnya adalah menyiapkan model dengan mengonfigurasi dan menginisialisasi lingkungan pelatihan.

Penyiapan mencakup penentuan hyperparameter yang diperlukan terkait pelatihan, evaluasi, dan optimisasi.

Namun sebelum itu, kita perlu masuk ke akun Hugging Face menggunakan kredensial akun kita, yang dapat diperoleh sebagai berikut:

Langkah utama untuk memperoleh kredensial Hugging Face

Dengan masuk ke akun Hugging Face, kita dapat mengunggah dan berbagi model terlatih dengan komunitas. Selanjutnya, proses autentikasi dipicu menggunakan fungsi notebook_login.

notebook_login()

Saat diminta, berikan token koneksi, seperti yang disalin pada langkah 4 dari panduan di atas.

Setelah berhasil masuk, pesan berikut seharusnya ditampilkan:

Kode konfigurasi dan inisialisasi disediakan di bawah ini:

training_args = TrainingArguments(
	output_dir="./beans_health_type_classifier",
	remove_unused_columns=False,
	evaluation_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_ratio=0.1,
	logging_steps=10,
	load_best_model_at_end=True,
	metric_for_best_model="accuracy"
)

trainer = Trainer(
	model=model,
	args=training_args,
	data_collator=data_collator,
	train_dataset=beans_transformed["train"],
	eval_dataset=beans_transformed["test"],
	tokenizer=image_processor,
	compute_metrics=compute_metrics,
)

• TrainingArguments dikonfigurasi dengan parameter spesifik seperti direktori keluaran, strategi evaluasi dan penyimpanan per epoch, laju pembelajaran, ukuran batch, langkah akumulasi gradien, dan pengaturan lain yang bertujuan mengoptimalkan proses pelatihan serta kinerja model.
• Objek Trainer diinisialisasi dengan model yang telah ditentukan, argumen pelatihan, data collator untuk pembentukan batch, dataset pelatihan dan evaluasi, tokenizer (atau image processor dalam kasus ini) untuk prapemrosesan data, serta fungsi untuk menghitung metrik evaluasi.

Kini masuk ke fase pelatihan, yang dilakukan menggunakan fungsi .train.

trainer.train()

Pelatihan khusus ini menghasilkan metrik berikut:

Hasil pelatihan model untuk tiga epoch

Kita dapat melihat bahwa tabel menampilkan progres pelatihan model selama tiga epoch pada dataset beans Anda, menunjukkan tiga metrik kunci: training loss, validation loss, dan accuracy.

• Training loss: Turun dari 1,02800 pada epoch pertama menjadi 0,53470 pada epoch ketiga, menandakan model belajar dan meningkatkan kinerjanya pada data pelatihan seiring waktu.
• Validation loss: Juga turun dari 0,77973 menjadi 0,43553 dari epoch pertama ke ketiga, menunjukkan model melakukan generalisasi dengan baik dan tidak overfitting pada data pelatihan.
• Akurasi: Ada peningkatan konsisten dari 85,5072% pada epoch pertama menjadi 94,2029% pada epoch ketiga, mencerminkan peningkatan yang baik dalam kemampuan model mengklasifikasikan gambar kacang pada himpunan validasi.

Menerapkan Model Klasifikasi Gambar Anda

Saat melakukan autentikasi ke portal Hugging Face untuk pertama kali, mode koneksi adalah Read saja. Namun, kita memerlukan kredensial write agar dapat mendorong model ke hub Hugging Face.

Setelah itu, kita perlu masuk kembali menggunakan fungsi notebook_login dengan menggunakan kredensial yang baru dibuat.

notebook_login()

Mendorong model dilakukan menggunakan fungsi push_to_hub sebagai berikut:

trainer.model.push_to_hub("zoumana/beans_health_type_classifier")

Ini akan mendorong model ke hub, dan kita dapat melihat properti utama dari model tersebut.

Model didorong ke Hugging Face

Integrasi ke dalam aplikasi

Setelah model dibagikan, model dapat diintegrasikan ke dalam aplikasi menggunakan REST API, atau pengguna dapat mengintegrasikannya langsung dari portal Hugging Face. Pengembang dan peneliti juga dapat menggunakan model dengan memuatnya melalui pustaka Transformers.

Pada bagian ini, kita membahas tiga cara utama menggunakan model.

1. Gunakan dari portal Hugging Face

Di portal, pengguna dapat langsung mengunggah gambar dan mendapatkan prediksi model seperti diilustrasikan pada animasi berikut.

Menggunakan model dari portal Hugging Face

2. Gunakan di Transformers

Dengan memilih ikon “Use in Transformers”, kode untuk menggunakan model otomatis disediakan sebagai berikut:

Menggunakan model dengan Transformers

3. Menggunakan REST API

Terakhir, kita dapat menggunakan model sebagai REST API menggunakan string koneksi yang disediakan secara otomatis dari portal setelah mengeklik ikon “Deploy > Inference API (serverless)”.

Menggunakan endpoint API

Potongan kode yang disediakan pada animasi sebelumnya sama seperti di bawah ini dan dapat digunakan untuk melakukan prediksi pada gambar tertentu.

Gambar yang digunakan sama seperti yang disediakan saat ilustrasi dari portal Hugging Face.

Pastikan untuk mengganti “xxx” dengan nilai sebenarnya.

import requests

API_URL = "https://api-inference.huggingface.co/models/zoumana/beans_health_type_classifier"
headers = {"Authorization": "Bearer xxxxxxxxxxxxxxxxx"}

def query(filename):
   with open(filename, "rb") as f:
       data = f.read()
   response = requests.post(API_URL, headers=headers, data=data)
   return response.json()

Selanjutnya, kita mendapatkan respons model menggunakan fungsi query sebelumnya.

output = query("./inference_images/test_beans_leaf.jpg")

Hasil akhirnya adalah respons JSON, seperti yang ditunjukkan di bawah. Kita dapat melihat label yang diprediksi adalah yang memiliki skor probabilitas tertinggi, dan dalam kasus ini, labelnya adalah healthy, yang persis sama dengan prediksi dari portal Hugging Face.

print(output)

[
    {'label': 'healthy', 'score': 0.4799719452857971},
     {'label': 'angular_leaf_spot', 'score': 0.27489492297172546},
     {'label': 'bean_rust', 'score': 0.2451331913471222}
]

Kesimpulan dan Pembelajaran Lanjutan

Artikel ini memberikan panduan lengkap tentang cara melakukan tugas klasifikasi gambar menggunakan Hugging Face.

Kami memulai dengan dasar-dasar klasifikasi gambar dan membahas mengapa Hugging Face adalah alat yang tepat untuk pekerjaan ini, berkat koleksi modelnya yang luas dan komunitasnya yang suportif.

Lalu, kami membahas cara menyiapkan gambar pelatihan untuk klasifikasi, termasuk memastikan data pelatihan memenuhi kebutuhan fine-tuning.

Selain itu, kami membahas cara melakukan fine-tuning model dengan Hugging Face, memilih model pralatih yang tepat. Kami juga membahas cara mengintegrasikan model terlatih ke aplikasi dunia nyata menggunakan tiga strategi integrasi utama.

Selalu ada lebih banyak hal untuk dipelajari dan dieksplorasi dalam AI, dan setiap langkah yang Anda ambil membuka kemungkinan baru. Jadi, bagi siapa pun yang ingin mempelajari lebih lanjut tentang AI dan machine learning, khususnya tentang mengklasifikasikan gambar dan lainnya, berikut beberapa sumber yang patut dilihat:

• Untuk pengantar ramah pemula tentang Transformers dan Hugging Face, lihat Pengantar Menggunakan Transformers dan Hugging Face kami.
• Bagi yang tertarik mengolah lebih banyak gambar menggunakan Python, Image Processing with Python skill track mengeksplorasi cara bekerja dan menganalisis gambar.
• Terakhir, untuk mendapatkan gambaran umum yang baik tentang apa itu pengenalan gambar dan mengapa itu penting, artikel kami Apa itu Pengenalan Gambar? adalah tempat yang tepat untuk mulai.

Panduan ini dimaksudkan untuk membantu siapa pun memulai proyek mereka sendiri menggunakan Hugging Face untuk klasifikasi gambar, baik mereka praktisi pemula, menengah, maupun mahir.