TRL documentation

Pemodelan Reward

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Pemodelan Reward

model badge

Ikhtisar

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

Metode pasca-pelatihan ini disumbangkan oleh Younes Belkada.

Mulai cepat

Contoh ini menunjukkan cara melatih model reward menggunakan RewardTrainer dari TRL. Kami melatih model Qwen 3 0.6B pada UltraFeedback dataset, dataset preferensi berskala besar, bergranularitas halus, dan beragam.

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 mendukung tipe dataset preference (baik prompt implisit maupun eksplisit). RewardTrainer kompatibel dengan format dataset standar dan conversational. Ketika diberikan dataset conversational, trainer akan secara otomatis menerapkan chat template ke dataset tersebut.

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

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"])))
{
    "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. 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 x adalah urutan input (prompt) dan y+ y^+ dan y− y^- adalah urutan yang dipilih dan ditolak masing-masing. Di bawah model Bradley-Terry (Bradley & Terry, 1952), probabilitas bahwa y+ y^+ lebih disukai daripada y− y^- diberikan fungsi reward r r adalah p(y+≻y−∣x)=σ(r(x,y+)−r(x,y−)) p(y^+ ≻ y^- |x) = \sigma(r(x, y^+)−r(x, y^-)) , di mana σ σ adalah fungsi sigmoid.

Model reward rθ(x,y) r_\theta(x, y) dilatih untuk memberikan skor yang lebih tinggi pada respons yang lebih disukai y+ y^+ dibandingkan dengan respons yang tidak disukai y− y^- . Fungsi kerugian kemudian didefinisikan sebagai negatif log-likelihood dari preferensi yang diamati: L(θ)=−E(x,y+,y−)∼D[log⁡σ(rθ(x,y+)−rθ(x,y−))]. \mathcal{L}(\theta) = - \mathbb{E}_{(x,y^+,y^-) \sim \mathcal{D}} \left[ \log \sigma(r_\theta(x, y^+) - r_\theta(x, y^-)) \right].

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 mengusulkan penambahan suku loss tambahan yang mendorong agar reward terpusat di sekitar nol. Hal ini dikendalikan oleh parameter center_rewards_coefficient dalam 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. Misalnya, jika Anda ingin memuat model dalam presisi yang berbeda, serupa dengan

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.

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.

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 dan teruskan secara langsung ke trainer tanpa mengargumentasikan peft_config.

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

Saat melatih adapter, Anda biasanya menggunakan tingkat pembelajaran yang lebih tinggi (≈1e‑3) karena hanya parameter baru yang dipelajari.

RewardConfig(learning_rate=1e-3, ...)

Pemanggilan Alat dengan Pemodelan Hadiah

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.

RewardTrainer

kelas trl.RewardTrainer

< >

( model: str | PreTrainedModel | PeftModelargs: trl.trainer.reward_config.RewardConfig | 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 | 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)optimizer_cls_and_kwargs: tuple[type[torch.optim.Optimizer], dict[str, typing.Any]] | None = Nonepreprocess_logits_for_metrics: collections.abc.Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = Nonequantization_config: BitsAndBytesConfig | None = Nonepeft_config: PeftConfig | None = None )

