Cara Fine-Tuning LLM: Metode, Framework & Kode Langkah demi Langkah [2026]

Fine-tuning LLM berarti mengambil model yang sudah dilatih sebelumnya (pre-trained) dan melatihnya menggunakan data spesifik Anda agar performanya lebih baik dalam tugas tertentu dibandingkan hanya dengan prompt. Hambatan masuk kini telah runtuh: QLoRA + Unsloth memungkinkan Anda melakukan fine-tuning pada model 8 miliar parameter di GPU konsumen berkapasitas 12 GB dengan biaya cloud kurang dari $1.

Panduan ini mencakup seluruh perjalanan, mulai dari kapan harus melakukan fine-tuning (vs. RAG atau rekayasa prompt), metode dan framework mana yang harus dipilih, cara menyiapkan dataset, panduan Llama 3 yang siap salin-tempel, skenario biaya nyata, hingga penerapan (deployment).

Sekilas tentang Fine-Tuning

Sebelum Anda berkomitmen pada sesuatu, berikut gambaran cepatnya:

Sekarang, mari kita tentukan apakah fine-tuning benar-benar langkah yang tepat untuk proyek Anda.

Kapan Anda Harus Melakukan Fine-Tuning LLM? (vs. RAG vs. Rekayasa Prompt)

Ini adalah pertanyaan yang sering dilewatkan oleh sebagian besar pengembang, dan hal itu membuat mereka membuang waktu berminggu-minggu. Fine-tuning sangat kuat, tetapi tidak selalu menjadi alat yang tepat. Berikut kerangka kerja untuk memutuskan.

Keputusan bermuara pada apa yang ingin Anda ubah. Berikut adalah skenario nyata:

Jika Anda sedang memilih stack AI yang tepat untuk SaaS Anda, kerangka keputusan ini adalah langkah pertama. Banyak tim membangun pipeline RAG yang kompleks padahal fine-tune dengan 500 contoh akan memberikan hasil yang lebih konsisten dengan latensi lebih rendah.

Kesimpulan: Lakukan fine-tuning ketika Anda perlu model secara konsisten berperilaku berbeda, bukan hanya mengetahui hal-hal berbeda. Jika Anda hanya membutuhkan pengetahuan baru, RAG lebih murah dan lebih mudah dipelihara. Jika Anda membutuhkan keduanya, gunakan pendekatan hybrid.

Bagaimana Cara Kerja Fine-Tuning LLM? Full vs. LoRA vs. QLoRA

Ada tiga pendekatan utama, dan mereka berbeda secara dramatis dalam persyaratan hardware, biaya, dan kualitas. Memahami trade-off ini menyelamatkan Anda dari investasi berlebihan atau hasil yang kurang memuaskan.

Full Fine-Tuning (Ketika Anggaran Bukan Masalah)

Full fine-tuning memperbarui setiap parameter dalam model. Ini menghasilkan hasil terbaik tetapi membutuhkan sumber daya yang sangat besar, sekitar 100+ GB VRAM untuk model 7B (Anda perlu menyimpan model, status optimizer, dan gradien secara bersamaan). Ini adalah wilayah klaster H100. Kecuali Anda berada di lab dengan pendanaan besar, lewati ini.

LoRA: Revolusi PEFT

LoRA (Low-Rank Adaptation) membekukan model dasar dan menambahkan matriks kecil yang dapat dilatih yang disebut adapter. Alih-alih memperbarui matriks bobot besar W secara langsung, LoRA menguraikan pembaruan menjadi dua matriks kecil A dan B, di mana rank r jauh lebih kecil daripada dimensi model. Hasilnya: Anda melatih kira-kira 1-2% dari parameter asli sambil mempertahankan 98-99% kualitas full fine-tuning.

Pustaka peft dari Hugging Face adalah implementasi standarnya. Adapter LoRA biasanya berukuran 50-200 MB, sangat kecil dibandingkan dengan model penuh.

QLoRA: Fine-Tuning untuk Semua Orang

