Pelatih DPO

Ikhtisar

TRL mendukung Direct Preference Optimization (DPO) Trainer untuk melatih model bahasa, seperti yang dijelaskan dalam makalah Direct Preference Optimization: Your Language Model is Secretly a Reward Model oleh Rafael Rafailov, Archit Sharma, Eric Mitchell, Stefano Ermon, Christopher D. Manning, Chelsea Finn.

Abstrak dari makalah tersebut adalah sebagai berikut:

Meskipun model bahasa (LM) berskala besar yang dilatih secara tidak berlabel (unsupervised) mempelajari pengetahuan dunia yang luas dan beberapa keterampilan penalaran, mencapai kontrol yang presisi atas perilaku mereka sulit karena sifat pelatihan mereka yang sepenuhnya tidak berlabel. Metode-metode yang ada untuk mendapatkan kemampuan pengendalian (steerability) semacam itu mengumpulkan label manusia mengenai kualitas relatif dari generasi model dan melakukan penyesuaian halus (fine-tuning) pada LM tidak berlabel tersebut agar selaras dengan preferensi ini, sering kali menggunakan pembelajaran penguatan dari umpan balik manusia (RLHF). Namun, RLHF adalah prosedur yang kompleks dan sering kali tidak stabil, yang pertama-tama menyesuaikan model reward yang mencerminkan preferensi manusia, dan kemudian melakukan penyesuaian halus pada LM tidak berlabel yang besar menggunakan pembelajaran penguatan untuk memaksimalkan reward yang diperkirakan ini tanpa menyimpang terlalu jauh dari model asli. Dalam makalah ini, kami memperkenalkan parameterisasi baru dari model reward dalam RLHF yang memungkinkan ekstraksi kebijakan optimal yang sesuai dalam bentuk tertutup (closed form), sehingga memungkinkan kami menyelesaikan masalah RLHF standar hanya dengan fungsi kerugian klasifikasi sederhana. Algoritma yang dihasilkan, yang kami sebut Optimasi Preferensi Langsung (Direct Preference Optimization / DPO), stabil, berkinerja baik, dan ringan secara komputasi, menghilangkan kebutuhan untuk pengambilan sampel (sampling) dari LM selama penyesuaian halus atau melakukan penyetelan hiperparameter yang signifikan. Eksperimen kami menunjukkan bahwa DPO dapat melakukan penyesuaian halus pada LM agar selaras dengan preferensi manusia dengan hasil yang sama baiknya atau lebih baik daripada metode yang ada. Secara khusus, penyesuaian halus dengan DPO melampaui RLHF berbasis PPO dalam kemampuan untuk mengendalikan sentimen dari generasi, dan menyamai atau meningkatkan kualitas respons dalam ringkasan dan dialog satu giliran (single-turn dialogue) sambil jauh lebih sederhana untuk diimplementasikan dan dilatih.

Metode pasca-pelatihan ini disumbangkan oleh Kashif Rasul dan kemudian di-refactor oleh Quentin Gallouédec.

Mulai cepat

Contoh ini menunjukkan cara melatih model bahasa menggunakan DPOTrainer dari TRL. Kami melatih model Qwen 3 0.6B pada dataset UltraFeedback.

from trl import DPOTrainer
from datasets import load_dataset

trainer = DPOTrainer(
    model="Qwen/Qwen3-0.6B",
    train_dataset=load_dataset("trl-lib/ultrafeedback_binarized", split="train"),
)
trainer.train()

Jenis dan format dataset yang diharapkan

DPO memerlukan dataset preferensi. DPOTrainer kompatibel dengan format dataset standar dan percakapan. Ketika diberikan dataset percakapan, trainer akan secara otomatis menerapkan template chat ke dataset tersebut.

# Standard format
## Explicit prompt (recommended)
preference_example = {"prompt": "The sky is", "chosen": " blue.", "rejected": " green."}
# Implicit prompt
preference_example = {"chosen": "The sky is blue.", "rejected": "The sky is green."}

# Conversational format
## Explicit prompt (recommended)
preference_example = {"prompt": [{"role": "user", "content": "What color is the sky?"}],
                      "chosen": [{"role": "assistant", "content": "It is blue."}],
                      "rejected": [{"role": "assistant", "content": "It is green."}]}
## Implicit prompt
preference_example = {"chosen": [{"role": "user", "content": "What color is the sky?"},
                                 {"role": "assistant", "content": "It is blue."}],
                      "rejected": [{"role": "user", "content": "What color is the sky?"},
                                   {"role": "assistant", "content": "It is green."}]}

Jika dataset Anda tidak dalam salah satu format ini, Anda dapat melakukan pra-pemrosesan untuk mengonversinya ke format yang diharapkan. Berikut adalah contoh dengan dataset Vezora/Code-Preference-Pairs:

from datasets import load_dataset

dataset = load_dataset("Vezora/Code-Preference-Pairs")


def preprocess_function(example):
    return {
        "prompt": [{"role": "user", "content": example["input"]}],
        "chosen": [{"role": "assistant", "content": example["accepted"]}],
        "rejected": [{"role": "assistant", "content": example["rejected"]}],
    }


dataset = dataset.map(preprocess_function, remove_columns=["instruction", "input", "accepted", "ID"])
print(next(iter(dataset["train"])))

{
    "prompt": [{"role": "user", "content": "Create a nested loop to print every combination of numbers [...]"}],
    "chosen": [{"role": "assistant", "content": "Here is an example of a nested loop in Python [...]"}],
    "rejected": [{"role": "assistant", "content": "Here is an example of a nested loop in Python [...]"}],
}

Menggali lebih dalam ke metode DPO

