TRL documentation

KTO Trainer

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

KTO Trainer

All_models-KTO-blue

Ikhtisar

TRL mendukung Trainer Optimasi Kahneman-Tversky (KTO) untuk melatih model bahasa, seperti yang dijelaskan dalam makalah KTO: Model Alignment as Prospect Theoretic Optimization oleh Kawin Ethayarajh, Winnie Xu, Niklas Muennighoff, Dan Jurafsky, Douwe Kiela.

Abstrak dari makalah tersebut adalah sebagai berikut:

Teori prospek dari Kahneman & Tversky menunjukkan bahwa manusia mempersepsikan variabel acak dengan cara yang bias namun terdefinisi dengan baik; misalnya, manusia terkenal memiliki aversi terhadap kerugian. Kami menunjukkan bahwa tujuan untuk menyelaraskan LLM dengan umpan balik manusia secara implisit mengintegrasikan banyak bias tersebut — keberhasilan tujuan-tujuan ini (misalnya, DPO) dibandingkan dengan minimasi entropi silang dapat sebagian dikaitkan dengan fakta bahwa mereka merupakan fungsi kerugian yang sadar akan manusia (HALOs). Namun, fungsi utilitas yang diatribusikan oleh metode-metode ini kepada manusia masih berbeda dari yang ada dalam literatur teori prospek. Dengan menggunakan model utilitas manusia Kahneman-Tversky, kami mengusulkan sebuah HALO yang secara langsung memaksimalkan utilitas dari generasi, alih-alih memaksimalkan log-likelihood dari preferensi seperti yang dilakukan metode saat ini. Kami menyebut pendekatan ini sebagai Optimasi Kahneman-Tversky (KTO), dan ia menyamai atau melampaui kinerja metode berbasis preferensi pada skala dari 1B hingga 30B. Yang krusial, KTO tidak memerlukan preferensi — hanya sinyal biner tentang apakah suatu keluaran diinginkan atau tidak diinginkan untuk suatu masukan tertentu. Hal ini membuatnya jauh lebih mudah digunakan di dunia nyata, di mana data preferensi langka dan mahal.

Kode resmi dapat ditemukan di ContextualAI/HALOs.

Metode pasca-pelatihan ini disumbangkan oleh Kashif Rasul, Younes Belkada, Lewis Tunstall, Pablo Vicente, dan kemudian direfaktor oleh Albert Villanova del Moral.

Mulai cepat

Contoh ini menunjukkan cara melatih model menggunakan metode KTO. Kami menggunakan model Qwen 0.5B sebagai model dasar. Kami menggunakan data preferensi dari KTO Mix 14k. Anda dapat melihat data dalam dataset di sini:

Berikut adalah skrip untuk melatih model:

# train_kto.py
from datasets import load_dataset
from trl import KTOConfig, KTOTrainer
from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2-0.5B-Instruct")
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2-0.5B-Instruct")
train_dataset = load_dataset("trl-lib/kto-mix-14k", split="train")

training_args = KTOConfig(output_dir="Qwen2-0.5B-KTO")
trainer = KTOTrainer(model=model, args=training_args, processing_class=tokenizer, train_dataset=train_dataset)
trainer.train()

Jalankan skrip menggunakan perintah berikut:

torchrun --nproc_per_node 8 train_kto.py

Distribusi di 8 x GPU H100, pelatihan memakan waktu sekitar 30 menit. Anda dapat memverifikasi kemajuan pelatihan dengan memeriksa grafik reward. Tren peningkatan pada margin reward menunjukkan bahwa model sedang membaik dan menghasilkan respons yang lebih baik seiring waktu.

kto qwen2 reward margin

Untuk melihat bagaimana kinerja model terlatih, Anda dapat menggunakan Transformers Chat CLI.

$ transformers chat trl-lib/Qwen2-0.5B-KTO
<quentin_gallouedec>:
What is the best programming language?

<trl-lib/Qwen2-0.5B-KTO>:
The best programming language can vary depending on individual preferences, industry-specific requirements, technical skills, and familiarity with the specific use case or task. Here are some widely-used programming languages that have been noted as popular and widely used:

