Natural Language Processing (NLP) dulunya adalah bidang yang rumit dan mahal untuk dimasuki. Kamu perlu melatih model dari nol, mengumpulkan data raksasa, dan menyewa GPU berjam-jam hanya untuk sekadar mengklasifikasikan teks. Kini, berkat Hugging Face Transformers, kamu bisa memanfaatkan model-model canggih seperti BERT, GPT, dan RoBERTa hanya dalam beberapa baris kode Python.

Pada tutorial ini kamu akan belajar menggunakan library Transformers secara lengkap: mulai dari instalasi, memakai pipeline untuk berbagai tugas NLP, memahami cara kerja tokenizer, hingga fine-tuning model untuk klasifikasi teks dengan dataset milikmu sendiri. Jika kamu masih baru di dunia machine learning, pahami dulu konsep dasarnya di Apa Itu Machine Learning dan Bagaimana Cara Kerjanya.

Apa Itu Hugging Face Transformers?

Hugging Face adalah perusahaan sekaligus komunitas yang mengelola Model Hub — sebuah repositori berisi ratusan ribu model open-source yang siap dipakai. Library transformers adalah antarmuka standar untuk memuat dan menjalankan model-model tersebut, baik yang berbasis arsitektur encoder (seperti BERT dan RoBERTa), decoder (seperti GPT), maupun encoder-decoder (seperti T5 dan BART).

Kelebihan utamanya adalah konsistensi: dengan API yang sama, kamu bisa berpindah dari satu model ke model lain tanpa menulis ulang kode. Model-model ini sudah dilatih (pre-trained) pada korpus teks yang sangat besar, sehingga bisa langsung dipakai untuk berbagai tugas NLP, atau diadaptasi (fine-tuned) ke kebutuhan spesifikmu dengan data yang jauh lebih sedikit.

Instalasi dan Persiapan Lingkungan

Langkah pertama adalah membuat virtual environment dan menginstal library yang dibutuhkan. Kita memakai uv karena jauh lebih cepat daripada pip — jika belum familier, baca dulu Tutorial Lengkap uv: Package Manager Python Super Cepat.

bash
# Buat dan aktifkan environment baru
uv venv
source .venv/bin/activate

# Instal transformers, torch, dan dependensi pendukung
uv pip install transformers torch datasets evaluate

Jika kamu punya GPU NVIDIA, instal versi CUDA dari PyTorch agar pelatihan dan inferensi jauh lebih cepat. Cek panduan resmi di pytorch.org untuk perintah yang sesuai dengan driver-mu. Tanpa GPU pun, contoh di tutorial ini tetap bisa dijalankan — hanya lebih lambat.

Menggunakan Pipeline untuk Tugas NLP

Fitur paling cepat untuk memulai adalah pipeline, yang menggabungkan preprocessing, model, dan post-processing dalam satu fungsi. Berikut beberapa tugas NLP yang bisa kamu selesaikan langsung.

python
from transformers import pipeline

# 1. Analisis sentimen
sentimen = pipeline("sentiment-analysis")
print(sentimen("Aplikasi ini sangat membantu pekerjaan saya!"))
# [{'label': 'POSITIVE', 'score': 0.999...}]

# 2. Named Entity Recognition (NER)
ner = pipeline("ner", grouped_entities=True)
print(ner("Mark Zuckerberg mendirikan Facebook di California pada 2004."))

# 3. Text generation
generator = pipeline("text-generation", model="gpt2")
print(generator("Kunci belajar coding yang efektif adalah", max_length=40))

# 4. Summarization
summarizer = pipeline("summarization")
teks_panjang = """Bahasa Indonesia memiliki ratusan juta penutur di seluruh dunia.
Namun, sebagian besar penelitian NLP masih berfokus pada bahasa Inggris. Hal ini
membuka peluang besar bagi pengembang lokal untuk membangun model dan aplikasi
yang lebih relevan bagi pengguna Indonesia."""
print(summarizer(teks_panjang, max_length=30, min_length=10))

# 5. Translation (Inggris -> Indonesia)
penerjemah = pipeline("translation", model="Helsinki-NLP/opus-mt-en-id")
print(penerjemah("Learning to code is a valuable skill."))

Saat pertama kali memanggil sebuah model, library akan mengunduhnya secara otomatis dari Hugging Face Model Hub dan menyimpannya di cache lokal. Setelah itu, pemakaian berikutnya tidak perlu mengunduh ulang.

Memahami Tokenizer dan Model

Di balik pipeline, ada dua komponen utama: tokenizer yang mengubah teks menjadi angka (id token) yang dipahami model, dan model yang memproses angka tersebut menjadi prediksi. Memahami keduanya penting sebelum kita melangkah ke fine-tuning.