Direct Preference Optimization (DPO) adalah metode pelatihan yang dirancang untuk menyelaraskan model bahasa dengan data preferensi. Alih-alih pasangan input–output yang diawasi, model dilatih pada pasangan penyelesaian untuk prompt yang sama, di mana satu penyelesaian lebih disukai daripada yang lain. Tujuannya secara langsung mengoptimalkan model untuk memperlebar jarak antara log-likelihood penyelesaian yang disukai dan tidak disukai, relatif terhadap model referensi, tanpa memerlukan model reward yang eksplisit. Dalam praktiknya, hal ini biasanya dicapai dengan menekan likelihood penyelesaian yang tidak disukai, bukan dengan meningkatkan likelihood penyelesaian yang disukai.

Bagian ini menguraikan cara kerja DPO dalam praktik, mencakup langkah-langkah utama: pra-pemrosesan dan perhitungan loss.

Pra-pemrosesan dan tokenisasi

Selama pelatihan, setiap contoh diharapkan berisi prompt beserta penyelesaian yang lebih disukai (chosen) dan penyelesaian yang tidak disukai (rejected). Untuk detail lebih lanjut mengenai format yang diharapkan, lihat Dataset formats. DPOTrainer melakukan tokenisasi setiap input menggunakan tokenizer model.

Menghitung loss

dpo_figure

Loss yang digunakan dalam DPO didefinisikan sebagai berikut: $\mathcal{L}_{\mathrm{DPO}}(\theta) = -\mathbb{E}_{(x,y^{+},y^{-})}\!\left[\log \sigma\!\left(\beta\Big(\log\frac{\pi_{\theta}(y^{+}\!\mid x)}{\pi_{\mathrm{ref}}(y^{+}\!\mid x)}-\log \frac{\pi_{\theta}(y^{-}\!\mid x)}{\pi_{\mathrm{ref}}(y^{-}\!\mid x)}\Big)\right)\right]$

di mana $x$ adalah prompt, $y^+$ adalah penyelesaian yang lebih disukai dan $y^-$ adalah penyelesaian yang kurang disukai. $\pi_{\theta}$ adalah model kebijakan yang sedang dilatih, $\pi_{\mathrm{ref}}$ adalah model referensi, $\sigma$ adalah fungsi sigmoid, dan $\beta > 0$ adalah hiperparameter yang mengontrol kekuatan sinyal preferensi.

Jenis-jenis Loss

Beberapa formulasi dari fungsi tujuan telah diusulkan dalam literatur. Pada awalnya, fungsi tujuan DPO didefinisikan seperti yang disajikan di atas.

`loss_type=`	Deskripsi
`"sigmoid"` (default)	Dengan data preferensi, kita dapat menyesuaikan klasifikator biner sesuai model Bradley-Terry dan memang para penulis DPO mengusulkan kerugian sigmoid pada kemungkinan yang dinormalisasi melalui `logsigmoid` untuk menyesuaikan regresi logistik.
`"hinge"`	Para penulis RSO mengusulkan untuk menggunakan hinge loss pada likelihood ternormalisasi dari makalah SLiC. Dalam kasus ini, `beta` adalah kebalikan dari margin.
`"ipo"`	Para penulis IPO berargumen bahwa transformasi logit dapat menyebabkan overfitting dan mengusulkan transformasi identitas untuk mengoptimalkan preferensi secara langsung; TRL mengekspos ini sebagai `loss_type="ipo"`.
`"exo_pair"`	Para penulis EXO mengusulkan optimasi preferensi reverse-KL. `label_smoothing` harus lebih besar dari `0.0`; nilai yang direkomendasikan adalah `1e-3` (lihat Persamaan 16 untuk varian pairwise yang disederhanakan). Metode lengkap menggunakan `K>2` penyelesaian SFT dan mendekati PPO seiring bertambahnya `K`.
`"nca_pair"`	Para penulis NCA menunjukkan bahwa NCA mengoptimalkan kemungkinan absolut untuk setiap respons, bukan kemungkinan relatif.
`"robust"`	Para penulis Robust DPO mengusulkan kerugian DPO yang tidak bias di bawah preferensi berisik. Gunakan `label_smoothing` di DPOConfig untuk memodelkan probabilitas pembalikan label; nilai yang valid berada dalam rentang `[0.0, 0.5)`.
`"bco_pair"`	Para penulis BCO melatih klasifikasi biner yang logit-nya berfungsi sebagai reward sehingga klasifikator memetakan pasangan {prompt, chosen completion} ke 1 dan pasangan {prompt, rejected completion} ke 0.
`"sppo_hard"`	Para penulis SPPO mengklaim bahwa SPPO mampu menyelesaikan ekuilibrium Nash secara iteratif dengan mendorong reward yang dipilih menjadi sebesar 1/2 dan reward yang ditolak menjadi sekecil -1/2, serta dapat meredakan masalah kelangkaan data. Implementasi ini mengaproksimasi algoritma tersebut dengan menggunakan probabilitas label keras, yaitu memberikan nilai 1 kepada pemenang dan 0 kepada pecundang.
`"aot"` atau `loss_type="aot_unpaired"`	Para penulis AOT mengusulkan Distributional Preference Alignment via Optimal Transport. `loss_type="aot"` digunakan untuk data berpasangan; `loss_type="aot_unpaired"` digunakan untuk data tidak berpasangan. Keduanya menerapkan stochastic dominance melalui quantile yang diurutkan; ukuran batch per-GPU yang lebih besar membantu.
`"apo_zero"` atau `loss_type="apo_down"`	Metode APO memperkenalkan tujuan yang berjangkar. `apo_zero` meningkatkan bobot pemenang dan menurunkan bobot pecundang (berguna ketika model berkinerja di bawah pemenang). `apo_down` menurunkan bobot keduanya, dengan tekanan yang lebih kuat pada pecundang (berguna ketika model sudah berkinerja di atas pemenang).
`"discopop"`	Paper DiscoPOP menggunakan LLM untuk menemukan kerugian optimasi preferensi offline yang lebih efisien. Dalam paper tersebut, kerugian DiscoPOP yang diusulkan (yang merupakan kerugian yang dimodulasi rasio log) melampaui kerugian optimasi lainnya pada berbagai tugas (generasi teks positif IMDb, ringkasan TLDR Reddit, dan Alpaca Eval 2.0).
`"sft"`	Loss SFT (Supervised Fine-Tuning) adalah loss negative log likelihood, yang digunakan untuk melatih model agar menghasilkan respons yang diinginkan.
`"sigmoid_norm"`	Para penulis SimPO mengatasi bias panjang pada loss sigmoid asli dengan menormalisasi berdasarkan jumlah token non-mask; TRL mengekspos ini sebagai `loss_type="sigmoid_norm"`.
`"udpo"`	Para penulis UDPO mengusulkan kerugian DPO tanpa bias di bawah preferensi berisik yang, tidak seperti `"robust"`, tetap tanpa bias ketika probabilitas flip diperkirakan berlebihan. Gunakan `label_smoothing` di DPOConfig untuk mengatur probabilitas flip ε; nilai yang valid berada dalam rentang `[0.0, 0.5)`.

