# KTO Trainer

[![All_models-KTO-blue](https://img.shields.io/badge/All_models-KTO-blue)](https://huggingface.co/models?other=kto,trl)

## Ikhtisar

TRL mendukung Trainer Optimasi Kahneman-Tversky (KTO) untuk melatih model bahasa, seperti yang dijelaskan dalam makalah [KTO: Model Alignment as Prospect Theoretic Optimization](https://huggingface.co/papers/2402.01306) oleh [Kawin Ethayarajh](https://huggingface.co/kawine), [Winnie Xu](https://huggingface.co/xwinxu), [Niklas Muennighoff](https://huggingface.co/Muennighoff), Dan Jurafsky, [Douwe Kiela](https://huggingface.co/douwekiela).

Abstrak dari makalah tersebut adalah sebagai berikut:

> Teori prospek dari Kahneman & Tversky memberitahu kita 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 menginkorporasikan banyak bias ini -- 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 oleh metode-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](https://github.com/ContextualAI/HALOs).

Metode pasca-pelatihan ini disumbangkan oleh [Kashif Rasul](https://huggingface.co/kashif), [Younes Belkada](https://huggingface.co/ybelkada), [Lewis Tunstall](https://huggingface.co/lewtun), Pablo Vicente, dan kemudian direfaktor oleh [Albert Villanova del Moral](https://huggingface.co/albertvillanova).

## Mulai cepat

Contoh ini menunjukkan cara melatih model menggunakan metode KTO. Kami menggunakan [model Qwen 0.5B](https://huggingface.co/Qwen/Qwen2-0.5B-Instruct) sebagai model dasar. Kami menggunakan data preferensi dari [KTO Mix 14k](https://huggingface.co/datasets/trl-lib/kto-mix-14k). Anda dapat melihat data dalam dataset di sini:

<iframe src="https://huggingface.co/datasets/trl-lib/kto-mix-14k/embed/viewer/default/train?row=0" frameborder="0" width="100%" height="560px"
>

Berikut adalah skrip untuk melatih model:

```python
# 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:

```bash
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](https://huggingface.co/datasets/trl-lib/documentation-images/resolve/main/kto-qwen2-reward-margin.png)

Untuk melihat bagaimana kinerja [model terlatih](https://huggingface.co/trl-lib/Qwen2-0.5B-KTO), Anda dapat menggunakan [Transformers Chat CLI](https://huggingface.co/docs/transformers/quicktour#chat-with-text-generation-models).

$ transformers chat trl-lib/Qwen2-0.5B-KTO &lt;quentin_gallouedec&gt;: Apa bahasa pemrograman terbaik?

&lt;trl-lib/Qwen2-0.5B-KTO&gt;: Bahasa pemrograman terbaik dapat bervariasi tergantung pada preferensi individu, persyaratan spesifik industri, keterampilan teknis, dan tingkat keakraban dengan kasus penggunaan atau tugas tertentu. Berikut adalah beberapa bahasa pemrograman yang banyak digunakan dan telah dicatat sebagai populer serta banyak dipakai:

Berikut adalah beberapa faktor lain yang perlu dipertimbangkan saat memilih bahasa pemrograman untuk sebuah proyek:

 1 JavaScript: JavaScript adalah inti dari web dan dapat digunakan untuk membangun aplikasi web, API, serta aplikasi front-end interaktif seperti framework React dan Angular. Sintaksnya mirip dengan C, C++, dan F#, mudah diakses, dan mudah dipelajari, menjadikannya pilihan populer bagi pemula maupun profesional. 2 Java: Dikenal karena pemrograman berorientasi objek (OOP) dan dukungannya untuk Java 8 dan .NET, Java digunakan untuk mengembangkan aplikasi perangkat lunak tingkat enterprise, game berkinerja tinggi, serta aplikasi mobile, pengembangan game, dan aplikasi desktop. 3 C++: Dikenal karena fleksibilitas dan skalabilitasnya, C++ menawarkan pemrograman berorientasi objek yang komprehensif dan merupakan pilihan populer untuk komputasi berkinerja tinggi serta bidang teknis lainnya. Ini adalah platform yang kuat untuk membangun aplikasi dan game dunia nyata dalam skala besar. 4 Python: Dikembangkan oleh Guido van Rossum pada tahun 1991, Python adalah bahasa tingkat tinggi, terinterpretasi, dan bertipe dinamis yang dikenal karena kesederhanaan, keterbacaan, dan versatilitasnya.

## Jenis dan format dataset yang diharapkan

KTO memerlukan dataset preferensi [unpaired](dataset_formats#unpaired-preference). 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](/docs/trl/v1.18.0/id/kto_trainer#trl.KTOTrainer) kompatibel dengan format dataset [standar](dataset_formats#standard) dan [konversasional](dataset_formats#conversational). Ketika diberikan dataset konversasional, trainer akan secara otomatis menerapkan chat template ke dataset tersebut.

```python
# 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](dataset_formats). [KTOTrainer](/docs/trl/v1.18.0/id/kto_trainer#trl.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](https://huggingface.co/papers/2402.01306)) didefinisikan sebagai berikut:

$$ \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) \\) adalah

$$ 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{jika } y \text{ diinginkan} \\ \sigma\!\left(\beta\big(\mathrm{KL} - \log\frac{\pi_{\theta}(y\mid x)}{\pi_{\mathrm{ref}}(y\mid x)}\big)\right) & \text{jika } y \text{ tidak diinginkan} \end{cases} $$

Di sini  \\( x \\) adalah prompt,  \\( y \\) adalah completion,  \\( \pi_{\theta} \\) adalah model policy yang sedang dilatih,  \\( \pi_{\mathrm{ref}} \\) adalah model referensi,  \\( \sigma \\) adalah fungsi sigmoid,  \\( \beta > 0 \\) mengontrol deviasi dari model referensi, dan  \\( \mathrm{KL} \\) adalah istilah divergensi KL yang diperkirakan. Bobot  \\( w(y) \\) adalah `desirable_weight` untuk completion 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](https://huggingface.co/papers/2402.01306). 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](https://huggingface.co/papers/2408.06266). 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 imbalan implisit yang dihitung untuk penyelesaian yang dipilih (diinginkan), dihitung sebagai  \\( \beta \log \frac{\pi_{\theta}(y\mid x)}{\pi_{\mathrm{ref}}(y\mid x)} \\).
- `rewards/rejected`: Rata-rata imbalan implisit yang dihitung untuk penyelesaian yang ditolak (tidak diinginkan), 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.

## Kustomisasi

### Kompatibilitas dan batasan

Beberapa kombinasi argumen sengaja dibatasi dalam implementasi [KTOTrainer](/docs/trl/v1.18.0/id/kto_trainer#trl.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](/docs/trl/v1.18.0/id/kto_trainer#trl.KTOConfig). Misalnya, jika Anda ingin memuat model dalam presisi yang berbeda, serupa dengan

```python
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](/docs/trl/v1.18.0/id/kto_trainer#trl.KTOConfig).

```python
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.

```python
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](/docs/trl/v1.18.0/id/kto_trainer#trl.KTOTrainer) dan teruskan secara langsung ke trainer tanpa mengargumentasikan `peft_config`.

> [!TIP]
> 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](/docs/trl/v1.18.0/id/kto_trainer#trl.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](dataset_formats#tool-calling).

## Pelatihan Model Bahasa Visual

[KTOTrainer](/docs/trl/v1.18.0/id/kto_trainer#trl.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](dataset_formats#vision-dataset).

```python
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()
```

> [!TIP]
> Untuk VLM, pemotongan dapat menghapus token gambar, yang menyebabkan kesalahan selama pelatihan. Untuk menghindari hal ini, atur `max_length=None` di [KTOConfig](/docs/trl/v1.18.0/id/kto_trainer#trl.KTOConfig). Ini memungkinkan model memproses panjang urutan penuh tanpa memotong token gambar.
>
> ```python
> 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`](https://github.com/huggingface/trl/blob/main/trl/scripts/kto.py)

Untuk menguji skrip KTO dengan [model Qwen2 0.5B](https://huggingface.co/Qwen/Qwen2-0.5B-Instruct) pada [dataset UltraFeedback](https://huggingface.co/datasets/trl-lib/kto-mix-14k), jalankan perintah berikut:

```bash
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](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/mixtral#transformers.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

`desirable_weight` dan `undesirable_weight` dari [KTOConfig](/docs/trl/v1.18.0/id/kto_trainer#trl.KTOConfig) merujuk pada bobot yang diterapkan pada kerugian (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 sehingga rasio antara (`desirable_weight`  \\(\times\\) jumlah positif) dan (`undesirable_weight`  \\(\times\\) jumlah negatif) berada dalam rentang 1:1 hingga 4:3.

## KTOTrainer[[trl.KTOTrainer]]

#### trl.KTOTrainer[[trl.KTOTrainer]]

```python
trl.KTOTrainer(model: str | PreTrainedModel | PeftModel, ref_model: transformers.modeling_utils.PreTrainedModel | None = None, args: trl.trainer.kto_config.KTOConfig | None = None, data_collator: collections.abc.Callable[[list[typing.Any]], dict[str, typing.Any]] | None = None, train_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | None = None, eval_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 = None, processing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | transformers.processing_utils.ProcessorMixin | None = None, compute_metrics: collections.abc.Callable[[transformers.trainer_utils.EvalPrediction], dict] | None = None, callbacks: list[transformers.trainer_callback.TrainerCallback] | None = None, optimizers: tuple[typing.Optional[torch.optim.Optimizer], typing.Optional[torch.optim.lr_scheduler.LambdaLR]] = (None, None), quantization_config: BitsAndBytesConfig | None = None, peft_config: PeftConfig | None = None)
```

[Sumber](https://github.com/huggingface/trl/blob/v1.18.0/trl/trainer/kto_trainer.py#L462)

**Parameter:**

model (`str` atau [PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel) atau `PeftModel`) : Model yang akan dilatih. Bisa berupa:  - String, yaitu *model id* dari model pretrained yang dihosting di dalam repo model di huggingface.co, atau path ke *directory* yang berisi bobot model yang disimpan menggunakan [save_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel.save_pretrained), misalnya `'./my_model_directory/'`. Model dimuat menggunakan `<ModelArchitecture>.from_pretrained` (di mana `<ModelArchitecture>` diturunkan dari konfigurasi model) dengan argumen kata kunci dalam `args.model_init_kwargs`. Jika `dtype` tidak ditentukan dalam `args.model_init_kwargs`, nilainya secara default adalah `float32`. Ini berbeda dari [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel.from_pretrained), di mana (sejak Transformers v5) dtype disimpulkan dari konfigurasi model. - Objek [PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel). Hanya model bahasa kausal yang didukung. - Objek `PeftModel`. Hanya model bahasa kausal yang didukung.

ref_model ([PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel), *opsional*) : Model referensi yang digunakan untuk menghitung probabilitas log 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 keadaan model sebelum pelatihan KTO dimulai.

args ([KTOConfig](/docs/trl/v1.18.0/id/kto_trainer#trl.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. Secara default akan menggunakan `DataCollatorForUnpairedPreference` jika modelnya adalah language model dan `DataCollatorForVisionUnpairedPreference` jika modelnya adalah vision-language model. Collator kustom harus memotong (truncate) urutan sebelum padding; trainer tidak menerapkan pemotongan setelah kolasi.

train_dataset ([Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset) atau [IterableDataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.IterableDataset)) : Dataset yang digunakan untuk pelatihan. Trainer ini mendukung tipe [unpaired preference](#unpaired-preference). Format sampel dapat berupa:  - [Standard](dataset_formats#standard): Setiap sampel berisi teks polos. - [Conversational](dataset_formats#conversational): Setiap sampel berisi pesan terstruktur (misalnya, role dan content).  Ketika `train_dataset` adalah [IterableDataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.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 learning rate scheduler.

eval_dataset ([Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset), [IterableDataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.IterableDataset), [DatasetDict](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.DatasetDict), [IterableDatasetDict](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.IterableDatasetDict) atau `dict[str, Dataset | IterableDataset]`) : Dataset yang digunakan untuk evaluasi. Dataset ini harus memenuhi persyaratan yang sama dengan `train_dataset`.

processing_class ([PreTrainedTokenizerBase](https://huggingface.co/docs/transformers/v5.23.0/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase) atau [ProcessorMixin](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/processors#transformers.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](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoProcessor.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](https://huggingface.co/docs/transformers/v5.23.0/en/internal/trainer_utils#transformers.EvalPrediction) dan mengembalikan kamus string ke nilai metrik. Saat meneruskan [SFTConfig](/docs/trl/v1.18.0/id/sft_trainer#trl.SFTConfig) dengan `batch_eval_metrics` diatur 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 maju tambahan. Ini tidak didukung lagi dan akan dihapus di v2.0.0.

callbacks (daftar [TrainerCallback](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/callback#transformers.TrainerCallback), *opsional*) : Daftar callback untuk menyesuaikan loop pelatihan. Callback tersebut akan ditambahkan ke daftar callback default yang dijelaskan di [di sini](https://huggingface.co/docs/transformers/main_classes/callback). Jika Anda ingin menghapus salah satu callback default yang digunakan, gunakan metode [remove_callback](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.Trainer.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](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/optimizer_schedules#transformers.get_linear_schedule_with_warmup) yang dikendalikan oleh `args`.

quantization_config ([BitsAndBytesConfig](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/quantization#transformers.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](https://huggingface.co/papers/2402.01306). Kelas ini adalah pembungkus (wrapper) dari kelas [Trainer](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.Trainer) dan mewarisi semua atribut serta metodenya.

Contoh:

```python
>>> 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()
```

#### train[[trl.KTOTrainer.train]]

```python
train(resume_from_checkpoint: str | bool | None = None, trial: optuna.Trial | dict[str, Any] | None = None, ignore_keys_for_eval: list[str] | None = None)
```

[Sumber](https://github.com/huggingface/trl/blob/v1.18.0/transformers/trainer.py#L1450)

**Parameter:**

resume_from_checkpoint (`str` atau `bool`, *opsional*) : Jika berupa `str`, path 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 state model/optimizer/scheduler yang dimuat di sini.

trial (`optuna.Trial` atau `dict[str, Any]`, *opsional*) : Jalur percobaan atau kamus hiperparameter untuk pencarian hiperparameter.

ignore_keys_for_eval (`list[str]`, *opsional*) : Daftar kunci dalam output model Anda (jika berupa kamus) 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[[trl.KTOTrainer.save_model]]

```python
save_model(output_dir: str | None = None, _internal_call: bool = False)
```

[Sumber](https://github.com/huggingface/trl/blob/v1.18.0/transformers/trainer.py#L4077)

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

Hanya akan menyimpan dari proses utama.

#### push_to_hub[[trl.KTOTrainer.push_to_hub]]

```python
push_to_hub(commit_message: str | None = 'End of training', blocking: bool = True, token: str | None = None, revision: str | None = None, private: bool | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/trl/blob/v1.18.0/transformers/trainer.py#L4337)

**Parameter:**

commit_message (`str`, *opsional*, defaultnya `"End of training"`) : Pesan untuk commit saat push.

blocking (`bool`, *opsional*, defaultnya `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 cabang "main".

private (`bool`, *opsional*) : Apakah membuat repo menjadi privat saat dibuat. Bawaan 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`.

**Mengembalikan:**

URL repositori tempat model didorong jika `blocking=False`, atau objek `Future` yang melacak kemajuan commit jika `blocking=True`.

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

## KTOConfig[[trl.KTOConfig]]

#### trl.KTOConfig[[trl.KTOConfig]]

```python
trl.KTOConfig(output_dir: str | None = None, per_device_train_batch_size: int = 8, num_train_epochs: float = 3.0, max_steps: int = -1, learning_rate: float = 1e-06, lr_scheduler_type: transformers.trainer_utils.SchedulerType | str = 'linear', lr_scheduler_kwargs: dict | str | None = None, warmup_steps: float = 0, optim: transformers.training_args.OptimizerNames | str = 'adamw_torch_fused', optim_args: str | None = None, weight_decay: float = 0.0, adam_beta1: float = 0.9, adam_beta2: float = 0.999, adam_epsilon: float = 1e-08, optim_target_modules: None | str | list[str] = None, gradient_accumulation_steps: int = 1, average_tokens_across_devices: bool = True, max_grad_norm: float = 1.0, label_smoothing_factor: float = 0.0, bf16: bool | None = None, fp16: bool = False, bf16_full_eval: bool = False, fp16_full_eval: bool = False, tf32: bool | None = None, activation_checkpointing: bool | None = None, activation_checkpointing_kwargs: dict[str, typing.Any] | str | None = None, gradient_checkpointing: bool = True, gradient_checkpointing_kwargs: dict[str, typing.Any] | str | None = None, torch_compile: bool = False, torch_compile_backend: str | None = None, torch_compile_mode: str | None = None, use_liger_kernel: bool = False, liger_kernel_config: dict[str, bool] | None = None, use_cache: bool = False, neftune_noise_alpha: float | None = None, torch_empty_cache_steps: int | None = None, auto_find_batch_size: bool = False, logging_strategy: transformers.trainer_utils.IntervalStrategy | str = 'steps', logging_steps: float = 10, logging_first_step: bool = False, log_on_each_node: bool = True, logging_nan_inf_filter: bool = True, include_num_input_tokens_seen: str | bool = 'no', log_level: str = 'passive', log_level_replica: str = 'warning', disable_tqdm: bool | None = None, report_to: None | str | list[str] = 'none', run_name: str | None = None, project: str = 'huggingface', trackio_space_id: str | None = None, trackio_bucket_id: str | None = None, trackio_static_space_id: typing.Union[str, NoneType, typing.Literal[False]] = None, eval_strategy: transformers.trainer_utils.IntervalStrategy | str = 'no', eval_steps: float | None = None, eval_delay: float = 0, per_device_eval_batch_size: int = 8, prediction_loss_only: bool = False, eval_on_start: bool = False, eval_do_concat_batches: bool = True, eval_use_gather_object: bool = False, eval_accumulation_steps: int | None = None, include_for_metrics: list[str] = <factory>, batch_eval_metrics: bool = False, save_only_model: bool = False, save_strategy: transformers.trainer_utils.SaveStrategy | str = 'steps', save_steps: float = 500, save_on_each_node: bool = False, save_total_limit: int | None = None, enable_jit_checkpoint: bool = False, push_to_hub: bool = False, hub_token: str | None = None, hub_private_repo: bool | None = None, hub_model_id: str | None = None, hub_strategy: transformers.trainer_utils.HubStrategy | str = 'every_save', hub_always_push: bool = False, hub_revision: str | None = None, load_best_model_at_end: bool = False, metric_for_best_model: str | None = None, greater_is_better: bool | None = None, ignore_data_skip: bool = False, restore_callback_states_from_checkpoint: bool = False, full_determinism: bool = False, seed: int = 42, data_seed: int | None = None, use_cpu: bool = False, accelerator_config: dict | str | None = None, parallelism_config: accelerate.parallelism_config.ParallelismConfig | None = None, dataloader_drop_last: bool = False, dataloader_num_workers: int = 0, dataloader_pin_memory: bool = True, dataloader_persistent_workers: bool = False, dataloader_prefetch_factor: int | None = None, dataloader_multiprocessing_context: str | None = None, dataloader_in_order: bool = True, remove_unused_columns: bool = True, label_names: list[str] | None = None, train_sampling_strategy: str = 'sequential', length_column_name: str = 'length', ddp_find_unused_parameters: bool | None = None, ddp_bucket_cap_mb: int | None = None, ddp_broadcast_buffers: bool | None = None, ddp_static_graph: bool | None = None, ddp_backend: str | None = None, ddp_timeout: int = 1800, fsdp: str | None = None, fsdp_config: dict[str, typing.Any] | str | None = None, deepspeed: dict | str | None = None, debug: str | list[transformers.debug_utils.DebugOption] = '', skip_memory_metrics: bool = True, do_train: bool = False, do_eval: bool = False, do_predict: bool = False, resume_from_checkpoint: str | None = None, local_rank: int = -1, model_init_kwargs: dict[str, typing.Any] | str | None = None, trust_remote_code: bool = False, router_aux_loss_coef: float | None = None, disable_dropout: bool = True, dataset_num_proc: int | None = None, max_length: int | None = 1024, pad_to_multiple_of: int | str | None = 'auto', precompute_ref_log_probs: bool = False, precompute_ref_batch_size: int | None = None, loss_type: str = 'kto', beta: float = 0.1, desirable_weight: float = 1.0, undesirable_weight: float = 1.0, activation_offloading: bool = False, sync_ref_model: bool = False, ref_model_mixup_alpha: float = 0.6, ref_model_sync_steps: int = 512)
```

[Sumber](https://github.com/huggingface/trl/blob/v1.18.0/trl/trainer/kto_config.py#L22)

**Parameter yang mengontrol model:**

model_init_kwargs (`dict[str, Any]`, *opsional*) : Argumen kata kunci untuk [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoModelForCausalLM.from_pretrained), digunakan ketika argumen `model` dari [KTOTrainer](/docs/trl/v1.18.0/id/kto_trainer#trl.KTOTrainer) diberikan sebagai string. Nilai `revision` juga digunakan saat memuat kelas pemrosesan.

trust_remote_code (`bool`, *opsional*, defaultnya `False`) : Apakah mengizinkan pemuatan model dan tokenizer yang menyertakan kode Python kustom dari Hub. Diteruskan ke [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoModelForCausalLM.from_pretrained) dan [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoProcessor.from_pretrained).

router_aux_loss_coef (`float`, *opsional*) : Koefisien dari loss tambahan load-balancing 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. Akan gagal jika digunakan dengan model non-MoE.

disable_dropout (`bool`, *opsional*, defaultnya `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*, defaultnya `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*, defaultnya `"auto"`) : Jika diatur, 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*, defaultnya `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*, defaultnya `"kto"`) : Jenis loss yang akan digunakan. Nilai yang mungkin adalah:  - `"kto"`: KTO loss dari paper [KTO](https://huggingface.co/papers/2402.01306). - `"apo_zero_unpaired"`: Varian unpaired dari APO-zero loss dari paper [APO](https://huggingface.co/papers/2408.06266).

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*, defaultnya `1.0`) : Kerugian yang diinginkan diberi bobot dengan faktor ini untuk mengimbangi jumlah pasangan yang diinginkan dan tidak diinginkan yang tidak seimbang.

undesirable_weight (`float`, *opsional*, defaultnya `1.0`) : Kerugian yang tidak diinginkan diberi bobot dengan faktor ini untuk mengimbangi jumlah pasangan yang diinginkan dan tidak diinginkan yang tidak seimbang.

activation_offloading (`bool`, *opsional*, defaultnya `False`) : Apakah akan meng-offload aktivasi ke CPU.

sync_ref_model (`bool`, *opsional*, defaultnya `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](https://huggingface.co/papers/2404.09656). `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](https://huggingface.co/papers/2404.09656), 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](/docs/trl/v1.18.0/id/kto_trainer#trl.KTOTrainer).

Kelas ini hanya mencakup parameter yang spesifik untuk pelatihan KTO. Untuk daftar lengkap argumen pelatihan, silakan merujuk ke dokumentasi [TrainingArguments](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.TrainingArguments). Perhatikan bahwa nilai default dalam kelas ini mungkin berbeda dari yang ada di [TrainingArguments](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.TrainingArguments).

Dengan [HfArgumentParser](https://huggingface.co/docs/transformers/v5.23.0/en/internal/trainer_utils#transformers.HfArgumentParser), kita dapat mengubah kelas ini menjadi argumen [argparse](https://docs.python.org/3/library/argparse#module-argparse) yang dapat ditentukan di baris perintah.

> [!NOTE]
> Parameter-parameter ini memiliki nilai default yang berbeda dari [TrainingArguments](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.TrainingArguments): - `logging_steps`: Defaultnya adalah `10`, bukan `500`. - `gradient_checkpointing`: Defaultnya adalah `True`, bukan `False`. - `bf16`: Defaultnya adalah `True` jika `fp16` tidak diatur, bukan `False`. - `learning_rate`: Defaultnya adalah `1e-6`, bukan `5e-5`. - `train_sampling_strategy`: Defaultnya adalah `"sequential"`, 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.