QLoRA membawa LoRA selangkah lebih maju. Ini memuat model dasar dalam presisi 4-bit menggunakan tipe data khusus bernama NormalFloat4 (NF4), lalu menerapkan adapter LoRA di atasnya. Kuantisasi 4-bit mengurangi penggunaan VRAM sebesar ~25% lagi dibandingkan LoRA standar sambil mempertahankan kualitas yang hampir identik.

Inilah yang membuat fine-tuning menjadi mudah diakses. Model 7B yang membutuhkan 100+ GB untuk full fine-tuning muat dalam 12 GB dengan QLoRA.

Kesimpulan: Untuk 90% pengembang, QLoRA adalah pilihan yang tepat. Perbedaan kualitas dari full fine-tuning dapat diabaikan untuk sebagian besar tugas, dan penghematan hardware sangat besar. Mulailah dari sana dan hanya tingkatkan skala jika metrik evaluasi Anda menuntutnya.

Framework Fine-Tuning Mana yang Harus Anda Gunakan di 2026?

Memilih framework lebih penting daripada yang disadari kebanyakan orang. Framework yang tepat menghemat berjam-jam penyiapan dan secara signifikan mempercepat pelatihan. Berikut perbandingan empat opsi utama.

Berikut rekomendasi cepatnya:

• Pertama kali fine-tune? Gunakan Unsloth. Pelatihan tercepat, penyiapan termudah, notebook Colab gratis untuk memulai segera.
• Butuh UI web tanpa kode? Gunakan LLaMA-Factory. GUI LLaMA-Board-nya memungkinkan Anda mengonfigurasi dan meluncurkan pelatihan dari browser.
• Melakukan alignment (RLHF, DPO, GRPO)? Gunakan TRL. Ini adalah standar Hugging Face untuk pelatihan berbasis preferensi, dan v0.15.0 (Maret 2026) menambahkan dukungan GRPO native.
• Menjalankan pipeline produksi di multi-GPU? Gunakan Axolotl. Konfigurasi berbasis YAML membuat eksperimen dapat direproduksi dan diaudit.

Satu trik berguna: Unsloth dan LLaMA-Factory dapat digabungkan. LLaMA-Factory mendukung Unsloth sebagai backend pelatihan, memberi Anda kenyamanan GUI dengan optimasi kecepatan Unsloth. Tim yang membangun agen AI yang menggunakan model fine-tuned sering memulai dengan Unsloth untuk iterasi cepat, lalu beralih ke Axolotl untuk reproduktibilitas produksi.

Bagaimana Cara Menyiapkan Dataset Fine-Tuning?

Kualitas data adalah faktor tunggal terbesar dalam keberhasilan fine-tuning. Dataset 500 contoh yang dikurasi dengan baik akan mengungguli dataset 10.000 contoh yang berisik hampir setiap saat.

Format Dataset

Dua format dominan adalah chat (kompatibel OpenAI) dan instruction (gaya Alpaca). Berikut tampilannya dalam format JSONL:

Format chat (direkomendasikan untuk sebagian besar kasus penggunaan):

{"messages": [{"role": "system", "content": "You are a customer support agent for Acme Inc. Be helpful, concise, and always reference the user's order number."}, {"role": "user", "content": "I ordered a laptop 3 days ago (order #4821) and it still says processing."}, {"role": "assistant", "content": "I can see order #4821 is currently in our warehouse being prepared for shipment. Laptops typically ship within 3-5 business days. You should receive a tracking number by tomorrow. Would you like me to flag this for priority processing?"}]}
{"messages": [{"role": "system", "content": "You are a customer support agent for Acme Inc. Be helpful, concise, and always reference the user's order number."}, {"role": "user", "content": "Can I return my keyboard? Order #3019, bought it last week."}, {"role": "assistant", "content": "Absolutely! Order #3019 is within our 30-day return window. I'll email you a prepaid return label right now. Once we receive the keyboard, your refund will process within 2-3 business days."}]}
{"messages": [{"role": "system", "content": "You are a customer support agent for Acme Inc. Be helpful, concise, and always reference the user's order number."}, {"role": "user", "content": "My monitor arrived cracked. Order #5573."}, {"role": "assistant", "content": "I'm sorry about that! For order #5573, I'm initiating an immediate replacement shipment -- no need to return the damaged unit. The new monitor will ship today with express delivery. You'll get a tracking email within the hour."}]}