Metrik yang dicatat

Selama pelatihan dan evaluasi, kami mencatat metrik berikut:

global_step: Total jumlah langkah optimizer yang telah dilakukan sejauh ini.
epoch: Nomor epoch saat ini, berdasarkan iterasi dataset.
num_tokens: Total jumlah token yang diproses sejauh ini.
loss: Rata-rata kerugian DPO selama interval pencatatan saat ini.
entropy: Entropi rata-rata dari distribusi token yang diprediksi model pada token yang tidak dimasker.
aux_loss: kerugian bantu penyeimbangan beban dari model Mixture-of-Experts, sebelum dikalikan dengan router_aux_loss_coef dan ditambahkan ke kerugian. Dicatat hanya ketika model adalah model MoE dan router_aux_loss_coef tidak nol.
mean_token_accuracy: Proporsi token yang tidak dimasker di mana prediksi top-1 model cocok dengan token dari penyelesaian yang dipilih.
learning_rate: Laju pembelajaran saat ini, yang dapat berubah secara dinamis jika penjadwal digunakan.
grad_norm: Norm L2 dari gradien, dihitung sebelum pemotongan gradien.
logits/chosen: Nilai logit rata-rata yang diberikan model kepada token dalam penyelesaian yang dipilih.
logits/rejected: Nilai logit rata-rata yang diberikan model untuk token dalam penyelesaian yang ditolak.
logps/chosen: Rata-rata log-probabilitas yang diberikan model pada token-token dalam penyelesaian yang dipilih.
logps/rejected: Rata-rata log-probabilitas yang diberikan model pada token dalam penyelesaian yang ditolak.
rewards/chosen: Rata-rata reward implisit yang dihitung untuk penyelesaian yang dipilih, dihitung sebagai $\beta \log \frac{\pi_{\theta}(y^{+}\!\mid x)}{\pi_{\mathrm{ref}}(y^{+}\!\mid x)}$ .
rewards/rejected: Rata-rata reward implisit yang dihitung untuk penyelesaian yang ditolak, dihitung sebagai $\beta \log \frac{\pi_{\theta}(y^{-}\!\mid x)}{\pi_{\mathrm{ref}}(y^{-}\!\mid x)}$ .
rewards/margins: Margin reward implisit rata-rata antara penyelesaian yang dipilih dan yang ditolak.
rewards/accuracies: Proporsi contoh di mana reward implisit untuk penyelesaian yang dipilih lebih tinggi daripada penyelesaian yang ditolak.

Kustomisasi

Kompatibilitas dan batasan

Beberapa kombinasi argumen sengaja dibatasi dalam implementasi DPOTrainer saat ini:

use_weighting=True tidak didukung dengan loss_type="aot" atau loss_type="aot_unpaired".
Adaptor PEFT yang menargetkan lm_head tidak didukung (gunakan modules_to_save=["lm_head"] sebagai gantinya).
sync_ref_model=True tidak didukung saat melatih dengan model PEFT yang tidak mempertahankan ref_model yang berdiri sendiri.
sync_ref_model=True tidak dapat digabungkan dengan precompute_ref_log_probs=True.
precompute_ref_log_probs=True tidak didukung dengan IterableDataset (train atau eval).

Kombinasi multi-loss

Pelatih DPO mendukung penggabungan beberapa fungsi kerugian dengan bobot yang berbeda, memungkinkan strategi optimasi yang lebih canggih. Hal ini sangat berguna untuk mengimplementasikan algoritma seperti MPO (Mixed Preference Optimization). MPO adalah pendekatan pelatihan yang menggabungkan beberapa tujuan optimasi, seperti yang dijelaskan dalam makalah Enhancing the Reasoning Ability of Multimodal Large Language Models via Mixed Preference Optimization.

Untuk menggabungkan beberapa loss, tentukan tipe loss dan bobot yang sesuai sebagai daftar:

# MPO: Combines DPO (sigmoid) for preference and BCO (bco_pair) for quality
training_args = DPOConfig(
    loss_type=["sigmoid", "bco_pair", "sft"],  # loss types to combine
    loss_weights=[0.8, 0.2, 1.0]  # corresponding weights, as used in the MPO paper
)

Inisialisasi model

Anda dapat langsung meneruskan kwargs dari metode from_pretrained() ke DPOConfig. Misalnya, jika Anda ingin memuat model dalam presisi yang berbeda, serupa dengan

model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen3-0.6B", dtype=torch.bfloat16)

Anda dapat melakukannya dengan meneruskan argumen model_init_kwargs={"dtype": torch.bfloat16} ke DPOConfig.

from trl import DPOConfig

training_args = DPOConfig(
    model_init_kwargs={"dtype": torch.bfloat16},
)

