TRL documentation
KTO Trainer
KTO Trainer
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.

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:
di mana nilai adalah
Di sini adalah prompt, adalah penyelesaian, adalah model kebijakan yang dilatih, adalah model referensi, adalah fungsi sigmoid, mengontrol deviasi dari model referensi, dan adalah istilah divergensi KL yang diperkirakan. Bobot 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 denganrouter_aux_loss_coefdan ditambahkan ke kerugian. Dicatat hanya ketika model adalah model MoE danrouter_aux_loss_coeftidak 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 .rewards/rejected: Rata-rata reward implisit yang dihitung untuk penyelesaian yang ditolak (tidak diinginkan), dihitung sebagai .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_headtidak didukung (gunakanmodules_to_save=["lm_head"]sebagai gantinya). sync_ref_model=Truetidak didukung saat melatih dengan model PEFT yang tidak mempertahankanref_modelyang berdiri sendiri.sync_ref_model=Truetidak dapat digabungkan denganprecompute_ref_log_probs=True.precompute_ref_log_probs=Truetidak didukung denganIterableDataset(train atau eval) atau dengan dataset vision.- Jenis loss yang memperkirakan istilah divergensi KL (semua kecuali
"apo_zero_unpaired") memerlukantrain_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 perantool) - 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=Nonedi KTOConfig. Ini memungkinkan model memproses panjang urutan penuh tanpa memotong token gambar.KTOConfig(max_length=None, ...)Gunakan
max_lengthhanya 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-KTOTips 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 jumlah positif) terhadap (undesirable_weight jumlah negatif) berada dalam rentang 1:1 hingga 4:3.
KTOTrainer
kelas trl.KTOTrainer
< source >( 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 (
stratau PreTrainedModel atauPeftModel) — 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 diargs.model_init_kwargs. Jikadtypetidak ditentukan diargs.model_init_kwargs, default-nya adalahfloat32. 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.
- 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
- 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 denganmodel, yaitu state model sebelum pelatihan KTO dimulai.
- Jika diberikan, model ini digunakan langsung sebagai kebijakan referensi. Model ini tidak boleh berupa
- 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 elementrain_datasetataueval_datasetyang telah diproses. Nilai defaultnya adalahDataCollatorForUnpairedPreferencejika modelnya adalah model bahasa danDataCollatorForVisionUnpairedPreferencejika 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_datasetadalah IterableDataset (misalnya dataset streaming),max_stepsharus 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 dengantrain_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_tokenakan 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 denganbatch_eval_metricsdiset keTrue, fungsicompute_metricsAnda harus menerima argumen booleancompute_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 instanceAdamWpada model Anda dan scheduler yang diberikan oleh get_linear_schedule_with_warmup yang dikendalikan olehargs. - quantization_config (BitsAndBytesConfig, opsional) —
Konfigurasi kuantisasi yang digunakan saat memuat model dari pengidentifikasi model. Gabungkan dengan
peft_configuntuk pelatihan QLoRA. Diabaikan jika model sudah diinstansiasi. - peft_config (
PeftConfig, opsional) — Konfigurasi PEFT yang digunakan untuk membungkus model. JikaNone, 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
< source >( 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 (
strataubool, opsional) — Jika berupastr, jalur lokal ke checkpoint yang disimpan oleh instanceTrainersebelumnya. Jika berupabooldan bernilaiTrue, muat checkpoint terakhir di args.output_dir yang disimpan oleh instanceTrainersebelumnya. Jika ada, pelatihan akan dilanjutkan dari status model/optimizer/scheduler yang dimuat di sini. - trial (
optuna.Trialataudict[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.
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, defaultTrue) — Apakah fungsi harus hanya mengembalikan nilai setelahgit pushselesai. - token (
str, opsional, defaultnyaNone) — 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 adalahargs.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
< 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 = '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 argumenmodeldari KTOTrainer diberikan sebagai string. Nilairevisionjuga digunakan saat memuat kelas pemrosesan. - trust_remote_code (
bool, opsional, defaultFalse) — 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 ke0.0untuk menonaktifkannya. Gagal jika digunakan dengan model non-MoE. - disable_dropout (
bool, opsional, defaultTrue) — 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 (
intatauNone, opsional, default1024) — Panjang maksimum dari urutan yang ditokenisasi. Urutan yang lebih panjang darimax_lengthakan dipangkas dari kanan. JikaNone, pemangkasan tidak diterapkan. - pad_to_multiple_of (
intataustr, 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, defaultFalse) — 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. JikaNone, secara default menggunakanper_device_train_batch_sizeuntuk pelatihan danper_device_eval_batch_sizeuntuk evaluasi.
Parameter yang mengontrol pelatihan
- loss_type (
str, opsional, default ke"kto") — Jenis loss yang akan digunakan. Nilai yang mungkin adalah: - beta (
float, opsional, default0.1) — Parameter yang mengontrol deviasi dari model referensi. Nilai β yang lebih tinggi berarti deviasi yang lebih kecil dari model referensi. - desirable_weight (
float, opsional, default1.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, default1.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, defaultFalse) — Apakah akan memindahkan aktivasi ke CPU. - sync_ref_model (
bool, opsional, defaultFalse) — Apakah model referensi akan disinkronkan dengan model aktif setiapref_model_sync_stepslangkah, menggunakan parameterref_model_mixup_alpha. Sinkronisasi ini berasal dari paper TR-DPO.sync_ref_model=Truebelum kompatibel dengan PEFT atauprecompute_ref_log_probs=True. - ref_model_mixup_alpha (
float, opsional, default0.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 mengatursync_ref_model=True. - ref_model_sync_steps (
int, opsional, default512) — parameter τ dari paper TR-DPO, yang menentukan seberapa sering kebijakan saat ini disinkronkan dengan kebijakan referensi. Untuk menggunakan parameter ini, Anda harus mengatursync_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 adalah10alih-alih500.gradient_checkpointing: Beralih keTruesebagai nilai bawaan, bukanFalse.bf16: Beralih keTruejikafp16tidak diatur, alih-alihFalse.learning_rate: Bawaan adalah1e-6alih-alih5e-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.