Here are some other factors to consider when choosing a programming language for a project:

 1 JavaScript: JavaScript is at the heart of the web and can be used for building web applications, APIs, and interactive front-end applications like frameworks like React and Angular. It's similar to C, C++, and F# in syntax structure and is accessible and easy to learn, making it a popular choice for beginners and professionals alike.
 2 Java: Known for its object-oriented programming (OOP) and support for Java 8 and .NET, Java is used for developing enterprise-level software applications, high-performance games, as well as mobile apps, game development, and desktop applications.
 3 C++: Known for its flexibility and scalability, C++ offers comprehensive object-oriented programming and is a popular choice for high-performance computing and other technical fields. It's a powerful platform for building real-world applications and games at scale.
 4 Python: Developed by Guido van Rossum in 1991, Python is a high-level, interpreted, and dynamically typed language known for its simplicity, readability, and versatility.

Jenis dan format dataset yang diharapkan

KTO memerlukan dataset preferensi unpaired. Sebagai alternatif, Anda dapat menyediakan dataset preferensi paired (yang juga dikenal sebagai dataset preferensi). Dalam kasus ini, trainer akan secara otomatis mengonversinya ke format unpaired dengan memisahkan respons yang dipilih dan ditolak, serta menetapkan label = True untuk penyelesaian yang dipilih dan label = False untuk yang ditolak.

KTOTrainer kompatibel dengan format dataset standar dan konversasional. Ketika diberikan dataset konversasional, trainer akan secara otomatis menerapkan chat template ke dataset tersebut.

# Standard format
unpaired_preference_example = {"prompt": "The sky is", "completion": " blue.", "label": True}

# Conversational format
unpaired_preference_example = {"prompt": [{"role": "user", "content": "What color is the sky?"}],
                               "completion": [{"role": "assistant", "content": "It is blue."}],
                               "label": True}

Secara teori, dataset harus berisi setidaknya satu penyelesaian yang dipilih dan satu yang ditolak. Namun, beberapa pengguna berhasil menjalankan KTO menggunakan hanya data yang dipilih atau hanya data yang ditolak. Jika hanya menggunakan data yang ditolak, disarankan untuk mengadopsi laju pembelajaran yang konservatif.

Menggali lebih dalam ke metode KTO

Kahneman-Tversky Optimization (KTO) adalah metode pelatihan yang dirancang untuk menyelaraskan model bahasa menggunakan hanya sinyal biner apakah suatu output diinginkan atau tidak diinginkan untuk input tertentu, bukan pasangan penyelesaian yang disukai/tidak disukai. Berangkat dari teori prospek Kahneman dan Tversky, metode ini mendefinisikan human-aware loss (HALO) yang secara langsung memaksimalkan utilitas dari generasi, dengan memberikan bobot secara asimetris pada contoh yang diinginkan dan tidak diinginkan untuk mencerminkan aversi terhadap kerugian manusia.

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

Pra-pemrosesan dan tokenisasi

Selama pelatihan, setiap contoh diharapkan berisi prompt, completion, dan label boolean yang menunjukkan apakah completion tersebut diinginkan (True) atau tidak diinginkan (False). Untuk detail lebih lanjut mengenai format yang diharapkan, lihat Dataset formats. KTOTrainer melakukan tokenisasi setiap input menggunakan tokenizer model.

Menghitung loss

Istilah divergensi KL yang digunakan oleh kerugian KTO diperkirakan dengan memasangkan setiap prompt dengan penyelesaian yang tidak cocok yang diambil dari bagian lain dalam batch. Karena alasan ini, jenis kerugian yang memperkirakan istilah KL (semua kecuali apo_zero_unpaired) memerlukan ukuran batch pelatihan per perangkat yang lebih besar dari 1 dan strategi pengambilan sampel berurutan, sehingga pasangan yang tidak cocok tetap stabil di seluruh batch.

