Cara Fine-Tune Gemma 4 dengan LoRA (Langkah demi Langkah)

Gemma 4 sudah mengesankan dari bawaan, tapi bagaimana jika kamu butuh ia berbicara seperti brand-mu, mengikuti format output spesifikmu, atau menguasai domain khusus yang membuat model umum kesulitan? Di situlah fine-tuning berperan.

Kabar baik: kamu tidak butuh kluster A100 lagi. Dengan LoRA dan tool bernama Unsloth, kamu bisa fine-tune Gemma 4 di satu GPU dalam waktu kurang dari satu jam. Mari kita bahas seluruh prosesnya.

Mengapa Fine-Tune Sama Sekali?

Sebelum kamu menginvestasikan usaha, pastikan fine-tuning benar-benar yang kamu butuhkan. Berikut panduan keputusan cepat:

Situasi	Solusi
Model tidak tahu domain-mu	Fine-tune dengan data domain
Model mengabaikan format output	Fine-tune dengan contoh format
Model butuh info terkini	Gunakan RAG saja
Model terlalu verbose/singkat	Coba prompt engineering dulu
Model kadang memberi jawaban salah	Coba few-shot prompting dulu

Jika prompt engineering dan RAG tidak cukup, fine-tuning adalah langkah selanjutnya. Sebelum mendalami, coba prompt Gemma 4 terbaik kami — kamu mungkin memecahkan masalah hanya dengan prompting lebih baik. Untuk melihat lebih luas apa yang Gemma 4 bisa lakukan sebelum kamu mulai menyesuaikannya, cek panduan kasus penggunaan kami.

LoRA dan QLoRA Dijelaskan (Secara Sederhana)

LoRA (Low-Rank Adaptation) tidak memodifikasi bobot model asli. Sebaliknya, ia melatih set kecil bobot adapter yang duduk di atas model dasar. Bayangkan seperti memasang lensa kustom pada kamera daripada membangun ulang kamera.

Model dasar: dibekukan, tidak disentuh
Adapter: kecil (biasanya 1-5% dari ukuran model dasar)
Hasil: mendekati kualitas fine-tune penuh dengan sebagian kecil biaya

QLoRA melangkah lebih jauh — memuat model dasar dalam bentuk terkuantisasi 4-bit, memotong penggunaan memori sekitar setengahnya. Kamu mendapat 90%+ kualitas LoRA sambil muat di GPU yang jauh lebih kecil.

Metode	VRAM Dibutuhkan (Gemma 4 E4B)	VRAM Dibutuhkan (Gemma 4 26B)	Kualitas
Fine-tune penuh	32GB+	100GB+	Terbaik
LoRA	16GB	48GB	~98% dari penuh
QLoRA	8GB	24GB	~95% dari penuh

Menyiapkan Unsloth

Unsloth adalah cara tercepat untuk fine-tune Gemma 4 dengan LoRA. Ia melakukan patch model untuk pelatihan 2x lebih cepat dan penggunaan memori 60% lebih sedikit dibanding HuggingFace vanilla.

# Buat virtual environment
python -m venv gemma4-finetune
source gemma4-finetune/bin/activate

# Instal Unsloth (termasuk semua dependensi)
pip install unsloth

# Untuk QLoRA di GPU lama, instal juga:
pip install bitsandbytes

Verifikasi setup-mu:

import torch
print(f"CUDA available: {torch.cuda.is_available()}")
print(f"GPU: {torch.cuda.get_device_name(0)}")
print(f"VRAM: {torch.cuda.get_device_properties(0).total_mem / 1e9:.1f} GB")

Menyiapkan Data Pelatihan

Datamu harus dalam format JSONL, dengan setiap baris berisi percakapan. Berikut struktur yang diharapkan Gemma 4:

{"messages": [{"role": "user", "content": "Apa kebijakan pengembalian?"}, {"role": "assistant", "content": "Kebijakan pengembalian kami memungkinkan pengembalian dalam 30 hari pembelian dengan struk asli."}]}
{"messages": [{"role": "user", "content": "Apakah kalian kirim internasional?"}, {"role": "assistant", "content": "Ya, kami kirim ke 45 negara. Pengiriman butuh 7-14 hari kerja."}]}
{"messages": [{"role": "system", "content": "Kamu adalah asisten medical coding."}, {"role": "user", "content": "Code: Pasien dengan bronkitis akut"}, {"role": "assistant", "content": "ICD-10: J20.9 - Bronkitis akut, tidak spesifik"}]}

Tips kualitas data:

500-1000 contoh adalah sweet spot untuk sebagian besar tugas
Lebih banyak tidak selalu lebih baik — 500 contoh berkualitas mengalahkan 5000 yang asal-asalan
Sertakan edge case dan contoh negatif
Jaga respons konsisten dalam format dan nada
Validasi JSONL-mu sebelum pelatihan:

import json

def validate_jsonl(filepath):
    valid = 0
    errors = 0
    with open(filepath, 'r') as f:
        for i, line in enumerate(f, 1):
            try:
                data = json.loads(line)
                assert "messages" in data, "Missing 'messages' key"
                assert len(data["messages"]) >= 2, "Need at least 2 messages"
                valid += 1
            except (json.JSONDecodeError, AssertionError) as e:
                print(f"Line {i}: {e}")
                errors += 1
    print(f"\nValid: {valid}, Errors: {errors}")