Parameter

  • model (str atau PreTrainedModel atau PeftModel) — Model yang akan dilatih. Bisa berupa:
    • String, berupa model id dari model pretrained yang dihosting di dalam model repo di huggingface.co, atau path ke directory yang berisi model weights yang disimpan menggunakan save_pretrained, misalnya './my_model_directory/'. Model dimuat menggunakan 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, di mana (sejak Transformers v5) dtype disimpulkan dari model config.
    • Objek PreTrainedModel untuk klasifikasi sekuens.
    • Objek PeftModel untuk klasifikasi sekuens.
  • args (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. Nilai defaultnya adalah DataCollatorForPreference.
  • train_dataset (Dataset atau IterableDataset) — Dataset yang digunakan untuk pelatihan. Trainer ini mendukung preference jenis (baik prompt implisit maupun eksplisit). Format sampel dapat berupa:
    • Standar: Setiap sampel berisi teks polos.
    • Konversasional: Setiap sampel berisi pesan terstruktur (misalnya, peran dan konten).

    Trainer juga mendukung dataset yang sudah diproses (ditokenisasi) selama mereka berisi field chosen_ids dan rejected_ids.

    Ketika train_dataset adalah IterableDataset (misalnya dataset streaming), max_steps harus diatur dalam argumen pelatihan, karena panjangnya tidak dapat disimpulkan dan jumlah total langkah pelatihan diperlukan untuk membatasi loop pelatihan serta mengonfigurasi penjadwal laju pembelajaran.

  • eval_dataset (Dataset, IterableDataset, DatasetDict, IterableDatasetDict atau dict[str, Dataset | IterableDataset]) — Dataset yang digunakan untuk evaluasi. Dataset ini harus memenuhi persyaratan yang sama dengan train_dataset.
  • processing_class (PreTrainedTokenizerBase, opsional) — Tokenizer yang digunakan untuk memproses data. Jika None, tokenizer dimuat dari nama model dengan from_pretrained. Token padding, processing_class.pad_token, harus diatur. Jika kelas pemrosesan belum mengatur 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 dan mengembalikan kamus dari string ke nilai metrik. Saat meneruskan RewardConfig dengan batch_eval_metrics diset ke True, fungsi compute_metrics Anda harus menerima argumen boolean compute_result. Ini akan dipicu setelah batch evaluasi terakhir untuk menandakan bahwa fungsi perlu menghitung dan mengembalikan statistik ringkasan global, bukan mengakumulasi statistik tingkat batch.
  • callbacks (daftar TrainerCallback, opsional) — Daftar callback untuk menyesuaikan loop pelatihan. Callback ini akan ditambahkan ke daftar callback default yang dijelaskan di sini.

    Jika Anda ingin menghapus salah satu callback default yang digunakan, gunakan metode remove_callback.

  • optimizers (tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None], opsional, defaultnya (None, None)) — Tuple yang berisi optimizer dan scheduler yang akan digunakan. Secara default akan menggunakan instance AdamW pada model Anda dan scheduler yang diberikan oleh get_linear_schedule_with_warmup yang dikendalikan oleh args.
  • optimizer_cls_and_kwargs (tuple[Type[torch.optim.Optimizer], Dict[str, Any]], opsional) — Tuple yang berisi kelas optimizer dan argumen kata kunci yang akan 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 dalam prediksi yang diterima oleh compute_metrics.

    Perhatikan bahwa label (parameter kedua) akan menjadi None jika dataset tidak memilikinya.

  • quantization_config (BitsAndBytesConfig, opsional) — Konfigurasi kuantisasi yang digunakan saat memuat model dari pengidentifikasi model. Gabungkan dengan peft_config untuk pelatihan QLoRA. Diabaikan jika model sudah diinstansiasi, 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 dan mewarisi semua atribut serta metodenya.

Contoh:

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

latih

< >

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

Parameter

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

Mengembalikan

~trainer_utils.TrainOutput

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

Titik masuk utama pelatihan.

save_model

< >

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

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

Hanya akan menyimpan dari proses utama.

push_to_hub

< >

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

Parameter

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

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

RewardConfig

kelas trl.RewardConfig

< >