Perhatikan bahwa semua argumen kata kunci dari from_pretrained() didukung.

Latih adapter dengan PEFT

Kami mendukung integrasi yang erat dengan pustaka 🤗 PEFT, memungkinkan setiap pengguna untuk dengan mudah melatih adapter dan membagikannya di Hub, alih-alih melatih seluruh model.

from datasets import load_dataset
from trl import DPOTrainer
from peft import LoraConfig

dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")

trainer = DPOTrainer(
    "Qwen/Qwen3-0.6B",
    train_dataset=dataset,
    peft_config=LoraConfig(),
)

trainer.train()

Anda juga dapat melanjutkan pelatihan PeftModel Anda. Untuk itu, pertama muat PeftModel di luar DPOTrainer dan teruskan secara langsung ke trainer tanpa mengargumentasikan peft_config.

from datasets import load_dataset
from trl import DPOTrainer
from peft import AutoPeftModelForCausalLM

model = AutoPeftModelForCausalLM.from_pretrained("trl-lib/Qwen3-4B-LoRA", is_trainable=True)
dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")

trainer = DPOTrainer(
    model=model,
    train_dataset=dataset,
)

trainer.train()

Saat melatih adapter, Anda biasanya menggunakan tingkat pembelajaran yang lebih tinggi (≈1e‑5) daripada fine-tuning penuh karena hanya parameter baru yang dipelajari.
DPOConfig(learning_rate=1e-5, ...)

Eksperimen Cepat untuk DPO

RapidFire AI adalah mesin eksperimen open-source yang berada di atas TRL dan memungkinkan Anda meluncurkan beberapa konfigurasi DPO sekaligus, bahkan pada satu GPU. Alih-alih mencoba konfigurasi secara berurutan, RapidFire memungkinkan Anda melihat semua kurva pembelajaran mereka lebih awal, menghentikan run yang kinerjanya rendah, dan mengkloning yang menjanjikan dengan pengaturan baru saat berjalan tanpa perlu memulai ulang. Untuk informasi lebih lanjut, lihat RapidFire AI Integration.

Latih dengan Unsloth

Unsloth adalah kerangka kerja sumber terbuka untuk penyesuaian halus (fine-tuning) dan pembelajaran penguatan yang melatih LLM (seperti Llama, Mistral, Gemma, DeepSeek, dan lainnya) hingga 2× lebih cepat dengan pengurangan VRAM hingga 70%, sambil menyediakan alur kerja yang ringkas dan kompatibel dengan Hugging Face untuk pelatihan, evaluasi, dan penerbitan. Untuk informasi lebih lanjut, lihat Integrasi Unsloth.

Pemanggilan Alat dengan DPO

DPOTrainer sepenuhnya mendukung fine-tuning model dengan kemampuan tool calling. Dalam hal ini, setiap contoh dataset harus mencakup:

Pesan percakapan (prompt, chosen, dan rejected), termasuk panggilan alat (tool_calls) dan respons alat (pesan dengan peran tool)
Daftar alat yang tersedia di kolom tools, biasanya disediakan sebagai skema JSON

Untuk detail mengenai struktur dataset yang diharapkan, lihat bagian Dataset Format — Tool Calling.

Pelatihan Model Bahasa Visual

DPOTrainer sepenuhnya mendukung pelatihan Vision-Language Models (VLM). Untuk melatih VLM, berikan dataset dengan kolom image (satu gambar per sampel) atau kolom images (daftar gambar per sampel). Untuk informasi lebih lanjut tentang struktur dataset yang diharapkan, lihat bagian Dataset Format — Vision Dataset. Contoh dataset seperti itu adalah dataset RLAIF-V Dataset.

from trl import DPOConfig, DPOTrainer
from datasets import load_dataset

trainer = DPOTrainer(
    model="Qwen/Qwen2.5-VL-3B-Instruct",
    args=DPOConfig(max_length=None),
    train_dataset=load_dataset("HuggingFaceH4/rlaif-v_formatted", split="train"),
)
trainer.train()

Untuk VLM, pemotongan dapat menghapus token gambar, yang menyebabkan kesalahan selama pelatihan. Untuk menghindari hal ini, atur max_length=None di DPOConfig. Ini memungkinkan model untuk memproses panjang urutan penuh tanpa memotong token gambar.
DPOConfig(max_length=None, ...)
Gunakan max_length hanya jika Anda telah memverifikasi bahwa pemotongan (truncation) tidak akan menghapus token gambar untuk seluruh dataset.

DPOTrainer

kelas trl.DPOTrainer

< source >

( model: str | PreTrainedModel | PeftModelref_model: transformers.modeling_utils.PreTrainedModel | None = Noneargs: trl.trainer.dpo_config.DPOConfig | None = Nonedata_collator: collections.abc.Callable[[list[typing.Any]], dict[str, typing.Any]] | None = Nonetrain_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | None = Noneeval_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | datasets.dataset_dict.DatasetDict | datasets.dataset_dict.IterableDatasetDict | dict[str, datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset] | None = Noneprocessing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | transformers.processing_utils.ProcessorMixin | None = Nonecompute_metrics: collections.abc.Callable[[transformers.trainer_utils.EvalPrediction], dict] | None = Nonecallbacks: list[transformers.trainer_callback.TrainerCallback] | None = Noneoptimizers: tuple[typing.Optional[torch.optim.Optimizer], typing.Optional[torch.optim.lr_scheduler.LambdaLR]] = (None, None)quantization_config: BitsAndBytesConfig | None = Nonepeft_config: PeftConfig | None = None )

Parameter