Format instruction (gaya Alpaca):

{"instruction": "Summarize the following customer complaint in one sentence.", "input": "I've been waiting 2 weeks for my refund and nobody responds to my emails. This is the worst customer service I've ever experienced.", "output": "Customer is frustrated by a 2-week delay in receiving their refund and lack of email response from support."}
{"instruction": "Classify the sentiment of this review.", "input": "The product works fine but shipping took forever.", "output": "Mixed (positive product, negative shipping)"}

Pedoman Ukuran Dataset

Berapa banyak data yang sebenarnya Anda butuhkan? Tergantung pada kompleksitas tugas:

1. 50-100 contoh, bukti konsep, cukup untuk menguji apakah fine-tuning membantu
2. 500-1.000 contoh, berguna untuk sebagian besar tugas tunggal (klasifikasi, ekstraksi, pemformatan)
3. 5.000-10.000 contoh, hasil berkualitas produksi untuk tugas kompleks
4. 10.000+ contoh, hasil yang semakin menurun kecuali tugas Anda memiliki variabilitas tinggi

Daftar Periksa Kualitas Data

Sebelum pelatihan, validasi dataset Anda terhadap kriteria ini:

• Format konsisten di semua contoh (prompt sistem yang sama, struktur output yang sama)
• Contoh beragam yang mencakup kasus tepi (edge cases) dan mode kegagalan
• Tidak ada kontradiksi (jangan ajari model untuk mengatakan "ya" dan "tidak" pada pola input yang sama)
• Distribusi jenis output yang seimbang (jika melakukan klasifikasi, jangan memiliki 90% contoh dalam satu kelas)
• Hapus entri duplikat atau hampir duplikat

Tips pro: Gunakan GPT-4 atau Claude untuk menghasilkan data pelatihan sintetis awal, lalu sempurnakan dengan tinjauan manusia. 500 contoh sintetis berkualitas tinggi sering kali mengungguli 5.000 contoh nyata yang berisik. Panduan fine-tuning Meta merekomendasikan pendekatan ini untuk bootstrap dataset.

Langkah demi Langkah: Fine-Tune Llama 3 8B dengan QLoRA dan Unsloth

Berikut panduan lengkapnya. Setiap blok kode siap salin-tempel, Anda dapat menjalankannya di notebook Google Colab gratis atau di mesin apa pun dengan VRAM 12+ GB.

Langkah 1: Instal Unsloth

pip install unsloth

Itu saja. Unsloth menangani semua dependensi (transformers, peft, trl, bitsandbytes) secara otomatis.

Langkah 2: Muat Model Dasar dalam 4-bit

from unsloth import FastLanguageModel

# Load Llama 3.1 8B in 4-bit quantization
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Meta-Llama-3.1-8B-bnb-4bit",
    max_seq_length=2048,
    load_in_4bit=True,
)

Ini mengunduh model terkuantisasi 4-bit (~4 GB) dan memuatnya ke memori GPU. Pada RTX 3060 (12 GB), Anda akan memiliki banyak ruang untuk pelatihan.

Langkah 3: Konfigurasi Adapter LoRA

# Add LoRA adapters to the model
model = FastLanguageModel.get_peft_model(
    model,
    r=16,                # LoRA rank -- 16 is the sweet spot for most tasks
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                     "gate_proj", "up_proj", "down_proj"],
    lora_alpha=16,       # Scaling factor (usually equal to r)
    lora_dropout=0,      # Unsloth optimizes for 0 dropout
    bias="none",
)

Dengan r=16, Anda melatih sekitar 40 juta parameter dari 8 miliar, kurang dari 0,5% dari model. Itulah keajaiban LoRA.

Langkah 4: Muat Dataset Anda

from datasets import load_dataset

# Load your JSONL dataset from Hugging Face Hub or local file
dataset = load_dataset("json", data_files="train.jsonl", split="train")

# Format into chat template
def format_chat(example):
    text = tokenizer.apply_chat_template(
        example["messages"],
        tokenize=False,
        add_generation_prompt=False,
    )
    return {"text": text}