Loss yang digunakan dalam KTO (Persamaan 7 dari makalah) didefinisikan sebagai berikut: LKTO(θ)=E(x,y) ⁣[w(y)(1−v(x,y))] \mathcal{L}_{\mathrm{KTO}}(\theta) = \mathbb{E}_{(x,y)}\!\left[ w(y)\Big(1 - v(x, y)\Big) \right]

di mana nilai v(x,y) v(x, y) adalah v(x,y)={σ ⁣(β(log⁡πθ(y∣x)πref(y∣x)−KL))if y is desirableσ ⁣(β(KL−log⁡πθ(y∣x)πref(y∣x)))if y is undesirable v(x, y) = \begin{cases} \sigma\!\left(\beta\big(\log\frac{\pi_{\theta}(y\mid x)}{\pi_{\mathrm{ref}}(y\mid x)} - \mathrm{KL}\big)\right) & \text{if } y \text{ is desirable} \\ \sigma\!\left(\beta\big(\mathrm{KL} - \log\frac{\pi_{\theta}(y\mid x)}{\pi_{\mathrm{ref}}(y\mid x)}\big)\right) & \text{if } y \text{ is undesirable} \end{cases}

Di sini x x adalah prompt, y y adalah penyelesaian, πθ \pi_{\theta} adalah model kebijakan yang dilatih, πref \pi_{\mathrm{ref}} adalah model referensi, σ \sigma adalah fungsi sigmoid, β>0 \beta > 0 mengontrol deviasi dari model referensi, dan KL \mathrm{KL} adalah istilah divergensi KL yang diperkirakan. Bobot w(y) w(y) adalah desirable_weight untuk penyelesaian yang diinginkan dan undesirable_weight untuk yang tidak diinginkan, digunakan untuk mengimbangi ketidakseimbangan antara jumlah contoh yang diinginkan dan tidak diinginkan.

Jenis-jenis Loss

loss_type=Deskripsi
"kto" (default)Kehilangan KTO dari makalah KTO. Kehilangan yang sadar akan manusia (HALO) berdasarkan teori prospek Kahneman-Tversky yang memaksimalkan utilitas penyelesaian yang diinginkan dan meminimalkannya untuk yang tidak diinginkan, menggunakan istilah divergensi KL yang diperkirakan sebagai titik referensi.
"apo_zero_unpaired"Varian tidak berpasangan dari kerugian APO-zero dari makalah APO. Kerugian ini meningkatkan kemungkinan penyelesaian yang diinginkan dan mengurangi kemungkinan penyelesaian yang tidak diinginkan tanpa memperkirakan istilah divergensi KL. Gunakan kerugian ini ketika Anda yakin bahwa penyelesaian yang diinginkan lebih baik daripada output default model.

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 KTO loss pada interval logging 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.
  • kl: Estimasi rata-rata divergensi KL antara model kebijakan dan model referensi, yang digunakan sebagai titik acuan dalam kerugian KTO.
  • 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 pada token dalam penyelesaian yang dipilih (diinginkan).
  • logits/rejected: Nilai logit rata-rata yang diberikan model untuk token dalam penyelesaian yang ditolak (tidak diinginkan).
  • logps/chosen: Rata-rata log-probabilitas yang diberikan model pada token dalam penyelesaian yang dipilih (diinginkan).
  • logps/rejected: Rata-rata log-probabilitas yang diberikan model pada token dalam penyelesaian yang ditolak (tidak diinginkan).
  • rewards/chosen: Rata-rata reward implisit yang dihitung untuk penyelesaian yang dipilih (diinginkan), dihitung sebagai βlog⁡πθ(y∣x)πref(y∣x) \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 (tidak diinginkan), dihitung sebagai βlog⁡πθ(y∣x)πref(y∣x) \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.

Kustomisasi

Kompatibilitas dan batasan

Beberapa kombinasi argumen sengaja dibatasi dalam implementasi KTOTrainer saat ini:

  • 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) atau dengan dataset vision.
  • Jenis loss yang memperkirakan istilah divergensi KL (semua kecuali "apo_zero_unpaired") memerlukan train_sampling_strategy="sequential" dan ukuran batch pelatihan per perangkat yang lebih besar dari 1.

