Post-Training LLM dengan TRL: SFT, Reward Modeling, dan DPO

Setelah sebuah base language model selesai dipretraining, model tersebut masih perlu dibentuk agar berguna dan selaras dengan ekspektasi manusia. TRL (Transformer Reinforcement Learning) adalah library dari Hugging Face untuk seluruh tahap post-training tersebut, mulai dari supervised fine-tuning sampai preference optimization. Tutorial ini membahas pipeline post-training modern dan menunjukkan cara memakai trainer-trainer TRL secara praktis, dengan Direct Preference Optimization (DPO) sebagai bagian utamanya.

Apa Itu TRL dan Posisinya

TRL adalah library yang berfokus pada langkah-langkah setelah pretraining. Tidak seperti wrapper yang sebagian besar hanya menyederhanakan konfigurasi, TRL menyediakan kelas-kelas trainer konkret untuk seluruh stack alignment: supervised fine-tuning, reward modeling, serta beberapa algoritma preference-optimization dan reinforcement learning.

TRL dibangun langsung di atas ekosistem Hugging Face:

• Transformers untuk memuat model dan tokenizer.
• PEFT untuk adapter yang hemat parameter seperti LoRA, sehingga model besar bisa dilatih di perangkat keras yang sederhana.
• Accelerate untuk pelatihan terdistribusi dan mixed-precision.
• Datasets untuk memuat dan memproses data.

Karena TRL memakai ulang komponen-komponen ini, semua hal yang sudah Anda ketahui tentang AutoModelForCausalLM, tokenizer, atau konfigurasi LoRA berlaku langsung di sini.

Pipeline Post-Training LLM Modern

Model instruction-following atau chat pada umumnya melewati tiga tahap:

TRL mencakup tahap 2 dan 3. Sebagian besar pekerjaan alignment di produksi saat ini menggabungkan satu putaran SFT yang diikuti satu putaran preference-optimization.

Instalasi

# Stack inti
pip install trl peft datasets accelerate

Ekstra yang direkomendasikan
pip install transformers bitsandbytes
pip install wandb  # pelacakan eksperimen opsional

Verifikasi instalasi dan pastikan GPU terlihat:

import torch
import trl

print("Versi TRL:", trl.version)
print("CUDA tersedia:", torch.cuda.isavailable())

example = {
    "messages": [
        {"role": "system", "content": "Anda adalah asisten yang membantu."},
        {"role": "user", "content": "Jelaskan apa itu vector database."},
        {"role": "assistant", "content": "Vector database menyimpan embedding..."},
    ]
}

example = {
    "prompt": "Jelaskan apa itu vector database.",
    "chosen": "Vector database menyimpan embedding dan mendukung similarity search...",
    "rejected": "Itu cuma database biasa.",
}

from datasets import loaddataset

raw = loaddataset("json", datafiles="mypreferences.jsonl", split="train")


def topreference(example):
    return {
        "prompt": example["question"],
        "chosen": example["goodanswer"],

        "rejected": example["badanswer"],
    }

dataset = raw.map(topreference, removecolumns=raw.columnnames)


Sisihkan split terpisah untuk evaluasi yang jujur.
splits = dataset.traintestsplit(testsize=0.05, seed=42)
traindataset, evaldataset = splits["train"], splits["test"]

Beberapa kebiasaan yang bermanfaat:

• Selalu sisihkan split terpisah. Metrik preference pada training set itu menyesatkan; Anda menginginkan angka eval yang belum pernah dilihat model.
• Periksa beberapa baris secara manual. Cetak lima contoh lalu baca. Label yang berisik jauh lebih mudah ditangkap dengan mata daripada lewat statistik agregat.
• Tetapkan seed. Split yang reproducible membuat eksperimen bisa dibandingkan antar-run.

Supervised Fine-Tuning dengan SFTTrainer

SFT adalah fondasinya: tahap ini mengajarkan base model gaya respons dan perilaku mengikuti instruksi yang Anda inginkan sebelum preference tuning apa pun. Di TRL ini adalah SFTTrainer yang dikonfigurasi dengan SFTConfig.

from datasets import loaddataset
from trl import SFTConfig, SFTTrainer

dataset = loaddataset("trl-lib/Capybara", split="train")

config = SFTConfig(
    outputdir="sft-model",

    numtrainepochs=1,

    perdevicetrainbatchsize=2,

    gradientaccumulationsteps=8,

    learningrate=2e-5,
    loggingsteps=10,

    packing=True,            # gabungkan sampel pendek agar context window efisien
    maxlength=1024,
    bf16=True,
)