dataset = dataset.map(format_chat)

Ini mengambil format chat JSONL dari bagian sebelumnya dan menerapkan template chat Llama 3. Tokenizer menangani semua token khusus (<|begin_of_text|>, <|eot_id|>, dll.).

Langkah 5: Konfigurasi dan Jalankan Pelatihan

from trl import SFTTrainer
from transformers import TrainingArguments
from unsloth import is_bfloat16_supported

trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=2048,
    args=TrainingArguments(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,    # Effective batch size = 8
        warmup_steps=5,
        max_steps=60,                     # Adjust based on dataset size
        learning_rate=2e-4,               # Standard for QLoRA
        fp16=not is_bfloat16_supported(),
        bf16=is_bfloat16_supported(),
        logging_steps=1,
        output_dir="outputs",
        seed=42,
    ),
)

# Start training
trainer.train()

Hyperparameter kunci untuk dipahami:

• Learning rate (2e-4): Standar untuk QLoRA. Turunkan (2e-5) jika Anda melihat model melupakan kemampuan umum.
• Batch size (2) x akumulasi gradien (4): Ukuran batch efektif 8. Tingkatkan gradient_accumulation jika GPU Anda kehabisan memori.
• max_steps (60): Untuk 500 contoh, ini kira-kira 1 epoch. Mulailah dengan 1-3 epoch dan perhatikan loss validasi.
• Rank r (16): Lebih rendah (4-8) untuk tugas sederhana, lebih tinggi (32-64) untuk tugas kompleks. 16 adalah default yang aman.

Langkah 6: Simpan dan Uji

# Save the LoRA adapters (small -- ~50-200 MB)
model.save_pretrained("my-fine-tuned-model")
tokenizer.save_pretrained("my-fine-tuned-model")

# Quick inference test
FastLanguageModel.for_inference(model)
inputs = tokenizer(
    [tokenizer.apply_chat_template(
        [{"role": "user", "content": "I need to return order #7742"}],
        tokenize=False,
        add_generation_prompt=True,
    )],
    return_tensors="pt",
).to("cuda")

outputs = model.generate(**inputs, max_new_tokens=256)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

Itulah seluruh pipeline. Pada RTX 4090 dengan Unsloth, pelatihan 500 contoh memakan waktu sekitar 15-30 menit. Di Colab T4 gratis, perkirakan 1-2 jam.

Bagaimana dengan Fine-Tuning Berbasis API? (OpenAI, Google, Mistral)

Tidak semua orang ingin mengelola GPU. Penyedia API memungkinkan Anda melakukan fine-tuning melalui alur kerja unggah-dan-latih yang sederhana. Berikut perbandingannya dengan menjalankannya sendiri.

Kapan fine-tuning API masuk akal: Anda perlu iterasi cepat, dataset Anda kecil, Anda tidak ingin mengelola infrastruktur, atau Anda secara khusus membutuhkan model tertutup seperti GPT-4o.

Kapan fine-tuning lokal menang: Privasi data penting (kesehatan, keuangan, hukum), Anda sering melakukan pelatihan, Anda ingin memiliki dan mengekspor bobot, atau Anda mengoptimalkan biaya dalam skala besar.

Kesimpulan: Fine-tuning API adalah jalur tercepat menuju bukti konsep. Fine-tuning lokal adalah jalur termurah menuju produksi. Sebagian besar tim membuat prototipe di API, lalu beralih ke Unsloth lokal setelah mereka memvalidasi pendekatannya.

Berapa Biaya untuk Fine-Tune LLM?

Narasi "fine-tuning itu mahal" terjebak di tahun 2023. Berikut biaya sebenarnya hari ini.

Kurva biaya mendatar dengan cepat. Startup yang melakukan fine-tuning model 8B di RunPod menghabiskan biaya pelatihan lebih sedikit daripada secangkir kopi. Bahkan skenario produksi 70B berada di bawah $30 -- itu setara dengan anggaran makan siang harian seorang pengembang junior selama satu bulan.

