Fine-tuning Model AI untuk Kasus Spesifik

Sudah familiar dengan ChatGPT yang bisa jawab apa aja? Pernah kepikiran bikin versi ChatGPT yang fokus untuk satu tugas spesifik — misalnya chatbot untuk layanan pelanggan bank, atau klasifikator ulasan produk? Itulah yang namanya Fine-tuning! 🎯

Apa Itu Fine-tuning?

Fine-tuning adalah proses mengambil model AI yang sudah pre-trained (seperti BERT atau GPT) dan melatihnya lebih lanjut dengan dataset spesifik untuk task tertentu.

Analogi Sederhana

Bayangkan model pre-trained itu seperti sarjana umum yang sudah punya pengetahuan luas. Fine-tuning adalah mengirimnya ke pelatihan profesi:

• Sarjana → Dokter (fine-tuning dengan data medis)
• Sarjana → Pengacara (fine-tuning dengan data hukum)
• Sarjana → Customer service (fine-tuning dengan data chat)

Kenapa Fine-tuning Penting?

1. Hemat Resource

• Training from scratch: Butuh jutaan dolar, ribuan GPU, data internet-scale
• Fine-tuning: Bisa dilakukan di laptop dengan beberapa ribu contoh

2. Data Efisien

• Model pre-trained sudah punya “common sense”
• Fine-tuning hanya butuh data spesifik (ratusan sampai ribuan)

3. Performa Lebih Baik

• Model yang di-fine-tune untuk domain spesifik bisa lebih akurat daripada model general

Jenis-Jenis Fine-tuning

1. Feature Extraction (Frozen Layers)

Gunakan model pre-trained sebagai “feature extractor”, tambahkan layer baru di atasnya.

# Contoh: Gunakan BERT untuk ekstrak fitur
from transformers import BertModel

# Load pre-trained BERT (frozen)
bert = BertModel.from_pretrained('bert-base-uncased')
for param in bert.parameters():
    param.requires_grad = False  # Freeze!

# Tambahkan classifier layer
classifier = nn.Linear(768, num_classes)  # Hanya layer ini yang di-train

Kapan pakai:

• Dataset kecil (< 1000 contoh)
• Task sederhana (classification)
• Resource terbatas

2. Full Fine-tuning

Latih ulang seluruh parameter model dengan learning rate kecil.

# Load model
model = BertForSequenceClassification.from_pretrained('bert-base-uncased')

# Fine-tune semua parameter
optimizer = AdamW(model.parameters(), lr=2e-5)  # Learning rate kecil!

Kapan pakai:

• Dataset cukup besar (> 5000 contoh)
• Task kompleks
• Budget compute cukup

3. Layer-wise Fine-tuning

Fine-tune layer atas saja, biarkan layer bawah tetap (frozen).

# Freeze layer bawah
for param in model.bert.encoder.layer[:6].parameters():
    param.requires_grad = False

# Fine-tune layer atas (6-11)
for param in model.bert.encoder.layer[6:].parameters():
    param.requires_grad = True

Idea: Layer bawah belajar fitur low-level (grammar, morphology), layer atas belajar fitur high-level (semantic, context).

Step-by-Step Fine-tuning dengan Hugging Face

Step 1: Install Dependencies

pip install transformers datasets torch

Step 2: Load Dataset

from datasets import load_dataset

# Contoh: Dataset sentimen analisis
dataset = load_dataset("imdb")  # 50k movie reviews

# Atau dataset custom CSV
# dataset = load_dataset("csv", data_files={"train": "train.csv", "test": "test.csv"})

Step 3: Load Tokenizer dan Model

from transformers import AutoTokenizer, AutoModelForSequenceClassification

model_name = "bert-base-uncased"  # Atau "distilbert-base-uncased" untuk lebih cepat
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(
    model_name, 
    num_labels=2  # Binary classification: positive/negative
)

Step 4: Preprocess Data

def tokenize_function(examples):
    return tokenizer(
        examples["text"], 
        padding="max_length", 
        truncation=True, 
        max_length=512
    )

tokenized_datasets = dataset.map(tokenize_function, batched=True)

Step 5: Setup Training Arguments

from transformers import TrainingArguments

training_args = TrainingArguments(
    output_dir="./results",
    evaluation_strategy="epoch",
    learning_rate=2e-5,  # Learning rate kecil untuk fine-tuning
    per_device_train_batch_size=16,
    per_device_eval_batch_size=16,
    num_train_epochs=3,
    weight_decay=0.01,
    save_strategy="epoch",
    load_best_model_at_end=True,
)

Step 6: Train!

from transformers import Trainer

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_datasets["train"],
    eval_dataset=tokenized_datasets["test"],
)

trainer.train()

Step 7: Save dan Use

# Save model
model.save_pretrained("./my-fine-tuned-model")
tokenizer.save_pretrained("./my-fine-tuned-model")

# Load untuk inference
from transformers import pipeline
classifier = pipeline("sentiment-analysis", model="./my-fine-tuned-model")

# Predict
result = classifier("This movie was absolutely amazing!")
print(result)  # [{'label': 'POSITIVE', 'score': 0.98}]

Contoh Kasus Fine-tuning

Kasus 1: Customer Support Chatbot

Goal: Chatbot yang bisa jawab pertanyaan spesifik tentang produk perusahaan.

Data yang dibutuhkan:

• FAQ perusahaan (Q&A pairs)
• Transcript chat customer service
• Dokumentasi produk

Approach:

• Base model: GPT-3.5 atau Llama
• Fine-tuning dengan conversation data
• Add retrieval system untuk knowledge base

