# Pemodelan Reward

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

## Ikhtisar

TRL mendukung Trainer untuk Outcome-supervised Reward Modeling (ORM) dalam melatih model reward.

Metode pasca-pelatihan ini disumbangkan oleh [Younes Belkada](https://huggingface.co/ybelkada).

## Mulai cepat

Contoh ini menunjukkan cara melatih model reward menggunakan [RewardTrainer](/docs/trl/v1.18.1/id/reward_trainer#trl.RewardTrainer) dari TRL. Kami melatih model [Qwen 3 0.6B](https://huggingface.co/Qwen/Qwen3-0.6B) pada [UltraFeedback dataset](https://huggingface.co/datasets/trl-lib/ultrafeedback_binarized), dataset preferensi berskala besar, bergranularitas halus, dan beragam.

```python
from trl import RewardTrainer
from datasets import load_dataset

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

## Jenis dan format dataset yang diharapkan

[RewardTrainer](/docs/trl/v1.18.1/id/reward_trainer#trl.RewardTrainer) mendukung tipe dataset [preference](dataset_formats#preference) (baik prompt implisit maupun eksplisit). [RewardTrainer](/docs/trl/v1.18.1/id/reward_trainer#trl.RewardTrainer) kompatibel dengan format dataset [standar](dataset_formats#standard) dan [conversational](dataset_formats#conversational). Ketika diberikan dataset conversational, trainer akan secara otomatis menerapkan chat template ke dataset tersebut.

```python
# Standard preference (implicit prompt)
{"chosen": "The sky is blue.",
 "rejected": "The sky is green."}

# Conversational preference (implicit prompt)
{"chosen": [{"role": "user", "content": "What color is the sky?"},
            {"role": "assistant", "content": "It is blue."}],
 "rejected": [{"role": "user", "content": "What color is the sky?"},
              {"role": "assistant", "content": "It is green."}]}

# Standard preference (explicit prompt)
{"prompt": "The sky is",
 "chosen": " blue.",
 "rejected": " green."}

# Conversational preference (explicit prompt)
{"prompt": [{"role": "user", "content": "What color is the sky?"}],
 "chosen": [{"role": "assistant", "content": "It is blue."}],
 "rejected": [{"role": "assistant", "content": "It is green."}]}
```

Jika dataset Anda tidak dalam salah satu format ini, Anda dapat melakukan pra-pemrosesan untuk mengonversinya ke format yang diharapkan. Berikut adalah contoh dengan dataset [lmarena-ai/arena-human-preference-55k](https://huggingface.co/datasets/lmarena-ai/arena-human-preference-55k):

```python
from datasets import load_dataset
import json

dataset = load_dataset("lmarena-ai/arena-human-preference-55k")

# Filter out ties
dataset = dataset.filter(lambda example: example["winner_tie"] == 0)

# Create 'chosen' and 'rejected' fields based on the winner column
def response_a_b_to_chosen_rejected(example):
    if example["winner_model_a"] == 1:
        example["chosen"] = example["response_a"]
        example["rejected"] = example["response_b"]
    else:
        example["chosen"] = example["response_b"]
        example["rejected"] = example["response_a"]
    return example

dataset = dataset.map(response_a_b_to_chosen_rejected)

# Convert to conversational format
def make_conversation(example):
    prompt = json.loads(example["prompt"])[0]  # '["What color is the sky?"]' -> "What color is the sky?"
    chosen = json.loads(example["chosen"])[0]
    rejected = json.loads(example["rejected"])[0]
    return {
        "chosen": [{"role": "user", "content": prompt}, {"role": "assistant", "content": chosen}],
        "rejected": [{"role": "user", "content": prompt}, {"role": "assistant", "content": rejected}],
    }

dataset = dataset.map(make_conversation)

# Keep only necessary columns
dataset = dataset.select_columns(["chosen", "rejected"])

print(next(iter(dataset["train"])))
```

```json
{
    "chosen": [
        {"role": "user", "content": "Is it morally right to try to have a certain percentage of females on managerial positions?"},
        {"role": "assistant", "content": "The question of whether it is morally right to aim for a certain percentage of females..."},
    ],
    "rejected": [
        {"role": "user", "content": "Is it morally right to try to have a certain percentage of females on managerial positions?"},
        {"role": "assistant", "content": "As an AI, I don't have personal beliefs or opinions. However, ..."},
    ],
}
```

## Menggali lebih dalam ke metode pelatihan

Reward Models (RMs) umumnya dilatih menggunakan pembelajaran terbimbing pada dataset yang berisi pasangan respons yang disukai dan tidak disukai. Tujuannya adalah untuk mempelajari fungsi yang memberikan skor lebih tinggi pada respons yang disukai, sehingga memungkinkan model untuk merangking output berdasarkan preferensi.

Bagian ini menguraikan bagaimana pemodelan reward bekerja dalam praktiknya, mencakup langkah-langkah utama: **pra-pemrosesan** dan **perhitungan loss**.

### Pra-pemrosesan dan tokenisasi

Selama pelatihan, setiap contoh diharapkan berisi bidang **chosen** dan **rejected**. Untuk detail lebih lanjut mengenai format yang diharapkan, lihat [Dataset formats - Preference](dataset_formats#preference). [RewardTrainer](/docs/trl/v1.18.1/id/reward_trainer#trl.RewardTrainer) melakukan tokenisasi setiap input menggunakan tokenizer model. Jika prompt dan completion (chosen dan rejected) diberikan secara terpisah (kasus prompt eksplisit), keduanya digabungkan sebelum tokenisasi.

### Menghitung loss

Misalkan  \\( x \\) adalah urutan input (prompt) dan  \\( y^+ \\) serta  \\( y^- \\) masing-masing adalah urutan yang dipilih dan ditolak. Berdasarkan model Bradley-Terry ([Bradley & Terry, 1952](https://www.jstor.org/stable/2334029)), probabilitas bahwa  \\( y^+ \\) lebih disukai daripada  \\( y^- \\) dengan fungsi reward  \\( r \\) adalah  \\( p(y^+ ≻ y^- |x) = \sigma(r(x, y^+)−r(x, y^-)) \\), di mana  \\( σ \\) adalah fungsi sigmoid.

Model reward \\( r_\theta(x, y) \\) dilatih untuk memberikan skor yang lebih tinggi pada respons yang lebih disukai \\( y^+ \\) dibandingkan dengan respons yang tidak disukai \\( y^- \\). Loss kemudian didefinisikan sebagai negative log-likelihood dari preferensi yang diamati:

$$ \mathcal{L}(\theta) = - \mathbb{E}_{(x,y^+,y^-) \sim \mathcal{D}} \left[ \log \sigma(r_\theta(x, y^+) - r_\theta(x, y^-)) \right]. $$

> [!TIP]
> Model Bradley-Terry bersifat underdetermined, yang berarti menambahkan konstanta pada semua reward tidak mengubah probabilitas preferensi. Untuk mengatasi hal ini, [Helping or Herding? Reward Model Ensembles Mitigate but do not Eliminate Reward Hacking](https://huggingface.co/papers/2312.09244) mengusulkan penambahan suku loss tambahan yang mendorong agar reward terpusat di sekitar nol. Hal ini dikendalikan oleh parameter `center_rewards_coefficient` dalam [RewardConfig](/docs/trl/v1.18.1/id/reward_trainer#trl.RewardConfig). Nilai yang direkomendasikan adalah `1e-2`.

## 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 loss pada interval logging terakhir.
- `accuracy`: Proporsi prediksi yang benar (yaitu, model memberikan skor yang lebih tinggi pada respons yang dipilih daripada pada respons yang ditolak) yang dirata-ratakan selama interval pencatatan terakhir.
- `min_reward`: Skor reward minimum yang diberikan oleh model. Nilai ini dirata-ratakan selama interval pencatatan.
- `mean_reward`: Skor reward rata-rata yang diberikan oleh model selama interval pencatatan terakhir.
- `max_reward`: Skor reward maksimum yang diberikan oleh model. Nilai ini dirata-ratakan selama interval pencatatan.
- `margin`: Margin rata-rata (selisih antara reward yang dipilih dan reward yang ditolak) selama interval pencatatan terakhir.
- `learning_rate`: Laju pembelajaran saat ini, yang dapat berubah secara dinamis jika penjadwal digunakan.
- `grad_norm`: Norm L2 dari gradien, dihitung sebelum pemotongan gradien.

## Kustomisasi

### Inisialisasi model

Anda dapat langsung meneruskan kwargs dari metode `from_pretrained()` ke [RewardConfig](/docs/trl/v1.18.1/id/reward_trainer#trl.RewardConfig). Misalnya, jika Anda ingin memuat model dalam presisi yang berbeda, serupa dengan

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

Anda dapat melakukannya dengan meneruskan argumen `model_init_kwargs={"dtype": torch.bfloat16}` ke [RewardConfig](/docs/trl/v1.18.1/id/reward_trainer#trl.RewardConfig).

```python
from trl import RewardConfig

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

Perhatikan bahwa semua argumen kata kunci dari `from_pretrained()` didukung, kecuali `num_labels`, yang secara otomatis diatur ke 1.

### 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 RewardTrainer
from peft import LoraConfig

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

trainer = RewardTrainer(
    "Qwen/Qwen3-4B",
    train_dataset=dataset,
    peft_config=LoraConfig(modules_to_save=["score"])  # important to include the score head when base model is not a sequence classification model
)

trainer.train()
```

Anda juga dapat melanjutkan pelatihan `PeftModel` Anda. Untuk itu, pertama muat `PeftModel` di luar [RewardTrainer](/docs/trl/v1.18.1/id/reward_trainer#trl.RewardTrainer) dan teruskan secara langsung ke trainer tanpa mengargumentasikan `peft_config`.

```python
from datasets import load_dataset
from trl import RewardTrainer
from peft import AutoPeftModelForCausalLM

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

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

trainer.train()
```

> [!TIP]
> Saat melatih adapter, Anda biasanya menggunakan tingkat pembelajaran yang lebih tinggi (≈1e‑3) karena hanya parameter baru yang dipelajari.
>
> ```python
> RewardConfig(learning_rate=1e-3, ...)
> ```

## Pemanggilan Alat dengan Pemodelan Hadiah

[RewardTrainer](/docs/trl/v1.18.1/id/reward_trainer#trl.RewardTrainer) sepenuhnya mendukung fine-tuning model dengan kemampuan _tool calling_. Dalam hal ini, setiap contoh dataset harus mencakup:

- Pesan percakapan, 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).

## RewardTrainer[[trl.RewardTrainer]]

#### trl.RewardTrainer[[trl.RewardTrainer]]

```python
trl.RewardTrainer(model: str | PreTrainedModel | PeftModel, args: trl.trainer.reward_config.RewardConfig | 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 | 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), optimizer_cls_and_kwargs: tuple[type[torch.optim.Optimizer], dict[str, typing.Any]] | None = None, preprocess_logits_for_metrics: collections.abc.Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = None, quantization_config: BitsAndBytesConfig | None = None, peft_config: PeftConfig | None = None)
```

[Sumber](https://github.com/huggingface/trl/blob/v1.18.1/trl/trainer/reward_trainer.py#L233)

**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 `AutoModelForSequenceClassification.from_pretrained` 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](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) untuk klasifikasi sekuens. - Objek `PeftModel` untuk klasifikasi sekuens.

args ([RewardConfig](/docs/trl/v1.18.1/id/reward_trainer#trl.RewardConfig), *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 menggunakan `DataCollatorForPreference`.

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 [preference](#preference) (baik prompt implisit maupun eksplisit). 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).  Trainer ini juga mendukung dataset yang sudah diproses (tokenized) selama dataset tersebut memuat field `chosen_ids` dan `rejected_ids`.  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), *opsional*) : Tokenizer yang digunakan untuk memproses data. Jika `None`, tokenizer dimuat dari nama model dengan [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoTokenizer.from_pretrained). Token padding, `processing_class.pad_token`, harus disetel. Jika kelas pemrosesan belum menyetel token padding, `processing_class.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 dari string ke nilai metrik. Saat meneruskan [RewardConfig](/docs/trl/v1.18.1/id/reward_trainer#trl.RewardConfig) 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.

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

optimizer_cls_and_kwargs (`tuple[Type[torch.optim.Optimizer], Dict[str, Any]]`, *opsional*) : Tuple yang berisi kelas optimizer dan argumen kata kunci untuk digunakan. Menimpa `optim` dan `optim_args` di `args`. Tidak kompatibel dengan argumen `optimizers`. Berbeda dengan `optimizers`, argumen ini menghindari kebutuhan untuk menempatkan parameter model pada perangkat yang benar sebelum menginisialisasi Trainer.

preprocess_logits_for_metrics (`Callable[[torch.Tensor, torch.Tensor], torch.Tensor]`, *opsional*) : Fungsi yang memproses ulang logits tepat sebelum disimpan ke cache pada setiap langkah evaluasi. Fungsi ini harus menerima dua tensor, yaitu logits dan label, lalu mengembalikan logits setelah diproses sesuai keinginan. Modifikasi yang dilakukan oleh fungsi ini akan tercermin pada prediksi yang diterima oleh `compute_metrics`. Perhatikan bahwa label (parameter kedua) akan bernilai `None` jika dataset tidak memilikinya.

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, atau jika `quantization_config` juga diatur di `args.model_init_kwargs`.

peft_config (`PeftConfig`, *opsional*) : Konfigurasi PEFT yang digunakan untuk membungkus model. Jika `None`, model tidak dibungkus. Perhatikan bahwa jika model yang dimuat adalah causal LM, sangat disarankan untuk mengatur `modules_to_save=["score"]` dalam konfigurasi PEFT untuk memastikan bahwa reward head dilatih dengan benar.

Trainer untuk Model Reward yang Diawasi Hasil (ORM).

Kelas ini adalah pembungkus 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 RewardTrainer
>>> from datasets import load_dataset

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

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

#### train[[trl.RewardTrainer.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.1/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.RewardTrainer.save_model]]

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

[Sumber](https://github.com/huggingface/trl/blob/v1.18.1/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.RewardTrainer.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.1/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`.

## RewardConfig[[trl.RewardConfig]]

#### trl.RewardConfig[[trl.RewardConfig]]

```python
trl.RewardConfig(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 = 0.0001, 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 | None = None, 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 = 'random', 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, chat_template_path: str | None = None, disable_dropout: bool = True, dataset_num_proc: int | None = None, eos_token: str | None = None, max_length: int | None = 1024, pad_to_multiple_of: int | str | None = 'auto', center_rewards_coefficient: float | None = None, activation_offloading: bool = False, pad_token: str | None = None)
```

[Sumber](https://github.com/huggingface/trl/blob/v1.18.1/trl/trainer/reward_config.py#L23)

**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.AutoModelForSequenceClassification.from_pretrained), digunakan ketika argumen `model` dari [RewardTrainer](/docs/trl/v1.18.1/id/reward_trainer#trl.RewardTrainer) diberikan sebagai string. Nilai `revision` juga digunakan saat memuat tokenizer.

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.AutoModelForSequenceClassification.from_pretrained) dan [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoTokenizer.from_pretrained).

chat_template_path (`str`, *opsional*) : Jika ditentukan, mengatur template chat model. Ini bisa berupa path ke tokenizer (direktori lokal atau model Hugging Face Hub) atau path langsung ke file template Jinja. Saat menggunakan file Jinja, Anda harus memastikan bahwa token khusus yang dirujuk dalam template ditambahkan ke tokenizer dan bahwa lapisan embedding model di-resize sesuai.

disable_dropout (`bool`, *opsional*, defaultnya `True`) : Apakah akan menonaktifkan dropout pada model.

**Parameter yang mengontrol pra-pemrosesan data:**

dataset_num_proc (`int`, *opsional*) : Jumlah proses yang digunakan untuk memproses dataset.

eos_token (`str`, *opsional*) : Token yang digunakan untuk menandakan akhir giliran atau urutan. Jika `None`, nilainya secara default adalah `processing_class.eos_token`.

max_length (`int` atau `None`, *opsional*, defaultnya `1024`) : Panjang maksimum dari urutan yang ditokenisasi. Sampel akan disaring jika urutan yang dipilih atau ditolak melebihi nilai ini. Jika `None`, penyaringan 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.

**Parameter yang mengontrol pelatihan:**

center_rewards_coefficient (`float`, *opsional*) : Koefisien untuk mendorong model reward agar menghasilkan reward dengan rata-rata nol (diajukan oleh [makalah ini](https://huggingface.co/papers/2312.09244), Persamaan 2). Nilai yang direkomendasikan: `0.01`.

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

**Parameter yang tidak didukung lagi:**

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

Kelas konfigurasi untuk [RewardTrainer](/docs/trl/v1.18.1/id/reward_trainer#trl.RewardTrainer).

Kelas ini hanya mencakup parameter yang spesifik untuk pelatihan Reward. 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 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` alih-alih `500`. - `gradient_checkpointing`: Defaultnya adalah `True` alih-alih `False`. - `bf16`: Defaultnya adalah `True` jika `fp16` tidak diatur, alih-alih `False`. - `learning_rate`: Defaultnya adalah `1e-4` alih-alih `5e-5`.