Penyedia GPU cloud yang layak dibandingkan: RunPod (harga spot terbaik), Lambda (H100 on-demand yang andal), Vast.ai (termurah tetapi kualitas bervariasi), dan Modal (serverless, bayar per detik).

Grafik di atas menunjukkan mengapa QLoRA mengubah permainan. Model 7B yang membutuhkan klaster multi-GPU untuk full fine-tuning kini muat di GPU laptop. Model 70B turun dari "hanya cloud" menjadi satu A100.

Kesimpulan: Anda dapat melakukan fine-tuning model 8B berkualitas produksi dengan biaya di bawah $1. Hambatan biaya untuk fine-tuning telah hilang. Biaya sebenarnya adalah waktu persiapan dataset.

Bagaimana Cara Mengevaluasi Model Fine-Tuned?

Pelatihan hanyalah setengah dari pekerjaan. Tanpa evaluasi yang tepat, Anda tidak dapat mengetahui apakah model fine-tuned Anda benar-benar meningkat, atau hanya menghafal data pelatihan Anda.

Metrik Otomatis

Pantau ini selama dan setelah pelatihan:

• Training loss / perplexity: Harus menurun secara stabil, lalu mendatar. Jika turun hingga mendekati nol, Anda mengalami overfitting.
• Metrik spesifik tugas: Akurasi (klasifikasi), BLEU/ROUGE (ringkasan), exact match (ekstraksi), F1 (multi-label). Pilih metrik yang sesuai dengan tugas Anda.

Evaluasi Manusia

Angka tidak menangkap segalanya. Untuk tugas generatif:

• Pengujian A/B: Tampilkan output model dasar vs. fine-tuned berdampingan. Minta 3-5 evaluator memilih respons yang lebih baik di 50+ contoh. Lacak tingkat kemenangan.
• Peringkat skala Likert: Beri peringkat output berdasarkan relevansi (1-5), akurasi (1-5), dan nada (1-5). Hitung peningkatan rata-rata dibandingkan model dasar.

Pemeriksaan Catastrophic Forgetting

Ini adalah hal yang paling sering dilewatkan pengembang. Setelah fine-tuning, jalankan model Anda pada benchmark umum seperti MMLU atau HellaSwag. Jika skor turun lebih dari 2-3 poin, model Anda telah kehilangan terlalu banyak pengetahuan umum. Solusinya: turunkan learning rate, kurangi epoch, atau beralih ke LoRA (yang membekukan bobot dasar).

Aturan praktis: Selalu sisihkan 10-20% dataset Anda sebagai set uji. Jangan pernah mengevaluasi pada data pelatihan, itu tidak memberi tahu Anda apa-apa tentang kinerja dunia nyata.

Bagaimana Cara Menerapkan Model Fine-Tuned?

Pelatihan selesai. Sekarang Anda perlu menyajikannya. Sebagian besar panduan melewatkan bagian ini sepenuhnya.

Langkah 1: Gabungkan Adapter LoRA

Jika Anda menggunakan LoRA atau QLoRA, gabungkan adapter kembali ke model dasar untuk inferensi:

# Merge adapters into base model
model.merge_and_unload()
model.save_pretrained("merged-model")
tokenizer.save_pretrained("merged-model")

Langkah 2: Pilih Jalur Deployment Anda

Pengembangan lokal dan pengujian, Ollama:

# Convert to GGUF format (Ollama's native format)
python llama.cpp/convert_hf_to_gguf.py merged-model --outfile model.gguf --outtype q4_k_m

# Create an Ollama model
ollama create my-fine-tuned-model -f Modelfile
ollama run my-fine-tuned-model

Penyajian produksi, vLLM:

# Start an OpenAI-compatible API server
python -m vllm.entrypoints.openai.api_server \
    --model merged-model \
    --host 0.0.0.0 \
    --port 8000

Serverless (nol infrastruktur): Unggah model Anda ke Together AI, Fireworks, atau Modal. Anda mendapatkan endpoint API tanpa mengelola server. Biaya skala sesuai penggunaan.

Lanjutan: Penyajian Multi-Adapter

