Tutorial Lengkap LlamaFactory: Toolkit Fine-Tuning LLM All-in-One

# Tutorial Lengkap LlamaFactory: Toolkit Fine-Tuning LLM All-in-One Fine-tuning Large Language Model (LLM) sering kali menjadi proses yang kompleks dan membutuhkan banyak konfigurasi manual. LlamaFac...

By Ruby Abdullah · · tutorial
LlamaFactoryLLM Fine-TuningLoRAQLoRAMachine Learning

Tutorial Lengkap LlamaFactory: Toolkit Fine-Tuning LLM All-in-One

Fine-tuning Large Language Model (LLM) sering kali menjadi proses yang kompleks dan membutuhkan banyak konfigurasi manual. LlamaFactory hadir sebagai solusi yang menyederhanakan seluruh proses fine-tuning dengan antarmuka yang intuitif dan dukungan untuk berbagai model serta metode training. Dalam tutorial ini, kita akan mempelajari cara menggunakan LlamaFactory dari instalasi hingga deployment model yang sudah di-fine-tune.

Apa itu LlamaFactory?

LlamaFactory (atau LLaMA-Factory) adalah toolkit open-source yang menyediakan framework terpadu untuk fine-tuning lebih dari 100 model bahasa. Toolkit ini mendukung berbagai metode training termasuk full fine-tuning, LoRA, QLoRA, dan metode Parameter-Efficient Fine-Tuning (PEFT) lainnya. Salah satu keunggulan utama LlamaFactory adalah LLaMA Board, antarmuka web berbasis Gradio yang memungkinkan fine-tuning tanpa menulis kode.

Fitur Utama

  • Multi-Model Support: Mendukung LLaMA, Mistral, Qwen, Phi, Gemma, Yi, DeepSeek, dan banyak lagi
  • Metode Training Beragam: Full fine-tuning, LoRA, QLoRA, DoRA, dan GaLore
  • LLaMA Board: Web UI untuk fine-tuning tanpa coding
  • Dataset Terintegrasi: Puluhan dataset bawaan siap pakai
  • Evaluasi Otomatis: Benchmark otomatis dengan MMLU, CMMLU, dan C-Eval
  • Export Model: Export ke GGUF, vLLM, atau format lainnya

Instalasi

Prasyarat Sistem

Sebelum menginstal LlamaFactory, pastikan sistem Anda memenuhi persyaratan berikut:

  • Python 3.8 atau lebih baru
  • CUDA 11.8 atau 12.1 (untuk GPU NVIDIA)
  • Minimal 16GB RAM (disarankan 32GB)
  • GPU dengan minimal 8GB VRAM untuk QLoRA, 16GB untuk LoRA, 40GB+ untuk full fine-tuning

Instalasi dari Source

git clone --depth 1 https://github.com/hiyouga/LLaMA-Factory.git

cd LLaMA-Factory


pip install -e ".[torch,metrics]"

Instalasi dengan Docker

docker pull hiyouga/llamafactory:latest


docker run --gpus all \


  -v ./hfcache:/root/.cache/huggingface \


  -v ./data:/app/data \


  -v ./output:/app/output \


  -p 7860:7860 \


  -e GRADIOSHARE=1 \


  hiyouga/llamafactory:latest

Verifikasi Instalasi

llamafactory-cli version

Output yang diharapkan:

----------------------------------------------------------

| Welcome to LLaMA Factory, version x.x.x               |


| Project page: https://github.com/hiyouga/LLaMA-Factory |

Instalasi Dependencies Opsional

# Untuk quantisasi GPTQ

pip install auto-gptq



Untuk quantisasi AWQ


pip install autoawq



Untuk Flash Attention 2


pip install flash-attn --no-build-isolation



Untuk vLLM inference


pip install vllm

Basic Usage: Fine-Tuning dengan CLI

Menyiapkan Dataset