trainer = SFTTrainer(
    model="Qwen/Qwen2.5-0.5B",
    args=config,
    traindataset=dataset,

)

trainer.train()
trainer.savemodel("sft-model")

Beberapa hal yang perlu diperhatikan:

• Chat template. Ketika dataset memiliki kolom messages, SFTTrainer menerapkan chat template dari tokenizer, sehingga token khusus dan penanda peran ditambahkan dengan benar.
• Packing. Menyetel packing=True menggabungkan beberapa contoh pendek menjadi satu sekuens hingga maxlength. Ini meningkatkan throughput dan mengurangi padding yang terbuang, dengan konsekuensi sedikit mencampur contoh di dalam satu sekuens.
• Memberikan nama model. Anda bisa memberikan string ID model lalu TRL memuatnya untuk Anda, atau memberikan instance AutoModelForCausalLM yang sudah dimuat.

Untuk model yang lebih besar, biasanya Anda tidak ingin full fine-tuning. TRL menerima peftconfig, dan trainer membungkus model dengan PEFT secara internal. LoRA dan PEFT dibahas mendalam di tutorial terpisah, jadi bagian ini sengaja dibuat singkat.

from peft import LoraConfig
from trl import SFTConfig, SFTTrainer

peftconfig = LoraConfig(

    r=16,
    loraalpha=32,
    loradropout=0.05,

    targetmodules="all-linear",
    tasktype="CAUSALLM",
)

trainer = SFTTrainer(
    model="Qwen/Qwen2.5-0.5B",
    args=SFTConfig(outputdir="sft-lora", bf16=True),

    traindataset=dataset,
    peftconfig=peftconfig,
)

trainer.train()

Argumen peftconfig yang sama berlaku untuk trainer TRL lainnya, termasuk DPOTrainer.

from datasets import loaddataset
from transformers import AutoModelForSequenceClassification, AutoTokenizer
from trl import RewardConfig, RewardTrainer

modelid = "Qwen/Qwen2.5-0.5B"

tokenizer = AutoTokenizer.frompretrained(modelid)

model = AutoModelForSequenceClassification.frompretrained(modelid, numlabels=1)

dataset = loaddataset("trl-lib/ultrafeedbackbinarized", split="train")

config = RewardConfig(
    outputdir="reward-model",

    perdevicetrainbatchsize=4,

    numtrainepochs=1,

    learningrate=1e-5,
    loggingsteps=10,

    maxlength=1024,
    bf16=True,
)

trainer = RewardTrainer(
    model=model,
    args=config,
    traindataset=dataset,

    processingclass=tokenizer,
)

trainer.train()

Reward model dimuat sebagai head sequence-classification dengan satu output (numlabels=1). Trainer mengoptimalkan loss berpasangan sehingga skor untuk chosen melebihi skor untuk rejected. Reward model inilah yang nantinya dipakai oleh PPOTrainer untuk memberikan sinyal pelatihan.

from datasets import loaddataset

dataset = loaddataset("trl-lib/ultrafeedbackbinarized", split="train")
print(dataset[0].keys())  # dictkeys(['prompt', 'chosen', 'rejected', ...])

from datasets import loaddataset
from transformers import AutoModelForCausalLM, AutoTokenizer
from trl import DPOConfig, DPOTrainer

modelid = "Qwen/Qwen2.5-0.5B-Instruct"


model = AutoModelForCausalLM.frompretrained(modelid)

tokenizer = AutoTokenizer.frompretrained(modelid)


traindataset = loaddataset(

    "trl-lib/ultrafeedbackbinarized", split="train"
).select(range(2000))  # potongan kecil untuk percobaan cepat

config = DPOConfig(
    outputdir="dpo-model",

    perdevicetrainbatchsize=2,

    gradientaccumulationsteps=8,

    numtrainepochs=1,

    learningrate=5e-6,
    beta=0.1,                 # kekuatan KL: seberapa dekat tetap ke reference
    losstype="sigmoid",      # loss DPO standar

    loggingsteps=10,
    maxlength=1024,

    maxpromptlength=512,

    bf16=True,
)

trainer = DPOTrainer(
    model=model,
    refmodel=None,           # TRL membuat salinan beku dari model sebagai reference
    args=config,
    traindataset=traindataset,
    processingclass=tokenizer,

)