Berikut pola yang seharusnya lebih banyak digunakan tim: pertahankan satu model dasar dimuat dalam memori dan tukar adapter LoRA per permintaan. Anda dapat menyajikan adapter dukungan pelanggan, adapter tinjauan kode, dan adapter ringkasan, semuanya dari satu GPU. vLLM mendukung ini secara native dengan flag --enable-lora.

Siap untuk menerapkan? Lihat Alat & Platform Fine-Tuning LLM Terbaik [segera hadir] untuk perbandingan mendalam opsi deployment.

Apa Kesalahan Fine-Tuning yang Paling Umum?

Setelah membantu tim men-debug puluhan run fine-tuning, inilah kesalahan yang muncul berulang kali.

1. Overfitting pada dataset kecil. Anda melatih selama 10 epoch pada 200 contoh, training loss mencapai mendekati nol, dan model mengulangi data pelatihan Anda secara verbatim. Solusi: Maksimal 1-3 epoch, gunakan set validasi, dan perhatikan kesenjangan antara training loss dan eval loss.

2. Catastrophic forgetting. Model menguasai tugas spesifik Anda tetapi tidak dapat lagi mengadakan percakapan dasar. Solusi: gunakan LoRA/QLoRA (membekukan bobot dasar), jaga learning rate tetap rendah (2e-5 untuk full fine-tuning, 2e-4 untuk QLoRA), dan evaluasi pada benchmark umum sebelum deployment.

3. Kualitas data sampah. Format tidak konsisten, kontradiksi antar contoh, atau duplikat. Model mempelajari noise. Solusi: bersihkan data Anda sebelum pelatihan. Selalu. Habiskan lebih banyak waktu untuk kurasi data daripada penyetelan hyperparameter.

4. Memulai dengan model yang terlalu besar. Tim langsung melompat ke 70B karena "lebih besar lebih baik," lalu tidak mampu membayar biaya GPU. Solusi: mulailah dengan 8B. Jika 8B dengan data bagus tidak dapat menyelesaikan tugas Anda, 70B dengan data yang sama mungkin juga tidak akan bisa. Tingkatkan kualitas data terlebih dahulu, lalu ukuran model.

5. Tidak ada pipeline evaluasi. Melatih tanpa set uji yang disisihkan, lalu menerapkan berdasarkan perasaan. Solusi: pisahkan data Anda 80/10/10 (train/val/test) sebelum Anda mulai. Bandingkan dengan model dasar pada setiap contoh uji.

6. Learning rate terlalu tinggi. Menghancurkan pengetahuan pre-trained dalam beberapa langkah pertama. Model mengeluarkan omong kosong. Solusi: mulai dari 2e-4 untuk QLoRA, 2e-5 untuk full fine-tuning. Jika output menurun, turunkan.

Bagaimana Techsy Mendekati Fine-Tuning LLM

Di Techsy, kami mengikuti jalur eskalasi ketat untuk setiap proyek AI: rekayasa prompt pertama, RAG kedua, fine-tuning hanya ketika data membuktikan itu diperlukan. Sebagian besar proyek klien sebenarnya tidak memerlukan fine-tuning, prompt yang dirancang dengan baik atau pipeline RAG memecahkan masalah dengan biaya dan kompleksitas lebih rendah.

Ketika fine-tuning adalah panggilan yang tepat, berikut proses kami:

1. Audit dataset, Kami meninjau data klien untuk kualitas, cakupan, dan format. Jika kami tidak memiliki cukup contoh, kami membantu membangun dataset sintetis menggunakan GPT-4 atau Claude dengan tinjauan manusia.
2. Pemilihan framework, Unsloth + QLoRA untuk 90% proyek startup. Axolotl untuk klien yang membutuhkan pipeline produksi multi-GPU yang dapat direproduksi.
3. Pelatihan dan evaluasi, Kami selalu melatih dengan set uji yang disisihkan dan benchmark terhadap model dasar. Jika model fine-tuned tidak meningkatkan metrik target secara terukur, kami tidak menerapkannya.
4. Deployment, vLLM untuk penyajian produksi, pola multi-adapter ketika klien membutuhkan beberapa model khusus dari satu GPU.

