Salah satu pemanfaatan generative AI yang banyak dilakukan saat ini adalah image captioning. Image Captioning merupakan proses otomatis untuk menghasilkan deskripsi teks dari gambar yang dimasukkan ke dalam model. Pada artikel ini, kita akan menggunakan model BLIP (Bootstrapping Language-Image Pre-training) yang tersedia di Hugging Face untuk membuat aplikasi image captioning. Kita juga akan menggunakan API inference dari Hugging Face dan Gradio untuk membuat antarmuka interaktif.
Image Captioning
Proses Image Captioning menggabungkan dua bidang utama dalam kecerdasan buatan: Computer Vision (CV) dan Natural Language Processing (NLP). Beberapa langkah yang terjadi di dalam proses ini adalah :
Feature Extraction: Pada tahap ini, model computer vision digunakan untuk mengekstrak fitur-fitur penting dari gambar. Model yang digunakan biasanya berupa model convolutional neural network (CNN) yang telah dilatih (pretrained) pada tugas klasifikasi gambar, seperti ResNet atau EfficientNet.
Sequence Modeling: Fitur-fitur yang diekstraksi dari gambar kemudian dimasukkan ke dalam model seperti Long Short-Term Memory (LSTM) atau Transformer, untuk menghasilkan sequence kata berdasarkan fitur-fitur tersebut. Model ini belajar untuk menghasilkan deskripsi teks yang sesuai dengan konten gambar.
Caption Generation: Pada tahap terakhir, model menghasilkan deskripsi teks yang koheren dan sesuai dengan gambar yang diberikan.
BLIP (Bootstrapping Language-Image Pre-training)
BLIP merupakan model yang dirancang untuk tugas-tugas yang melibatkan hubungan antara gambar dan teks, termasuk Image Captioning. Model BLIP menggunakan pendekatan pre-training pada data skala besar yang mencakup gambar dan teks yang sesuai. Berikut sejumlah kelebihan dari model BLIP:
Pre-training on Large-Scale Data: BLIP dilatih pada dataset berskala besar yang mencakup berbagai jenis gambar dan deskripsi teks yang relevan. Hal ini memungkinkan model untuk menangkap berbagai pola dan hubungan antara gambar dan teks.
Bootstrapping Technique: Teknik bootstrapping digunakan untuk meningkatkan kualitas representasi gambar dan teks secara iteratif. Dengan menggunakan pendekatan ini, BLIP mampu memperbaiki kesalahan dan meningkatkan akurasi selama proses pelatihan.
Versatility: Model BLIP dapat digunakan untuk berbagai tugas yang melibatkan gambar dan teks, seperti image-to-text retrieval, text-to-image retrieval, dan Image Captioning.
Implementasi
Mengatur Kunci API
Pertama, kita perlu mengatur dan memuat kunci API dari Hugging Face untuk dapat mengakses layanan inference mereka. Kunci API ini biasanya disimpan dalam file .env untuk keamanan.
import io
import base64
import json
import requests
import gradio as gr
from dotenv import dotenv_values
config = dotenv_values(".env")
hf_api_key = config['HF_API_KEY']
Pada kode di atas, kita menggunakan pustaka dotenv untuk memuat kunci API dari file .env. Pastikan kita telah menambahkan kunci API kita di file .env dengan format HF_API_KEY=your_hugging_face_api_key.
Membuat Fungsi untuk Mengakses API
Selanjutnya, kita akan membuat fungsi get_completion yang akan mengirimkan gambar ke API Hugging Face dan menerima hasil deskripsi dari gambar yang dimasukkan.
API_URL = "https://api-inference.huggingface.co/models/Salesforce/blip-image-captioning-base"
def get_completion(inputs, parameters=None, ENDPOINT_URL=API_URL):
headers = {
"Authorization": f"Bearer {hf_api_key}",
"Content-Type": "application/json"
}
data = { "inputs": inputs }
if parameters is not None:
data.update({"parameters": parameters})
response = requests.request("POST",
ENDPOINT_URL,
headers=headers,
data=json.dumps(data))
return json.loads(response.content.decode("utf-8"))
Fungsi get_completion menggunakan modul requests untuk mengirimkan gambar yang sudah dikonversi ke format base64 ke API Hugging Face. Hasil dari API akan dikembalikan dalam bentuk JSON.
Mengkonversi Gambar ke Base64
Kita perlu mengkonversi gambar yang diunggah menjadi format base64 sebelum mengirimkannya ke API. Fungsi image_to_base64_str digunakan untuk tujuan ini.
def image_to_base64_str(pil_image):
byte_arr = io.BytesIO()
pil_image.save(byte_arr, format='PNG')
byte_arr = byte_arr.getvalue()
return str(base64.b64encode(byte_arr).decode('utf-8'))
Fungsi ini menerima gambar lalu mengkonversinya menjadi string base64. Tahap ini diperlukan karena API Hugging Face menerima input gambar dalam format base64.
Membuat Fungsi Captioner
Fungsi captioner digunakan untuk menggabungkan semua langkah sebelumnya dan mengembalikan deskripsi dari gambar yang diunggah.
def captioner(image):
base64_image = image_to_base64_str(image)
result = get_completion(base64_image)
return result[0]['generated_text']
Fungsi ini mengambil gambar, mengkonversinya menjadi string base64, mengirimkannya ke API Hugging Face menggunakan fungsi get_completion, dan mengembalikan deskripsi teks dari gambar tersebut.
Membuat Antarmuka Gradio
Terakhir, kita akan membuat interface menggunakan Gradio.
gr.close_all()
demo = gr.Interface(fn=captioner,
inputs=[gr.Image(label="Upload image", type="pil")],
outputs=[gr.Textbox(label="Caption")],
title="Image Captioning with BLIP",
description="Caption any image using the BLIP model",
allow_flagging="never",
examples=["./example/dog.jpg", "./example/fish.jpg", "./example/cat.jpg"])
demo.launch()
Interface ini memungkinkan pengguna untuk mengunggah gambar dan menampilkan deskripsi yang dihasilkan oleh model BLIP. Dengan Gradio, kita dapat dengan mudah menampilkan aplikasi ini di browser.
Kesimpulan
Pada artikel ini, kita telah belajar cara menggunakan model BLIP dari Hugging Face untuk melakukan Image Captioning. Kita juga telah membuat antarmuka interaktif menggunakan Gradio yang memungkinkan pengguna untuk mendapatkan deskripsi otomatis dari gambar yang diunggah. Terimakasih sudah membaca artikel ini, selamat belajar!
Source Code: Link to GitHub Repository