model (str atau PreTrainedModel atau PeftModel) — Model yang akan dilatih. Bisa berupa:
- String, berupa model id dari model pretrained yang dihosting di dalam model repo di huggingface.co, atau path ke directory yang berisi model weights yang disimpan menggunakan save_pretrained, misalnya './my_model_directory/'. Model dimuat menggunakan <ModelArchitecture>.from_pretrained (di mana <ModelArchitecture> diturunkan dari model config) dengan keyword arguments di args.model_init_kwargs. Jika dtype tidak ditentukan di args.model_init_kwargs, default-nya adalah float32. Ini berbeda dari from_pretrained, di mana (sejak Transformers v5) dtype disimpulkan dari model config.
- Objek PreTrainedModel. Hanya model bahasa kausal yang didukung.
- Objek PeftModel. Hanya model bahasa kausal yang didukung.
ref_model (PreTrainedModel, opsional) — Model referensi yang digunakan untuk menghitung log probabilitas referensi. Jika disediakan, model ini digunakan langsung sebagai kebijakan referensi. Model ini tidak boleh berupa PeftModel. Jika None, trainer akan secara otomatis menggunakan kebijakan awal yang sesuai dengan model, yaitu state model sebelum pelatihan DPO dimulai.
- Jika diberikan, model ini digunakan langsung sebagai kebijakan referensi. Model ini tidak boleh berupa PeftModel.
- Jika None, trainer akan secara otomatis menggunakan kebijakan awal yang sesuai dengan model, yaitu state model sebelum pelatihan DPO dimulai.
args (DPOConfig, opsional) — Konfigurasi untuk trainer ini. Jika None, konfigurasi default akan digunakan.
data_collator (DataCollator, opsional) — Fungsi yang digunakan untuk membentuk batch dari daftar elemen train_dataset atau eval_dataset yang telah diproses. Nilai defaultnya adalah DataCollatorForPreference jika modelnya adalah language model dan DataCollatorForVisionPreference jika modelnya adalah vision-language model. Collator kustom harus memotong (truncate) urutan sebelum padding; trainer tidak menerapkan pemotongan (truncation) setelah kolasi.
train_dataset (Dataset atau IterableDataset) — Dataset yang digunakan untuk pelatihan. Trainer ini mendukung tipe language modeling dan tipe prompt-completion . Format sampel dapat berupa:
- Standar: Setiap sampel berisi teks polos.
- Konversasional: Setiap sampel berisi pesan terstruktur (misalnya, peran dan konten).
Ketika train_dataset adalah IterableDataset (misalnya dataset streaming), max_steps harus diatur dalam argumen pelatihan, karena panjangnya tidak dapat disimpulkan dan jumlah total langkah pelatihan diperlukan untuk membatasi loop pelatihan serta mengonfigurasi penjadwal laju pembelajaran.
eval_dataset (Dataset, IterableDataset, DatasetDict, IterableDatasetDict atau dict[str, Dataset | IterableDataset]) — Dataset yang digunakan untuk evaluasi. Dataset ini harus memenuhi persyaratan yang sama dengan train_dataset.
processing_class (PreTrainedTokenizerBase atau ProcessorMixin, opsional) — Kelas pemrosesan yang digunakan untuk memproses data. Sisi padding harus diatur ke “left”. Jika None, kelas pemrosesan dimuat dari nama model dengan from_pretrained. Token padding, tokenizer.pad_token, harus diatur. Jika kelas pemrosesan belum mengatur token padding, tokenizer.eos_token akan digunakan sebagai default.
compute_metrics (Callable[[EvalPrediction], dict], opsional) — Fungsi yang akan digunakan untuk menghitung metrik saat evaluasi. Harus menerima EvalPrediction dan mengembalikan kamus dari string ke nilai metrik. Saat meneruskan SFTConfig dengan batch_eval_metrics diset ke True, fungsi compute_metrics Anda harus menerima argumen boolean compute_result. Ini akan dipicu setelah batch evaluasi terakhir untuk memberi sinyal bahwa fungsi perlu menghitung dan mengembalikan statistik ringkasan global, bukan mengakumulasi statistik tingkat batch. Logits yang diterimanya dihitung ulang dengan satu langkah forward tambahan. Ini sudah tidak didukung dan akan dihapus di v2.0.0.
callbacks (daftar TrainerCallback, opsional) — Daftar callback untuk menyesuaikan loop pelatihan. Callback ini akan ditambahkan ke daftar callback default yang dijelaskan di sini.
Jika Anda ingin menghapus salah satu callback default yang digunakan, gunakan metode remove_callback.
optimizers (tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None], opsional, defaultnya (None, None)) — Tuple yang berisi optimizer dan scheduler yang akan digunakan. Secara default akan menggunakan instance AdamW pada model Anda dan scheduler yang diberikan oleh get_linear_schedule_with_warmup yang dikendalikan oleh args.
quantization_config (BitsAndBytesConfig, opsional) — Konfigurasi kuantisasi yang digunakan saat memuat model dari pengidentifikasi model. Gabungkan dengan peft_config untuk pelatihan QLoRA. Diabaikan jika model sudah diinstansiasi.
peft_config (PeftConfig, opsional) — Konfigurasi PEFT yang digunakan untuk membungkus model. Jika None, model tidak dibungkus.

Trainer untuk metode Direct Preference Optimization (DPO). Algoritma ini pertama kali diusulkan dalam makalah Direct Preference Optimization: Your Language Model is Secretly a Reward Model. Kelas ini adalah pembungkus (wrapper) dari kelas Trainer dan mewarisi semua atribut serta metodenya.

Contoh:

>>> from trl import DPOTrainer
>>> from datasets import load_dataset

>>> dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")

>>> trainer = DPOTrainer(
...     model="Qwen/Qwen2.5-0.5B-Instruct",
...     train_dataset=dataset,
... )
>>> trainer.train()

latih

< source >

Parameter