LlamaFactory menggunakan format dataset khusus. Buat file JSON dengan format berikut:

[

  {


    "instruction": "Jelaskan apa itu machine learning dalam bahasa sederhana.",


    "input": "",


    "output": "Machine learning adalah cabang dari kecerdasan buatan di mana komputer belajar dari data untuk membuat prediksi atau keputusan tanpa diprogram secara eksplisit. Bayangkan seperti mengajarkan anak kecil mengenali hewan - semakin banyak contoh yang dilihat, semakin baik kemampuannya mengenali hewan baru."


  },


  {


    "instruction": "Tulis kode Python untuk menghitung faktorial.",


    "input": "5",


    "output": "def factorial(n):\n    if n <= 1:\n        return 1\n    return n * factorial(n - 1)\n\nresult = factorial(5)\nprint(f'Faktorial dari 5 adalah {result}')  # Output: 120"


  }


]

Simpan file tersebut misalnya sebagai data/mydataset.json. Lalu daftarkan dataset di data/datasetinfo.json:

{

  "mycustomdataset": {


    "filename": "mydataset.json",


    "columns": {


      "prompt": "instruction",


      "query": "input",


      "response": "output"


    }


  }


}

Format Dataset untuk Chat/Conversation

Untuk dataset percakapan multi-turn, gunakan format berikut:

[

  {


    "conversations": [


      {"from": "human", "value": "Apa itu Python?"},


      {"from": "gpt", "value": "Python adalah bahasa pemrograman tingkat tinggi yang terkenal dengan sintaksnya yang bersih dan mudah dibaca."},


      {"from": "human", "value": "Apa kelebihannya dibanding Java?"},


      {"from": "gpt", "value": "Python memiliki beberapa kelebihan dibanding Java: sintaks lebih ringkas, kurva belajar lebih landai, ekosistem library data science yang sangat kaya, dan proses development yang lebih cepat."}


    ]


  }


]

Menjalankan Fine-Tuning dengan CLI

Berikut contoh fine-tuning model Qwen2.5-7B menggunakan LoRA:

llamafactory-cli train \

  --stage sft \


  --modelnameorpath Qwen/Qwen2.5-7B \


  --dataset mycustomdataset \


  --template qwen \


  --finetuningtype lora \


  --lorarank 16 \


  --loraalpha 32 \


  --loradropout 0.05 \


  --outputdir output/qwen25-7b-lora \


  --perdevicetrainbatchsize 4 \


  --gradientaccumulationsteps 4 \


  --learningrate 5e-5 \


  --numtrainepochs 3 \


  --loggingsteps 10 \


  --savesteps 100 \


  --fp16 true \


  --maxlength 2048

Menggunakan File YAML untuk Konfigurasi

Untuk proyek yang lebih kompleks, gunakan file konfigurasi YAML:

# config/trainqwenlora.yaml

Model


modelnameorpath: Qwen/Qwen2.5-7B


trustremotecode: true



Method


stage: sft


dotrain: true


finetuningtype: lora


lorarank: 16


loraalpha: 32


loradropout: 0.05


loratarget: all



Dataset


dataset: mycustomdataset


template: qwen


cutofflen: 2048


overwritecache: true


preprocessingnumworkers: 16



Output


outputdir: output/qwen25-7b-lora


loggingsteps: 10


savesteps: 100


overwriteoutputdir: true



Train


perdevicetrainbatchsize: 4


gradientaccumulationsteps: 4


learningrate: 5.0e-5


numtrainepochs: 3.0


lrschedulertype: cosine


warmupratio: 0.1


fp16: true

Jalankan training dengan:

llamafactory-cli train config/trainqwenlora.yaml

Menggunakan LLaMA Board (Web UI)

LLaMA Board adalah fitur unggulan LlamaFactory yang memungkinkan fine-tuning melalui antarmuka web.

Menjalankan LLaMA Board

llamafactory-cli webui