Kami telah mengirimkan model fine-tuned untuk startup yang tidak mampu membayar anggaran GPU perusahaan, QLoRA di RunPod menjaga biaya di bawah $30 bahkan untuk model 70B.

Butuh bantuan fine-tuning LLM untuk kasus penggunaan Anda? Kami membantu tim pergi dari data mentah ke model yang diterapkan. Dapatkan konsultasi gratis

Pertanyaan yang Sering Diajukan tentang Fine-Tuning LLM

Apa itu fine-tuning LLM?

Fine-tuning LLM adalah proses melatih model bahasa pre-trained pada data spesifik tugas Anda sendiri agar performanya lebih baik dalam tugas tersebut. Anda pada dasarnya mengajarkan model perilaku baru, format, atau keahlian domain yang tidak dapat dicapai secara andal oleh prompting generik.

Kapan saya harus melakukan fine-tuning vs. menggunakan RAG?

Lakukan fine-tuning ketika Anda perlu model berperilaku berbeda, format output konsisten, bahasa spesifik domain, nada tertentu. Gunakan RAG ketika model perlu mengetahui hal-hal berbeda, terutama jika pengetahuan itu sering berubah. Untuk banyak sistem produksi, pendekatan hybrid bekerja paling baik.

Berapa biaya untuk fine-tune LLM?

Di mana saja dari $0 hingga $540 tergantung pada skala. Sebagian besar pengembang individu menghabiskan kurang dari $1 menggunakan QLoRA di RunPod RTX 4090 ($0,34/jam). Model produksi 70B di A100 berharga $17-27. Full fine-tuning di klaster H100 berjalan $270-540. Fine-tuning API (OpenAI) berharga $3-25 untuk 1.000 contoh.

Bisakah saya melakukan fine-tune LLM di laptop saya?

Ya, jika laptop Anda memiliki GPU dengan VRAM 12+ GB. GPU laptop RTX 3060 menangani model 8B dengan QLoRA. Mac Apple Silicon dengan memori terunifikasi 16+ GB juga dapat melakukan fine-tune melalui MLX, meskipun lebih lambat daripada CUDA. Untuk model yang lebih besar, Anda memerlukan GPU cloud.

Apa perbedaan antara LoRA dan QLoRA?

Keduanya menambahkan lapisan adapter kecil yang dapat dilatih sambil membekukan model dasar. Perbedaannya: QLoRA juga mengkuantisasi model dasar ke presisi 4-bit (tipe data NF4), mengurangi penggunaan VRAM sebesar ~25% dibandingkan LoRA standar. Kualitasnya hampir identik, QLoRA mencapai 97-99% kualitas full fine-tuning.

Berapa banyak contoh pelatihan yang saya butuhkan?

Tergantung pada kompleksitas tugas. 50-100 contoh cukup untuk bukti konsep. 500-1.000 contoh menghasilkan hasil yang berguna untuk sebagian besar tugas tunggal. 5.000-10.000 contoh memberikan kualitas produksi untuk tugas kompleks. Di atas 10.000, Anda mencapai hasil yang semakin menurun kecuali tugas memiliki variabilitas yang sangat tinggi.

Model dasar mana yang harus saya fine-tune di 2026?

Llama 3.x untuk tugas tujuan umum (rasio kualitas/ukuran terbaik secara keseluruhan). Mistral untuk bahasa Eropa dan inferensi efisien. Qwen 2.5 untuk tugas multibahasa dan kode. Phi-4 ketika Anda membutuhkan jejak sekecil mungkin. Gemma 2 untuk integrasi ekosistem Google.

Apa itu GRPO dan mengapa itu penting?

GRPO (Group Relative Policy Optimization), diperkenalkan oleh DeepSeek, adalah penerus RLHF untuk pelatihan alignment. Keuntungan utamanya: tidak memerlukan pelatihan model reward terpisah, yang memotong biaya komputasi sekitar setengahnya. TRL v0.15.0 mendukung GRPO secara native, membuatnya dapat diakses oleh siapa saja yang menggunakan ekosistem Hugging Face.

Bagaimana cara mencegah catastrophic forgetting?