trainer.train()
trainer.savemodel("dpo-model")

Pengaturan DPOConfig yang penting:

• beta mengontrol seberapa kuat policy ditahan pada reference model. Nilai lebih rendah (sekitar 0,05) memungkinkan perubahan lebih besar; nilai lebih tinggi (0,3+) membuat model konservatif. Nilai sekitar 0,1 adalah titik awal yang umum.
• losstype memilih loss preference. "sigmoid" adalah DPO standar; alternatif seperti "ipo" dan "hinge" mengubah cara objektif memperlakukan margin preference dan dapat mengurangi overfitting pada beberapa dataset.
• refmodel=None memberitahu TRL untuk membuat salinan beku dari policy sebagai reference. Jika Anda melatih dengan LoRA, TRL bisa memakai base model dengan adapter dinonaktifkan sebagai reference, sehingga tidak perlu salinan model kedua di memori.

Untuk menjalankan DPO dengan LoRA alih-alih full fine-tuning, berikan peftconfig persis seperti pada contoh SFT. Ini adalah setup umum untuk model yang lebih besar.

from datasets import loaddataset
from trl import GRPOConfig, GRPOTrainer

dataset = loaddataset("trl-lib/tldr", split="train")


Reward function menerima completion yang dihasilkan dan mengembalikan skor per item.
def lengthreward(completions, kwargs):

    # Contoh sederhana: lebih suka jawaban ringkas di bawah 200 karakter.
    return [1.0 if len(c) < 200 else 0.0 for c in completions]

trainer = GRPOTrainer(
    model="Qwen/Qwen2.5-0.5B-Instruct",
    rewardfuncs=lengthreward,
    args=GRPOConfig(outputdir="grpo-model", bf16=True, loggingsteps=10),
    traindataset=dataset,

)

trainer.train()

def correctnessreward(completions, groundtruth, kwargs):
    scores = []
    for completion, answer in zip(completions, groundtruth):
        scores.append(1.0 if answer.strip() in completion else 0.0)
    return scores

Kolom dataset tambahan (seperti groundtruth) diteruskan ke reward function sebagai keyword argument, sehingga Anda bisa mengimplementasikan objektif apa pun yang bisa diperiksa.

config = DPOConfig(
    outputdir="dpo-model",
    evalstrategy="steps",

    evalsteps=100,
    loggingsteps=10,

    reportto="wandb",       # atau "tensorboard"
    pushtohub=True,
    hubmodelid="username-anda/dpo-model",
)

Dengan split evaluasi yang diberikan sebagai evaldataset, DPO mencatat metrik berguna seperti reward accuracy (seberapa sering chosen mendapat skor di atas rejected) dan reward margin. Setelah pelatihan, Anda bisa mendorong model:

trainer.pushtohub()

accelerate config              # setup interaktif sekali saja
accelerate launch traindpo.py

Untuk model besar yang tidak muat dalam satu GPU, DeepSpeed ZeRO membagi state optimizer, gradien, dan parameter ke beberapa perangkat:

accelerate launch --configfile deepspeedzero3.yaml traindpo.py

• Post-training memiliki tiga tahap: pretrain, SFT, lalu preference optimization. TRL mencakup dua tahap terakhir.
• SFTTrainer menangani supervised fine-tuning, menerapkan chat template, mendukung packing, dan berpadu rapi dengan LoRA melalui peftconfig.
• RewardTrainer melatih reward model skalar pada pasangan chosen/rejected untuk RLHF klasik.
• DPOTrainer adalah default praktis untuk alignment preference: ia mengoptimalkan langsung pada pasangan preference, menghindari reward model terpisah dan loop RL, serta di-tuning terutama lewat beta dan loss_type.
• PPOTrainer, GRPOTrainer, ORPO, dan KTO mencakup sisa spektrumnya, dari RLHF penuh sampai RL dengan reward terverifikasi hingga metode feedback biner.
• Keberhasilan lebih bergantung pada melakukan SFT lebih dahulu, mengurasi data preference yang bersih, men-tuning beta, dan menjaga dari overfitting ketimbang pada algoritmanya sendiri.

Mulailah dengan satu putaran SFT, lanjutkan ke DPO pada dataset preference yang bersih, evaluasi secara jujur, dan baru beralih ke PPO atau GRPO ketika tugas Anda benar-benar membutuhkan reinforcement learning online.