Browser akan terbuka secara otomatis di http://localhost:7860. Antarmuka ini menyediakan:

  • Tab Train: Konfigurasi dan jalankan fine-tuning
  • Tab Evaluate: Evaluasi model dengan benchmark
  • Tab Chat: Test model secara interaktif
  • Tab Export: Export model ke format lain

    • Langkah Fine-Tuning via Web UI

  • Pilih model dari dropdown (misalnya Qwen2.5-7B)
  • Pilih metode fine-tuning (LoRA/QLoRA/Full)
  • Upload atau pilih dataset
  • Atur hyperparameter (learning rate, epochs, batch size)
  • Klik "Start" untuk memulai training
  • Monitor progress melalui grafik loss secara real-time

    • Advanced Usage

    QLoRA: Fine-Tuning dengan Resource Terbatas

    QLoRA memungkinkan fine-tuning model besar pada GPU dengan VRAM terbatas melalui quantisasi 4-bit:

    # config/trainqlora.yaml

    modelnameorpath: meta-llama/Llama-3.1-8B-Instruct
    

    quantizationbit: 4
    

    quantizationmethod: bitsandbytes
    


    stage: sft
    

    dotrain: true
    

    finetuningtype: lora
    

    lorarank: 64
    

    loraalpha: 128
    

    loradropout: 0.1
    

    loratarget: all
    


    dataset: mycustomdataset
    

    template: llama3
    

    cutofflen: 4096
    


    outputdir: output/llama31-8b-qlora
    

    perdevicetrainbatchsize: 2
    

    gradientaccumulationsteps: 8
    

    learningrate: 2.0e-4
    

    numtrainepochs: 3.0
    

    lrschedulertype: cosine
    

    warmupratio: 0.1
    

    bf16: true

    Dengan QLoRA 4-bit, model 8B parameter bisa di-fine-tune pada GPU dengan 8GB VRAM saja.

    DPO (Direct Preference Optimization)

    DPO digunakan untuk alignment model berdasarkan preferensi manusia:

    [

      {
    

        "conversations": [
    

          {"from": "human", "value": "Bagaimana cara menulis email profesional?"}
    

        ],
    

        "chosen": {
    

          "from": "gpt",
    

          "value": "Berikut langkah menulis email profesional:\n1. Gunakan subjek yang jelas dan spesifik\n2. Sapa penerima dengan sopan\n3. Sampaikan tujuan di paragraf pertama\n4. Berikan detail yang diperlukan\n5. Tutup dengan ajakan bertindak yang jelas\n6. Gunakan salam penutup yang profesional"
    

        },
    

        "rejected": {
    

          "from": "gpt",
    

          "value": "ya tinggal tulis aja emailnya ga usah ribet"
    

        }
    

      }
    

    ]

    Konfigurasi training DPO:

    stage: dpo

    dotrain: true
    

    modelnameorpath: Qwen/Qwen2.5-7B-Instruct
    

    finetuningtype: lora
    

    lorarank: 16
    


    dataset: mypreferencedataset
    

    template: qwen
    


    outputdir: output/qwen25-dpo
    

    perdevicetrainbatchsize: 2
    

    gradientaccumulationsteps: 4
    

    learningrate: 5.0e-6
    

    numtrainepochs: 1.0
    

    dpobeta: 0.1

    Multi-GPU Training dengan DeepSpeed

    Untuk training pada multiple GPU, gunakan DeepSpeed:

    # config/traindeepspeed.yaml

    modelnameorpath: Qwen/Qwen2.5-72B
    

    finetuningtype: lora
    

    lorarank: 32
    

    deepspeed: examples/deepspeed/dsz3config.json
    


    dataset: mycustomdataset
    

    template: qwen
    

    cutofflen: 4096
    


    outputdir: output/qwen25-72b-lora
    

    perdevicetrainbatchsize: 1
    

    gradientaccumulationsteps: 16
    

    learningrate: 1.0e-4
    

    numtrainepochs: 2.0
    

    bf16: true

    Jalankan dengan:

    deepspeed --numgpus 4 src/train.py config/traindeepspeed.yaml

    Merge LoRA Adapter ke Base Model

    Setelah training selesai, merge adapter LoRA ke model dasar:

    llamafactory-cli export \

      --modelnameorpath Qwen/Qwen2.5-7B \
    

      --adapternameorpath output/qwen25-7b-lora \
    

      --template qwen \
    

      --finetuningtype lora \
    

      --exportdir output/qwen25-7b-merged \
    

      --exportsize 4 \
    

      --exportlegacyformat false

    Export ke GGUF (untuk llama.cpp)

    llamafactory-cli export \

      --modelnameorpath output/qwen25-7b-merged \
    

      --template qwen \
    

      --exportdir output/qwen25-7b-gguf \
    

      --exportquantizationbit 4 \
    

      --exportquantizationdataset identity

    Evaluasi Model

    Evaluasi model yang sudah di-fine-tune:

    llamafactory-cli eval \

      --modelnameorpath Qwen/Qwen2.5-7B \
    

      --adapternameorpath output/qwen25-7b-lora \
    

      --template qwen \
    

      --finetuningtype lora \
    

      --task mmlu \
    

      --lang en \
    

      --nshot 5 \
    

      --batchsize 4

    Inference dan Chat

    Test model secara interaktif:

    llamafactory-cli chat \

      --modelnameorpath Qwen/Qwen2.5-7B \
    

      --adapternameorpath output/qwen25-7b-lora \
    

      --template qwen \
    

      --finetuningtype lora

    Atau deploy sebagai API server yang kompatibel dengan OpenAI:

    llamafactory-cli api \

      --modelnameorpath Qwen/Qwen2.5-7B \
    

      --adapternameorpath output/qwen25-7b-lora \
    

      --template qwen \
    

      --finetuningtype lora \
    

      --host 0.0.0.0 \
    

      --port 8000

    Kemudian bisa diakses seperti API OpenAI:

    from openai import OpenAI


    client = OpenAI(
    

        baseurl="http://localhost:8000/v1",
    

        apikey="not-needed"
    

    )
    


    response = client.chat.completions.create(
    

        model="qwen25-7b-lora",
    

        messages=[
    

            {"role": "user", "content": "Jelaskan konsep transfer learning."}
    

        ],
    

        temperature=0.7,
    

        maxtokens=512
    

    )
    


    print(response.choices[0].message.content)

    Best Practices

    1. Pemilihan Metode Fine-Tuning

    | Metode | VRAM | Kualitas | Kecepatan | Kapan Digunakan |

    |--------|------|----------|-----------|-----------------|

    | Full | 40GB+ | Terbaik | Lambat | Dataset besar, perubahan signifikan |

    | LoRA | 16GB | Sangat Baik | Sedang | Sebagian besar use case |

    | QLoRA | 8GB | Baik | Sedang | Resource terbatas |

    | DoRA | 16GB | Sangat Baik | Sedang | Alternatif LoRA yang lebih stabil |

    2. Optimasi Hyperparameter

    • Learning Rate: Mulai dari 2e-5 untuk full fine-tuning, 1e-4 hingga 5e-4 untuk LoRA/QLoRA
    • LoRA Rank: 8 untuk tugas sederhana, 16-32 untuk tugas kompleks, 64+ untuk dataset besar
    • Batch Size: Gunakan gradient accumulation jika VRAM terbatas
    • Epochs: 1-3 epoch biasanya cukup, lebih dari 5 berisiko overfitting

    3. Kualitas Dataset

    • Pastikan data bersih dan konsisten
    • Minimal 500-1000 sampel untuk tugas spesifik
    • Gunakan format yang sesuai (instruction/conversation)
    • Validasi data sebelum training dimulai
    • Hindari duplikasi berlebihan

    4. Monitoring Training

    • Perhatikan training loss, pastikan menurun secara konsisten
    • Gunakan validation set untuk mendeteksi overfitting
    • Simpan checkpoint secara berkala
    • Gunakan TensorBoard atau Weights & Biases untuk visualisasi

    # Jalankan TensorBoard

    tensorboard --logdir output/qwen25-7b-lora/runs

    5. Tips Menghemat Resource

    • Gunakan gradientcheckpointing: true untuk menghemat VRAM
    • Aktifkan flashattn: fa2 jika GPU mendukung
    • Gunakan packing: true untuk memaksimalkan panjang sequence
    • Pertimbangkan unsloth backend untuk percepatan 2x

    # Konfigurasi hemat resource

    gradientcheckpointing: true
    

    flashattn: fa2
    

    packing: true
    

    useunsloth: true

    Troubleshooting

    Error: CUDA Out of Memory

    Solusi:

  • Kurangi perdevicetrainbatchsize
  • Aktifkan gradientcheckpointing: true
  • Gunakan QLoRA (4-bit quantization)
  • Kurangi cutofflen

    • Error: Template Tidak Ditemukan

    Pastikan menggunakan template yang sesuai dengan model:

    • LLaMA 3/3.1: llama3
    • Qwen2/2.5: qwen
    • Mistral/Mixtral: mistral
    • Phi-3/3.5: phi
    • Gemma 2: gemma
    • DeepSeek V2/V3: deepseek

    Training Loss Tidak Turun

    • Periksa kualitas dan format dataset
    • Coba learning rate yang lebih tinggi
    • Pastikan template sesuai dengan model
    • Verifikasi bahwa dataset terdaftar di dataset_info.json

    Kesimpulan

    LlamaFactory menyederhanakan proses fine-tuning LLM secara signifikan. Dengan dukungan lebih dari 100 model, berbagai metode training, dan antarmuka web yang intuitif, toolkit ini cocok untuk pemula maupun praktisi berpengalaman.

    Poin penting yang perlu diingat:

  • Pilih metode fine-tuning sesuai resource dan kebutuhan (QLoRA untuk resource terbatas, LoRA untuk keseimbangan terbaik)
  • Kualitas dataset lebih penting daripada kuantitas
  • Gunakan LLaMA Board untuk eksperimen cepat sebelum menjalankan training skala besar
  • Selalu evaluasi model setelah fine-tuning dan bandingkan dengan baseline
  • Manfaatkan fitur export untuk deployment ke berbagai platform

    • Dengan menguasai LlamaFactory, Anda dapat mengkustomisasi LLM untuk berbagai kebutuhan spesifik seperti chatbot domain tertentu, asisten coding, analisis dokumen, dan banyak lagi, tanpa harus menguasai detail teknis yang rumit.

    Artikel Terkait

    Tutorial Torchtune: Fine-Tuning LLM dengan PyTorch Native

    Tutorial Torchtune: Fine-Tuning LLM dengan PyTorch Native Pendahuluan Torchtune adalah library resmi dari PyTorch untuk ...

    Tutorial Unsloth: Fine-Tuning LLM yang Cepat dan Hemat Memori

    Fine-Tuning LLM Secara Efisien dengan Unsloth Dahulu, melakukan fine-tuning model bahasa besar membutuhkan server multi-...

    ZenML: Bikin Pipeline ML dan LLM yang Portable dan Siap Produksi

    ZenML: Bikin Pipeline ML dan LLM yang Portable dan Siap Produksi Halo temen-temen, ketemu lagi sama aku, Ruby Abdullah. ...

    Tutorial Lengkap Replicate: Menjalankan dan Deploy Model ML via API

    Tutorial Lengkap Replicate: Menjalankan dan Deploy Model ML via API Replicate adalah platform cloud yang memungkinkan An...