Result: Chatbot yang ngerti produk, tone perusahaan, dan bisa handle edge cases.

Kasus 2: Medical Diagnosis Classifier

Goal: Klasifikasi jenis penyakit kulit dari deskripsi gejala.

Data yang dibutuhkan:

• Medical records (anonimized)
• Symptom-disease pairs
• Clinical notes

Approach:

• Base model: BioBERT atau MedBERT (sudah pre-trained dengan medical text)
• Fine-tuning dengan dataset penyakit kulit
• Multi-label classification

Result: Model yang akurat untuk triage awal (bukan diagnosis final!).

Kasus 3: Code Review Assistant

Goal: AI yang bisa review code dan suggest improvements.

Data yang dibutuhkan:

• Code + review comments dari GitHub
• Bug reports + fixes
• Best practices documentation

Approach:

• Base model: CodeT5 atau CodeBERT
• Fine-tuning dengan code review dataset
• Task: Code-to-text (generate review dari code)

Result: Assistant yang bisa detect common issues dan suggest refactoring.

Tips dan Best Practices

✅ Learning Rate

• Too high: Model “lupa” pengetahuan pre-trained (catastrophic forgetting)
• Too low: Training lambat, underfitting
• Sweet spot: 1e-5 sampai 5e-5 (tergantung task dan model)

✅ Learning Rate Scheduler

from transformers import get_linear_schedule_with_warmup

scheduler = get_linear_schedule_with_warmup(
    optimizer,
    num_warmup_steps=100,
    num_training_steps=1000
)

✅ Regularization

• Weight decay: 0.01 (standar)
• Dropout: 0.1 untuk classification layer
• Early stopping: Stop kalau validation loss naik

✅ Data Quality

• ⚠️ Garbage in, garbage out
• Clean data lebih penting daripada banyak data
• Augmentasi data (paraphrasing, back-translation)

✅ Validation Strategy

• Stratified split: Pastikan distribusi label seimbang
• Domain shift: Test set harus representatif dengan real-world data

Tantangan dalam Fine-tuning

⚠️ Catastrophic Forgetting

Model “lupa” pengetahuan umum setelah fine-tuning.

Solusi:

• Learning rate kecil
• Regularization
• Progressive unfreezing (freeze → unfreeze gradually)

⚠️ Overfitting

Model hafal data training, gagal generalize.

Solusi:

• More data
• Data augmentation
• Early stopping
• Regularization

⚠️ Class Imbalance

Satu label jauh lebih banyak dari yang lain.

Solusi:

• Weighted loss function
• Oversampling minority class
• Undersampling majority class
• Focal loss

⚠️ Hardware Limitations

Model besar butuh GPU/TPU.

Solusi:

• Distillation: Transfer knowledge ke model lebih kecil
• Quantization: INT8 atau INT4 precision
• LoRA (Low-Rank Adaptation): Fine-tune subset parameter saja

Advanced Techniques

1. LoRA (Low-Rank Adaptation)

Fine-tuning efisien yang hanya train “adapter” kecil.

from peft import LoraConfig, get_peft_model

config = LoraConfig(
    r=16,  # rank
    lora_alpha=32,
    target_modules=["q_proj", "v_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)

model = get_peft_model(model, config)
# Hanya ~1% parameter yang di-train!

Keuntungan:

• Save 99% memory
• Training jauh lebih cepat
• Bisa fine-tune LLM besar di consumer GPU

2. Prompt Tuning

Tambahkan “soft prompts” yang di-train, biarkan model tetap frozen.

[TRAINABLE PROMPT TOKENS] + Input Text → Model (frozen) → Output

Keuntungan:

• Extremely parameter-efficient
• Bisa switch antara tasks dengan ganti prompt

3. Instruction Tuning

Fine-tune model untuk mengikuti instruksi dalam format chat.

Data format:

{
  "instruction": "Terjemahkan ke bahasa Inggris",
  "input": "Saya suka makan nasi goreng",
  "output": "I like to eat fried rice"
}

Contoh model: Alpaca, Vicuna, WizardLM (instruction-tuned Llama)

Mengevaluasi Model Fine-tuned

Metrics untuk Classification

• Accuracy: Overall correctness
• Precision: Dari yang diprediksi positif, berapa yang benar?
• Recall: Dari yang sebenarnya positif, berapa yang ketangkap?
• F1-Score: Balance antara precision dan recall
• Confusion Matrix: Visualisasi kesalahan per kelas

Metrics untuk Generation

• BLEU: N-gram overlap dengan reference
• ROUGE: Recall-oriented for summarization
• Perplexity: Seberapa “yakin” model dengan output-nya
• Human Evaluation: Masih yang terbaik untuk quality assessment

Kesimpulan

Fine-tuning adalah superpower dalam AI modern. Dengan model pre-trained dan sedikit data spesifik, kamu bisa membuat AI yang powerful untuk task apapun.

Key takeaways:

1. Transfer learning: Leverage pengetahuan dari model besar
2. Choose approach: Feature extraction vs full fine-tuning vs LoRA
3. Learning rate: Kecil untuk fine-tuning (1e-5 - 5e-5)
4. Data quality: Lebih penting daripada quantity
5. Evaluate properly: Jangan cuma lihat training metrics

Next steps:

• Coba fine-tune BERT untuk sentiment analysis dengan dataset IMDB
• Eksplorasi LoRA untuk fine-tuning LLM besar
• Build chatbot spesifik untuk domain yang kamu kuasai

Selamat fine-tuning! 🚀

Punya pengalaman fine-tuning model? Share tips dan trikmu di komentar!