resume_from_checkpoint (str atau bool, opsional) — Jika berupa str, jalur lokal ke checkpoint yang disimpan oleh instance Trainer sebelumnya. Jika berupa bool dan bernilai True, muat checkpoint terakhir di args.output_dir yang disimpan oleh instance Trainer sebelumnya. Jika ada, pelatihan akan dilanjutkan dari status model/optimizer/scheduler yang dimuat di sini.
trial (optuna.Trial atau dict[str, Any], opsional) — Jalankan trial atau kamus hiperparameter untuk pencarian hiperparameter.
ignore_keys_for_eval (list[str], opsional) — Daftar kunci dalam output model Anda (jika berupa dictionary) yang harus diabaikan saat mengumpulkan prediksi untuk evaluasi selama pelatihan.

Mengembalikan

~trainer_utils.TrainOutput

Objek yang berisi jumlah langkah global, kerugian pelatihan, dan metrik.

Titik masuk utama pelatihan.

save_model

< source >

( output_dir: str | None = None_internal_call: bool = False )

Akan menyimpan model, sehingga Anda dapat memuatnya kembali menggunakan from_pretrained().

Hanya akan menyimpan dari proses utama.

push_to_hub

< source >

( commit_message: str | None = 'End of training'blocking: bool = Truetoken: str | None = Nonerevision: str | None = Noneprivate: bool | None = None**kwargs )

Parameter

commit_message (str, opsional, default "End of training") — Pesan untuk commit saat melakukan push.
blocking (bool, opsional, default True) — Apakah fungsi harus hanya mengembalikan nilai setelah git push selesai.
token (str, opsional, defaultnya None) — Token dengan izin tulis untuk menimpa argumen asli Trainer.
revision (str, opsional) — Revisi git untuk di-commit. Secara default menggunakan head dari branch “main”.
private (bool, opsional) — Apakah membuat repo menjadi privat saat dibuat. Defaultnya adalah args.hub_private_repo. Tidak berpengaruh jika repo sudah ada.
kwargs (dict[str, Any], opsional) — Argumen kata kunci tambahan yang diteruskan ke ~Trainer.create_model_card.

Unggah self.model dan self.processing_class ke 🤗 model hub di repo self.args.hub_model_id.

DPOConfig

kelas trl.DPOConfig

< source >

( output_dir: str | None = Noneper_device_train_batch_size: int = 8num_train_epochs: float = 3.0max_steps: int = -1learning_rate: float = 1e-06lr_scheduler_type: transformers.trainer_utils.SchedulerType | str = 'linear'lr_scheduler_kwargs: dict | str | None = Nonewarmup_steps: float = 0optim: transformers.training_args.OptimizerNames | str = 'adamw_torch_fused'optim_args: str | None = Noneweight_decay: float = 0.0adam_beta1: float = 0.9adam_beta2: float = 0.999adam_epsilon: float = 1e-08optim_target_modules: None | str | list[str] = Nonegradient_accumulation_steps: int = 1average_tokens_across_devices: bool = Truemax_grad_norm: float = 1.0label_smoothing_factor: float = 0.0bf16: bool | None = Nonefp16: bool = Falsebf16_full_eval: bool = Falsefp16_full_eval: bool = Falsetf32: bool | None = Noneactivation_checkpointing: bool | None = Noneactivation_checkpointing_kwargs: dict[str, typing.Any] | str | None = Nonegradient_checkpointing: bool = Truegradient_checkpointing_kwargs: dict[str, typing.Any] | str | None = Nonetorch_compile: bool = Falsetorch_compile_backend: str | None = Nonetorch_compile_mode: str | None = Noneuse_liger_kernel: bool = Falseliger_kernel_config: dict[str, bool] | None = Noneuse_cache: bool = Falseneftune_noise_alpha: float | None = Nonetorch_empty_cache_steps: int | None = Noneauto_find_batch_size: bool = Falselogging_strategy: transformers.trainer_utils.IntervalStrategy | str = 'steps'logging_steps: float = 10logging_first_step: bool = Falselog_on_each_node: bool = Truelogging_nan_inf_filter: bool = Trueinclude_num_input_tokens_seen: str | bool = 'no'log_level: str = 'passive'log_level_replica: str = 'warning'disable_tqdm: bool | None = Nonereport_to: None | str | list[str] = 'none'run_name: str | None = Noneproject: str = 'huggingface'trackio_space_id: str | None = Nonetrackio_bucket_id: str | None = Nonetrackio_static_space_id: typing.Union[str, NoneType, typing.Literal[False]] = Noneeval_strategy: transformers.trainer_utils.IntervalStrategy | str = 'no'eval_steps: float | None = Noneeval_delay: float = 0per_device_eval_batch_size: int = 8prediction_loss_only: bool = Falseeval_on_start: bool = Falseeval_do_concat_batches: bool = Trueeval_use_gather_object: bool = Falseeval_accumulation_steps: int | None = Noneinclude_for_metrics: list[str] = <factory>batch_eval_metrics: bool = Falsesave_only_model: bool = Falsesave_strategy: transformers.trainer_utils.SaveStrategy | str = 'steps'save_steps: float = 500save_on_each_node: bool = Falsesave_total_limit: int | None = Noneenable_jit_checkpoint: bool = Falsepush_to_hub: bool = Falsehub_token: str | None = Nonehub_private_repo: bool | None = Nonehub_model_id: str | None = Nonehub_strategy: transformers.trainer_utils.HubStrategy | str = 'every_save'hub_always_push: bool = Falsehub_revision: str | None = Noneload_best_model_at_end: bool = Falsemetric_for_best_model: str | None = Nonegreater_is_better: bool | None = Noneignore_data_skip: bool = Falserestore_callback_states_from_checkpoint: bool = Falsefull_determinism: bool = Falseseed: int = 42data_seed: int | None = Noneuse_cpu: bool = Falseaccelerator_config: dict | str | None = Noneparallelism_config: accelerate.parallelism_config.ParallelismConfig | None = Nonedataloader_drop_last: bool = Falsedataloader_num_workers: int = 0dataloader_pin_memory: bool = Truedataloader_persistent_workers: bool = Falsedataloader_prefetch_factor: int | None = Nonedataloader_multiprocessing_context: str | None = Nonedataloader_in_order: bool = Trueremove_unused_columns: bool = Truelabel_names: list[str] | None = Nonetrain_sampling_strategy: str = 'random'length_column_name: str = 'length'ddp_find_unused_parameters: bool | None = Noneddp_bucket_cap_mb: int | None = Noneddp_broadcast_buffers: bool | None = Noneddp_static_graph: bool | None = Noneddp_backend: str | None = Noneddp_timeout: int = 1800fsdp: str | None = Nonefsdp_config: dict[str, typing.Any] | str | None = Nonedeepspeed: dict | str | None = Nonedebug: str | list[transformers.debug_utils.DebugOption] = ''skip_memory_metrics: bool = Truedo_train: bool = Falsedo_eval: bool = Falsedo_predict: bool = Falseresume_from_checkpoint: str | None = Nonelocal_rank: int = -1model_init_kwargs: dict[str, typing.Any] | str | None = Nonetrust_remote_code: bool = Falserouter_aux_loss_coef: float | None = Nonedisable_dropout: bool = Truedataset_num_proc: int | None = Nonemax_length: int | None = 1024truncation_mode: str = 'keep_start'padding_free: bool = Falsepad_to_multiple_of: int | str | None = 'auto'precompute_ref_log_probs: bool = Falseprecompute_ref_batch_size: int | None = Noneloss_type: list[str] = <factory>loss_weights: list[float] | None = Noneld_alpha: float | None = Nonef_divergence_type: str = 'reverse_kl'f_alpha_divergence_coef: float = 0.5label_smoothing: float = 0.0beta: float = 0.1use_weighting: bool = Falsediscopop_tau: float = 0.05activation_offloading: bool = Falsesync_ref_model: bool = Falseref_model_mixup_alpha: float = 0.6ref_model_sync_steps: int = 512pad_token: str | None = None )