validate_jsonl("training_data.jsonl")

Konfigurasi Pelatihan

Berikut skrip pelatihan lengkap menggunakan Unsloth:

from unsloth import FastLanguageModel
import torch

# Load model dengan QLoRA (4-bit)
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="google/gemma-4-e4b",
    max_seq_length=4096,
    dtype=None,           # Auto-detect
    load_in_4bit=True,    # QLoRA
)

# Tambahkan LoRA adapter
model = FastLanguageModel.get_peft_model(
    model,
    r=16,                  # Rank — lebih tinggi = lebih kapasitas, lebih VRAM
    target_modules=[
        "q_proj", "k_proj", "v_proj", "o_proj",
        "gate_proj", "up_proj", "down_proj",
    ],
    lora_alpha=16,
    lora_dropout=0,        # Unsloth teroptimasi — biarkan 0
    bias="none",
    use_gradient_checkpointing="unsloth",
)

# Load data pelatihan
from datasets import load_dataset
dataset = load_dataset("json", data_files="training_data.jsonl", split="train")

# Argumen pelatihan
from trl import SFTTrainer
from transformers import TrainingArguments

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    max_seq_length=4096,
    args=TrainingArguments(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        warmup_steps=10,
        num_train_epochs=3,
        learning_rate=2e-4,
        fp16=not torch.cuda.is_bf16_supported(),
        bf16=torch.cuda.is_bf16_supported(),
        logging_steps=10,
        output_dir="outputs",
        optim="adamw_8bit",
        seed=42,
    ),
)

# Latih
trainer.train()

# Simpan LoRA adapter
model.save_pretrained("gemma4-finetuned-lora")
tokenizer.save_pretrained("gemma4-finetuned-lora")

Parameter kunci untuk dituning:

r=16: LoRA rank. Mulai dengan 16, naik ke 32 atau 64 jika kualitas kurang
num_train_epochs=3: Biasanya 2-5 sudah cukup. Waspada overfitting
learning_rate=2e-4: Default bekerja baik. Turunkan ke 1e-4 jika pelatihan tidak stabil
per_device_train_batch_size=2: Naikkan jika punya ruang VRAM

Ekspor ke GGUF

Setelah adapter kamu terlatih, kamu mungkin ingin menjalankannya secara lokal dengan Ollama. Itu berarti konversi ke format GGUF. Untuk rincian detail opsi kuantisasi dan trade-off-nya, lihat panduan GGUF kami.

# Merge adapter dan ekspor ke GGUF (kuantisasi Q4_K_M)
model.save_pretrained_gguf(
    "gemma4-finetuned-gguf",
    tokenizer,
    quantization_method="q4_k_m",
)

# Atau ekspor di beberapa level kuantisasi
for method in ["q4_k_m", "q5_k_m", "q8_0"]:
    model.save_pretrained_gguf(
        f"gemma4-finetuned-{method}",
        tokenizer,
        quantization_method=method,
    )

Kuantisasi	Ukuran File (E4B)	Kehilangan Kualitas	Terbaik Untuk
Q4_K_M	~2.5 GB	Minimal	Kebanyakan user
Q5_K_M	~3.2 GB	Sangat kecil	Fokus kualitas
Q8_0	~4.8 GB	Dapat diabaikan	Saat VRAM memungkinkan

Deploy dengan Ollama

Buat Modelfile untuk membawa model fine-tuned-mu ke Ollama:

# Modelfile
FROM ./gemma4-finetuned-gguf/gemma4-finetuned-q4_k_m.gguf

PARAMETER temperature 0.7
PARAMETER top_p 0.9

SYSTEM "Kamu adalah asisten yang membantu, fine-tuned untuk customer support."

Lalu build dan jalankan:

# Buat model kustom
ollama create my-gemma4 -f Modelfile

# Test
ollama run my-gemma4 "Apa kebijakan pengembalian kalian?"

# Verifikasi terdaftar
ollama list

Model fine-tuned-mu sekarang berjalan persis seperti model Ollama lainnya. Kamu bisa menggunakannya dengan API Ollama, membangun aplikasi di atasnya, atau membagikannya dengan tim-mu.

Masalah Umum dan Solusinya

Kehabisan memori saat pelatihan: Turunkan per_device_train_batch_size ke 1, aktifkan gradient_checkpointing, atau beralih ke model dasar lebih kecil.

Model menghasilkan sampah setelah fine-tuning: Datamu mungkin punya masalah formatting, atau kamu berlatih terlalu banyak epoch. Kurangi epoch dan validasi JSONL-mu.

Ekspor GGUF gagal: Pastikan kamu punya ruang disk cukup (3-5x ukuran model selama konversi) dan versi Unsloth-mu up to date.

Training loss tidak menurun: Learning rate mungkin terlalu rendah. Coba 5e-4. Juga cek apakah datamu benar-benar punya pola yang kamu ingin model pelajari.

Langkah Selanjutnya

Jelajahi ukuran model Gemma 4 untuk memilih model dasar terbaik untuk fine-tuning
Siapkan pipeline deployment yang proper untuk model fine-tuned-mu
Pelajari tentang output JSON terstruktur untuk menggabungkan fine-tuning dengan format output yang andal
Cek kebutuhan hardware untuk merencanakan setup pelatihanmu

gemma4 — interact