( output_dir: str | None = Noneper_device_train_batch_size: int = 8num_train_epochs: float = 3.0max_steps: int = -1learning_rate: float = 0.0001lr_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 | None = Nonegradient_checkpointing_kwargs: dict[str, typing.Any] | str | None = Nonetorch_compile: bool = Falsetorch_compile_backend: str | None = Nonetorch_compile_mode: str | None = Noneuse_liger_kernel: bool = Falseliger_kernel_config: dict[str, bool] | None = Noneuse_cache: bool = Falseneftune_noise_alpha: float | None = Nonetorch_empty_cache_steps: int | None = Noneauto_find_batch_size: bool = Falselogging_strategy: transformers.trainer_utils.IntervalStrategy | str = 'steps'logging_steps: float = 10logging_first_step: bool = Falselog_on_each_node: bool = Truelogging_nan_inf_filter: bool = Trueinclude_num_input_tokens_seen: str | bool = 'no'log_level: str = 'passive'log_level_replica: str = 'warning'disable_tqdm: bool | None = Nonereport_to: None | str | list[str] = 'none'run_name: str | None = Noneproject: str = 'huggingface'trackio_space_id: str | None = Nonetrackio_bucket_id: str | None = Nonetrackio_static_space_id: typing.Union[str, NoneType, typing.Literal[False]] = Noneeval_strategy: transformers.trainer_utils.IntervalStrategy | str = 'no'eval_steps: float | None = Noneeval_delay: float = 0per_device_eval_batch_size: int = 8prediction_loss_only: bool = Falseeval_on_start: bool = Falseeval_do_concat_batches: bool = Trueeval_use_gather_object: bool = Falseeval_accumulation_steps: int | None = Noneinclude_for_metrics: list[str] = <factory>batch_eval_metrics: bool = Falsesave_only_model: bool = Falsesave_strategy: transformers.trainer_utils.SaveStrategy | str = 'steps'save_steps: float = 500save_on_each_node: bool = Falsesave_total_limit: int | None = Noneenable_jit_checkpoint: bool = Falsepush_to_hub: bool = Falsehub_token: str | None = Nonehub_private_repo: bool | None = Nonehub_model_id: str | None = Nonehub_strategy: transformers.trainer_utils.HubStrategy | str = 'every_save'hub_always_push: bool = Falsehub_revision: str | None = Noneload_best_model_at_end: bool = Falsemetric_for_best_model: str | None = Nonegreater_is_better: bool | None = Noneignore_data_skip: bool = Falserestore_callback_states_from_checkpoint: bool = Falsefull_determinism: bool = Falseseed: int = 42data_seed: int | None = Noneuse_cpu: bool = Falseaccelerator_config: dict | str | None = Noneparallelism_config: accelerate.parallelism_config.ParallelismConfig | None = Nonedataloader_drop_last: bool = Falsedataloader_num_workers: int = 0dataloader_pin_memory: bool = Truedataloader_persistent_workers: bool = Falsedataloader_prefetch_factor: int | None = Nonedataloader_multiprocessing_context: str | None = Nonedataloader_in_order: bool = Trueremove_unused_columns: bool = Truelabel_names: list[str] | None = Nonetrain_sampling_strategy: str = 'random'length_column_name: str = 'length'ddp_find_unused_parameters: bool | None = Noneddp_bucket_cap_mb: int | None = Noneddp_broadcast_buffers: bool | None = Noneddp_static_graph: bool | None = Noneddp_backend: str | None = Noneddp_timeout: int = 1800fsdp: str | None = Nonefsdp_config: dict[str, typing.Any] | str | None = Nonedeepspeed: dict | str | None = Nonedebug: str | list[transformers.debug_utils.DebugOption] = ''skip_memory_metrics: bool = Truedo_train: bool = Falsedo_eval: bool = Falsedo_predict: bool = Falseresume_from_checkpoint: str | None = Nonelocal_rank: int = -1model_init_kwargs: dict[str, typing.Any] | str | None = Nonetrust_remote_code: bool = Falsechat_template_path: str | None = Nonedisable_dropout: bool = Truedataset_num_proc: int | None = Noneeos_token: str | None = Nonemax_length: int | None = 1024pad_to_multiple_of: int | str | None = 'auto'center_rewards_coefficient: float | None = Noneactivation_offloading: bool = Falsepad_token: str | None = None )

Parameter yang mengontrol model

  • model_init_kwargs (dict[str, Any], opsional) — Argumen kata kunci untuk from_pretrained, digunakan ketika argumen model dari RewardTrainer diberikan sebagai string. Nilai revision juga digunakan saat memuat tokenizer.
  • trust_remote_code (bool, opsional, default False) — Apakah mengizinkan pemuatan model dan tokenizer yang menyertakan kode Python kustom dari Hub. Diteruskan ke from_pretrained dan from_pretrained.
  • 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, default 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, default 1024) — Panjang maksimum dari sekuens yang ditokenisasi. Sampel akan disaring jika sekuens chosen atau rejected melebihi nilai ini. Jika None, penyaringan tidak diterapkan.
  • pad_to_multiple_of (int atau str, opsional, default "auto") — Jika diset, urutan akan di-*pad* menjadi kelipatan dari nilai ini. "auto" melakukan *padding* menjadi kelipatan 128 pada Neuron (AWS Trainium), yang dikompilasi sekali per bentuk input, dan tidak melakukan *padding* di tempat lain.

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, Persamaan 2). Nilai yang direkomendasikan: 0.01.
  • activation_offloading (bool, opsional, default False) — Apakah akan memindahkan aktivasi ke CPU.

Parameter yang tidak didukung lagi

  • pad_token —

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

Kelas konfigurasi untuk RewardTrainer.

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

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

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

  • logging_steps: Bawaan adalah 10 alih-alih 500.
  • gradient_checkpointing: Beralih ke True sebagai nilai bawaan, bukan False.
  • bf16: Beralih ke True jika fp16 tidak diatur, alih-alih False.
  • learning_rate: Bawaan adalah 1e-4 alih-alih 5e-5.
Update on GitHub