python
from transformers import AutoTokenizer, AutoModelForSequenceClassification

nama_model = "distilbert-base-uncased"

tokenizer = AutoTokenizer.from_pretrained(nama_model)
model = AutoModelForSequenceClassification.from_pretrained(nama_model)

# Lihat bagaimana tokenizer bekerja
teks = "Halo, dunia!"
tokens = tokenizer.tokenize(teks)
ids = tokenizer.encode(teks)
print(tokens)   # ['halo', ',', 'dunia', '!']
print(ids)      # [7592, 1010, 6198, 999]

# Decode kembali ke teks
print(tokenizer.decode(ids))  # 'halo, dunia!'

Selalu gunakan pasangan tokenizer dan model yang sama. Tokenizer dari BERT tidak bisa dipasangkan dengan model GPT karena keduanya memakai vocabulary yang berbeda. Kelas AutoTokenizer dan AutoModel... memastikan komponen yang dimuat cocok satu sama lain.

Fine-Tuning Model untuk Klasifikasi Teks

Sekarang bagian yang paling menarik: menyesuaikan model pre-trained agar memahami data spesifikmu. Kita akan melatih DistilBERT (versi ringan BERT) untuk klasifikasi sentimen pada dataset IMDb. Konsep klasifikasinya mirip dengan yang dijelaskan di Membuat Model Klasifikasi Pertama dengan Python (Scikit-learn), tetapi kali ini memakai deep learning.

python
from datasets import load_dataset
from transformers import (
    AutoTokenizer,
    AutoModelForSequenceClassification,
    TrainingArguments,
    Trainer,
)
import numpy as np
import evaluate

# 1. Muat dataset IMDb (ulasan film + label positif/negatif)
dataset = load_dataset("imdb")
tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")

# 2. Tokenisasi seluruh dataset
def tokenize(examples):
    return tokenizer(
        examples["text"],
        truncation=True,
        padding="max_length",
        max_length=128,
    )

tokenized = dataset.map(tokenize, batched=True)
tokenized = tokenized.remove_columns(["text"])
tokenized = tokenized.rename_column("label", "labels")
tokenized.set_format("torch")

# 3. Siapkan model dengan 2 label keluaran (positif/negatif)
model = AutoModelForSequenceClassification.from_pretrained(
    "distilbert-base-uncased",
    num_labels=2,
)

# 4. Konfigurasi pelatihan
training_args = TrainingArguments(
    output_dir="./results",
    eval_strategy="epoch",
    save_strategy="epoch",
    learning_rate=2e-5,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=16,
    num_train_epochs=3,
    weight_decay=0.01,
)

# 5. Metrik evaluasi (akurasi)
accuracy = evaluate.load("accuracy")

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

# 6. Latih model (pakai subset kecil agar cepat)
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized["train"].shuffle(seed=42).select(range(2000)),
    eval_dataset=tokenized["test"].shuffle(seed=42).select(range(500)),
    compute_metrics=compute_metrics,
)

trainer.train()

Untuk eksperimen cepat, pakai subset kecil dataset (seperti contoh di atas). Setelah kode berjalan lancar, naikkan ukuran data dan jumlah num_train_epochs secara bertahap sambil memantau metrik evaluasi agar tidak overfitting.

Menyimpan dan Memuat Model Hasil Fine-Tuning

Setelah pelatihan selesai, simpan model dan tokenizer agar bisa dipakai kembali tanpa melatih ulang. Kamu juga bisa memuatnya melalui pipeline seperti model dari Hub.

python
# Simpan model dan tokenizer ke folder lokal
trainer.save_model("./model-klasifikasi-sentimen")
tokenizer.save_pretrained("./model-klasifikasi-sentimen")

# Muat kembali dan gunakan untuk prediksi
from transformers import pipeline

classifier = pipeline(
    "sentiment-analysis",
    model="./model-klasifikasi-sentimen",
)
print(classifier("Film ini benar-benar luar biasa, saya sangat merekomendasikannya!"))
# [{'label': 'LABEL_1', 'score': 0.99...}]

Kesimpulan

Hugging Face Transformers menurunkan hambatan untuk masuk ke dunia NLP secara drastis. Kamu kini bisa memakai model state-of-the-art untuk analisis sentimen, NER, ringkasan, terjemahan, hingga melatih model klasifikasi teks sendiri — semuanya dengan Python. Jika ingin memahami lebih dalam bagaimana model-model ini dibangun dari dalam, lanjutkan dengan Belajar PyTorch: Panduan Lengkap Membangun Neural Network dari Nol.

Selamat mencoba! Mulailah dari pipeline, lalu beranikan diri untuk fine-tuning dengan dataset milikmu sendiri — di sanalah nilai sebenarnya dari library ini berada.