Gunakan LoRA atau QLoRA alih-alih full fine-tuning, mereka membekukan bobot model dasar, yang mempertahankan pengetahuan umum. Jaga learning rate Anda tetap rendah (2e-4 untuk QLoRA, 2e-5 untuk full). Latih selama epoch sesedikit mungkin (1-3 biasanya cukup). Setelah pelatihan, jalankan model Anda pada benchmark umum (MMLU, HellaSwag) untuk memverifikasi bahwa itu tidak mengalami kemunduran.

Bisakah saya melakukan fine-tune dan kemudian menggunakan RAG bersama-sama?

Tentu saja, dan banyak sistem produksi melakukan persis ini. Lakukan fine-tune untuk konsistensi perilaku dan format, lalu hubungkan RAG untuk pengambilan pengetahuan terbaru. Model fine-tuned lebih baik dalam menggunakan konteks yang diambil karena memahami bahasa domain dan persyaratan output Anda.

Berapa lama waktu yang dibutuhkan untuk fine-tuning?

Untuk sebagian besar proyek, 30 menit hingga 8 jam. Model 8B dengan 500 contoh di Unsloth + RTX 4090 selesai dalam 15-30 menit. Pekerjaan yang sama di Colab T4 gratis memakan waktu 1-2 jam. Model 70B di A100 memakan waktu 5-8 jam. Full fine-tuning pada pengaturan multi-GPU dapat memakan waktu 20-40 jam.

Apakah API fine-tuning OpenAI worth it?

Untuk pembuatan prototipe cepat, ya. Anda dapat mengunggah file JSONL dan memiliki GPT-4o-mini fine-tuned dalam 30 menit tanpa penyiapan GPU. Untuk produksi, fine-tuning lokal biasanya lebih baik: Anda memiliki bobot, mengontrol privasi data Anda, dan biaya lebih rendah dalam skala besar. Sebagian besar tim memulai dengan API untuk memvalidasi pendekatan, lalu bermigrasi ke lokal.

Kesimpulan

Fine-tuning LLM bukanlah sihir hitam seperti dua tahun lalu. Berikut adalah poin-poin kunci:

1. Mulailah dengan QLoRA + Unsloth, ini menangani 90% kasus penggunaan pada hardware konsumen
2. Data bagus mengalahkan model yang lebih besar setiap saat. Habiskan usaha Anda pada kualitas dataset, bukan upgrade GPU.
3. Hambatan biaya telah hilang, fine-tune model 8B dengan biaya di bawah $1 di GPU cloud
4. Selalu evaluasi terhadap model dasar sebelum deployment. Jika tidak lebih baik secara terukur, jangan luncurkan.
5. Pertimbangkan RAG terlebih dahulu, lakukan fine-tune hanya ketika Anda perlu model berperilaku berbeda, bukan hanya mengetahui hal-hal berbeda

Siap untuk menerapkan? Lihat Alat & Platform Fine-Tuning LLM Terbaik [segera hadir] untuk perbandingan terperinci framework pelatihan dan opsi deployment.

Jika Anda menemukan panduan ini bermanfaat, lihat walkthrough kami tentang memilih stack AI yang tepat untuk keputusan arsitektur yang lebih luas seputar produk bertenaga AI.

Sumber

• Repositori GitHub Unsloth, framework fine-tuning dengan peningkatan kecepatan 2-5x
• Dokumentasi TRL Hugging Face, Implementasi SFTTrainer, DPO, dan GRPO
• Dokumentasi PEFT Hugging Face, LoRA dan fine-tuning efisien parameter
• Makalah QLoRA (Dettmers dkk., 2023) -- penelitian kuantisasi NormalFloat 4-bit
• Makalah LoRA (Hu dkk., 2021), adaptasi low-rank model bahasa besar
• Dokumentasi API Fine-Tuning OpenAI, alur kerja fine-tuning berbasis API
• Harga Cloud GPU RunPod, referensi biaya GPU cloud
• Dokumentasi vLLM, penyajian LLM produksi
• Panduan Fine-Tuning Meta Llama, rekomendasi pelatihan Llama resmi
• Makalah DeepSeekMath (GRPO), Group Relative Policy Optimization