Parameter yang mengontrol model

model_init_kwargs (dict[str, Any], opsional) — Argumen kata kunci untuk from_pretrained, digunakan ketika argumen model dari DPOTrainer diberikan sebagai string. Nilai revision juga digunakan saat memuat kelas pemrosesan.
trust_remote_code (bool, opsional, default False) — Apakah mengizinkan pemuatan model dan tokenizer yang menyertakan kode Python kustom dari Hub. Diteruskan ke from_pretrained dan from_pretrained.
router_aux_loss_coef (float, opsional) — Koefisien dari loss tambahan penyeimbangan beban untuk model Mixture-of-Experts (MoE), yang ditambahkan ke loss pelatihan dengan bobot ini. Jika tidak diatur, nilai yang dideklarasikan oleh konfigurasi model akan digunakan. Atur ke 0.0 untuk menonaktifkannya. Gagal jika digunakan dengan model non-MoE.
disable_dropout (bool, opsional, default True) — Apakah akan menonaktifkan dropout pada model dan model referensi.

Parameter yang mengontrol pra-pemrosesan data

dataset_num_proc (int, opsional) — Jumlah proses yang digunakan untuk memproses dataset.
max_length (int atau None, opsional, default 1024) — Panjang maksimum dari urutan yang ditokenisasi. Urutan yang lebih panjang dari max_length akan dipangkas dari kiri atau kanan tergantung pada truncation_mode. Jika None, pemangkasan tidak diterapkan.
truncation_mode (str, opsional, default "keep_start") — Mode pemotongan yang digunakan ketika urutan melebihi max_length. Nilai yang didukung hanyalah "keep_start". Nilai "keep_end" sudah tidak didukung lagi dan akan dihapus pada v2.0.0.
padding_free (bool, opsional, default False) — Apakah akan melakukan forward pass tanpa padding dengan meratakan semua urutan dalam batch menjadi satu urutan kontinu. Hal ini mengurangi penggunaan memori dengan menghilangkan overhead padding. Saat ini, fitur ini hanya didukung dengan FlashAttention 2 atau 3, yang dapat menangani struktur batch yang telah diratakan secara efisien. Sementara tidak tersedia: sejak refactoring DPO, mengatur nilainya ke True akan memberikan peringatan dan kembali ke padding standar. Fitur ini direncanakan untuk dikembalikan dalam pembaruan mendatang.
pad_to_multiple_of (int atau str, opsional, default "auto") — Jika diset, urutan akan di-*pad* menjadi kelipatan dari nilai ini. "auto" melakukan *padding* menjadi kelipatan 128 pada Neuron (AWS Trainium), yang dikompilasi sekali per bentuk input, dan tidak melakukan *padding* di tempat lain.
precompute_ref_log_probs (bool, opsional, default False) — Apakah akan menghitung log probabilitas model referensi untuk seluruh dataset pelatihan sebelum pelatihan dimulai. Hal ini memungkinkan penghematan memori selama pelatihan, karena model referensi tidak perlu disimpan di memori.
precompute_ref_batch_size (int, opsional) — Ukuran batch yang digunakan saat pramenghitung log probabilitas model referensi. Nilai ini dapat diatur lebih tinggi daripada ukuran batch pelatihan untuk mempercepat pra-pemrosesan. Jika None, secara default menggunakan per_device_train_batch_size untuk pelatihan dan per_device_eval_batch_size untuk evaluasi.

Parameter yang mengontrol pelatihan