Inisialisasi model

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

model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2-0.5B-Instruct", dtype=torch.bfloat16)

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

from trl import KTOConfig

training_args = KTOConfig(
    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 KTOTrainer
from peft import LoraConfig

dataset = load_dataset("trl-lib/kto-mix-14k", split="train")

trainer = KTOTrainer(
    "Qwen/Qwen2-0.5B-Instruct",
    train_dataset=dataset,
    peft_config=LoraConfig(),
)

trainer.train()

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

Saat melatih adapter, Anda biasanya menggunakan learning rate yang lebih tinggi daripada full fine-tuning karena hanya parameter baru yang dipelajari.

Pemanggilan Alat dengan KTO

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

  • Pesan percakapan (prompt dan completion), 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

KTOTrainer 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.

from trl import KTOConfig, KTOTrainer
from datasets import load_dataset

trainer = KTOTrainer(
    model="Qwen/Qwen2.5-VL-3B-Instruct",
    args=KTOConfig(max_length=None),
    train_dataset=load_dataset("trl-internal-testing/zen-image", "conversational_unpaired_preference", 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 KTOConfig. Ini memungkinkan model memproses panjang urutan penuh tanpa memotong token gambar.

KTOConfig(max_length=None, ...)

Gunakan max_length hanya jika Anda telah memverifikasi bahwa pemotongan (truncation) tidak akan menghapus token gambar untuk seluruh dataset.

Skrip contoh

Kami menyediakan skrip contoh untuk melatih model menggunakan metode KTO. Skrip tersebut tersedia di trl/scripts/kto.py

Untuk menguji skrip KTO dengan model Qwen2 0.5B pada dataset UltraFeedback, jalankan perintah berikut:

torchrun --nproc_per_node 8 trl/scripts/kto.py \
    --model_name_or_path Qwen/Qwen2-0.5B-Instruct \
    --dataset_name trl-lib/kto-mix-14k \
    --num_train_epochs 1 \
    --output_dir Qwen2-0.5B-KTO

Tips penggunaan

Untuk Model Mixture of Experts: Mengaktifkan auxiliary loss

MOE paling efisien jika beban didistribusikan secara merata di antara para ahli.
Untuk memastikan bahwa MOE dilatih dengan cara yang serupa selama penyetelan preferensi, sangat bermanfaat untuk menambahkan kerugian bantu dari penyeimbang beban ke kerugian akhir.

Opsi ini diaktifkan dengan mengatur output_router_logits=True dalam konfigurasi model (misalnya MixtralConfig).
Untuk mengatur seberapa besar kontribusi loss tambahan terhadap total loss, gunakan hiperparameter router_aux_loss_coef=... (default: 0.001) dalam konfigurasi model.

Rekomendasi ukuran batch

Gunakan ukuran batch per langkah yang setidaknya 4, dan ukuran batch efektif antara 16 dan 128. Bahkan jika ukuran batch efektif Anda besar, jika ukuran batch per langkah Anda buruk, maka estimasi KL dalam KTO akan buruk.

Rekomendasi learning rate

Setiap pilihan beta memiliki batas laju pembelajaran maksimum yang dapat ditoleransi sebelum kinerja pembelajaran menurun. Untuk pengaturan default beta = 0.1, laju pembelajaran umumnya tidak boleh melebihi 1e-6 untuk sebagian besar model. Seiring beta menurun, laju pembelajaran juga harus dikurangi secara proporsional. Secara umum, kami sangat merekomendasikan untuk menjaga laju pembelajaran di antara 5e-7 dan 5e-6. Bahkan dengan dataset kecil, kami menyarankan untuk tidak menggunakan laju pembelajaran di luar rentang ini. Sebagai gantinya, gunakan lebih banyak epoch untuk mencapai hasil yang lebih baik.

Data tidak seimbang

Parameter desirable_weight dan undesirable_weight pada KTOConfig merujuk pada bobot yang diterapkan pada loss untuk contoh yang diinginkan/positif dan yang tidak diinginkan/negatif. Secara default, keduanya bernilai 1. Namun, jika Anda memiliki lebih banyak salah satu jenisnya, Anda sebaiknya menaikkan bobot jenis yang lebih jarang agar rasio (desirable_weight ×\times jumlah positif) terhadap (undesirable_weight ×\times jumlah negatif) berada dalam rentang 1:1 hingga 4:3.

KTOTrainer

kelas trl.KTOTrainer

< >

( model: str | PreTrainedModel | PeftModelref_model: transformers.modeling_utils.PreTrainedModel | None = Noneargs: trl.trainer.kto_config.KTOConfig | 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 KTO 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 KTO dimulai.
  • args (KTOConfig, 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 DataCollatorForUnpairedPreference jika modelnya adalah model bahasa dan DataCollatorForVisionUnpairedPreference jika modelnya adalah model vision-language. Collator kustom harus memotong (truncate) urutan sebelum padding; trainer tidak menerapkan pemotongan setelah collation.
  • train_dataset (Dataset atau IterableDataset) — Dataset yang digunakan untuk pelatihan. Trainer ini mendukung preferensi tanpa pasangan jenis. 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 Optimasi Kahneman-Tversky (KTO). Algoritma ini pertama kali diusulkan dalam makalah KTO: Model Alignment as Prospect Theoretic Optimization. Kelas ini adalah pembungkus (wrapper) di sekitar kelas Trainer dan mewarisi semua atribut serta metodenya.

Contoh:

>>> from trl import KTOTrainer
>>> from datasets import load_dataset

>>> dataset = load_dataset("trl-lib/kto-mix-14k", split="train")

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

latih

< >

( resume_from_checkpoint: str | bool | None = Nonetrial: optuna.Trial | dict[str, Any] | None = Noneignore_keys_for_eval: list[str] | None = None ) → ~trainer_utils.TrainOutput

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

< >

( 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

< >

( 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.

KTOConfig

kelas trl.KTOConfig

< >

( 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 = 'sequential'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 = 1024pad_to_multiple_of: int | str | None = 'auto'precompute_ref_log_probs: bool = Falseprecompute_ref_batch_size: int | None = Noneloss_type: str = 'kto'beta: float = 0.1desirable_weight: float = 1.0undesirable_weight: float = 1.0activation_offloading: bool = Falsesync_ref_model: bool = Falseref_model_mixup_alpha: float = 0.6ref_model_sync_steps: int = 512 )

Parameter yang mengontrol model

  • model_init_kwargs (dict[str, Any], opsional) — Argumen kata kunci untuk from_pretrained, digunakan ketika argumen model dari KTOTrainer 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 kanan. Jika None, pemangkasan tidak diterapkan.
  • 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 (str, opsional, default ke "kto") — Jenis loss yang akan digunakan. Nilai yang mungkin adalah:
    • "kto": KTO loss dari paper KTO.
    • "apo_zero_unpaired": Varian unpaired dari loss APO-zero dari paper APO.
  • 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.
  • desirable_weight (float, opsional, default 1.0) — Loss yang diinginkan diberi bobot dengan faktor ini untuk mengimbangi jumlah pasangan yang diinginkan dan tidak diinginkan yang tidak seimbang.
  • undesirable_weight (float, opsional, default 1.0) — Loss yang tidak diinginkan diberi bobot dengan faktor ini untuk mengimbangi jumlah pasangan yang diinginkan dan tidak diinginkan yang tidak seimbang.
  • 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.

Kelas konfigurasi untuk KTOTrainer.

Kelas ini hanya mencakup parameter yang spesifik untuk pelatihan KTO. 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.
  • train_sampling_strategy: Beralih ke "sequential" sebagai nilai bawaan, bukan "random". Jenis loss yang memperkirakan istilah divergensi KL (semua kecuali "apo_zero_unpaired") memerlukan sampling berurutan karena penyelesaian KL untuk setiap contoh dihitung sebelumnya terhadap tetangganya dalam batch dengan urutan tetap; strategi lain akan merusak pasangan tersebut.
Update on GitHub