loss_type (list[str], opsional, defaultnya ["sigmoid"]) — Jenis loss yang akan digunakan. Nilai yang mungkin adalah: 'sigmoid', 'hinge', 'ipo', 'exo_pair', 'nca_pair', 'robust', 'bco_pair', 'sppo_hard', 'aot', 'aot_unpaired', 'apo_zero', 'apo_down', 'discopop', 'sft', 'sigmoid_norm', 'udpo'. Jika beberapa jenis loss diberikan, mereka akan digabungkan menggunakan bobot yang ditentukan dalam loss_weights.
loss_weights (list[float], opsional) — Daftar bobot loss untuk kombinasi multi-loss. Digunakan saat menggabungkan beberapa jenis loss. Contoh: [0.8, 0.2, 1.0] untuk MPO. Jika tidak disediakan, secara default menggunakan bobot yang sama (1.0) untuk semua jenis loss.
ld_alpha (float, opsional) — parameter α dari paper LD-DPO, yang mengontrol pembobotan log-probabilitas token verbose dalam respons. Jika None, tidak ada pembobotan yang diterapkan pada bagian verbose, dan loss-nya ekuivalen dengan loss DPO standar. Harus berada dalam [0.0, 1.0]: ld_alpha=1.0 tidak menerapkan pembobotan, dan ld_alpha=0.0 mem-mask token di luar panjang bersama.
f_divergence_type (str, opsional, default "reverse_kl") — regularizer f-divergence antara policy dan referensi (paper f-DPO). Nilai yang mungkin adalah: reverse_kl (default), forward_kl, js_divergence, alpha_divergence. Hanya tipe loss yang dibangun di atas selisih reward chosen-rejected yang mendukung nilai non-default: 'sigmoid', 'sigmoid_norm', 'hinge', 'ipo', 'exo_pair', 'robust', 'discopop', 'sft', 'udpo'. Tipe loss lainnya tidak memiliki generalisasi f-divergence yang valid dan akan ditolak jika menggunakan nilai non-default.
f_alpha_divergence_coef (float, opsional, default 0.5) — koefisien α untuk regularizer α-divergence u^-α, hanya digunakan ketika f_divergence_type='alpha_divergence'.
label_smoothing (float, opsional, default 0.0) — Parameter label smoothing yang digunakan dalam Robust DPO, UDPO, dan EXO. Pada Robust DPO dan UDPO, parameter ini diinterpretasikan sebagai probabilitas ε bahwa label preferensi dibalik dan harus berada dalam rentang [0.0, 0.5); nilai tipikal yang direkomendasikan oleh paper Robust DPO adalah 0.1. UDPO menggunakannya untuk menetapkan a = ε / (1 - ε), dan paper UDPO merekomendasikan a = 0.8, yaitu ε = 4/9. Pada EXO, parameter ini sesuai dengan parameter label smoothing ε, yang direkomendasikan paper dengan nilai tipikal 1e-3.
beta (float, opsional, default 0.1) — Parameter yang mengontrol deviasi dari model referensi. Nilai β yang lebih tinggi berarti deviasi yang lebih kecil dari model referensi. Untuk kerugian IPO (loss_type='ipo'), nilai ini adalah parameter regularisasi yang dilambangkan dengan τ dalam makalah.
use_weighting (bool, opsional, default False) — Apakah akan menerapkan penimbangan bergaya WPO pada pasangan preferensi menggunakan probabilitas sekuens yang dinormalisasi berdasarkan panjang dari kebijakan.
discopop_tau (float, opsional, default 0.05) — parameter τ/suhu dari paper DiscoPOP, yang mengontrol bentuk loss yang dimodulasi log-ratio ketika menggunakan loss_type='discopop'. Paper tersebut merekomendasikan nilai default discopop_tau=0.05.
activation_offloading (bool, opsional, default False) — Apakah akan memindahkan aktivasi ke CPU.
sync_ref_model (bool, opsional, default False) — Apakah model referensi akan disinkronkan dengan model aktif setiap ref_model_sync_steps langkah, menggunakan parameter ref_model_mixup_alpha. Sinkronisasi ini berasal dari paper TR-DPO. sync_ref_model=True belum kompatibel dengan PEFT atau precompute_ref_log_probs=True.
ref_model_mixup_alpha (float, opsional, default 0.6) — parameter α dari paper TR-DPO, yang mengontrol campuran antara kebijakan saat ini dan kebijakan referensi sebelumnya selama pembaruan. Kebijakan referensi diperbarui sesuai persamaan: π_ref = α * π_θ + (1 - α) * π_ref_prev. Untuk menggunakan parameter ini, Anda harus mengatur sync_ref_model=True.
ref_model_sync_steps (int, opsional, default 512) — parameter τ dari paper TR-DPO, yang menentukan seberapa sering kebijakan saat ini disinkronkan dengan kebijakan referensi. Untuk menggunakan parameter ini, Anda harus mengatur sync_ref_model=True.

Parameter yang tidak didukung lagi

pad_token —
Parameter pad_token sudah tidak didukung dan akan dihapus pada versi v2.0.0. Tetapkan tokenizer.pad_token secara langsung dan teruskan sebagai processing_class ke trainer sebagai gantinya.

Kelas konfigurasi untuk DPOTrainer.

Kelas ini hanya mencakup parameter yang spesifik untuk pelatihan DPO. Untuk daftar lengkap argumen pelatihan, silakan merujuk ke dokumentasi TrainingArguments. Perhatikan bahwa nilai default dalam kelas ini mungkin berbeda dari yang ada di TrainingArguments.

Dengan HfArgumentParser, kita dapat mengubah kelas ini menjadi argumen argparse yang dapat ditentukan di baris perintah.

Parameter-parameter ini memiliki nilai default yang berbeda dari TrainingArguments:

logging_steps: Bawaan adalah 10 alih-alih 500.

gradient_checkpointing: Beralih ke True sebagai nilai bawaan, bukan False.

bf16: Beralih ke True jika fp16 tidak diatur, alih-alih False.

learning_rate: Bawaan adalah 1e-6 alih-alih 5e-5.

Update on GitHub