TRL documentation
Pemodelan Reward
Pemodelan Reward
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 adalah urutan input (prompt) dan dan adalah urutan yang dipilih dan ditolak masing-masing. Di bawah model Bradley-Terry (Bradley & Terry, 1952), probabilitas bahwa lebih disukai daripada diberikan fungsi reward adalah , di mana adalah fungsi sigmoid.
Model reward dilatih untuk memberikan skor yang lebih tinggi pada respons yang lebih disukai dibandingkan dengan respons yang tidak disukai . Fungsi kerugian kemudian didefinisikan sebagai negatif log-likelihood dari preferensi yang diamati:
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_coefficientdalam RewardConfig. Nilai yang direkomendasikan adalah1e-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 perantool) - Daftar alat yang tersedia di kolom
tools, biasanya disediakan sebagai skema JSON
Untuk detail mengenai struktur dataset yang diharapkan, lihat bagian Dataset Format — Tool Calling.
RewardTrainer
kelas trl.RewardTrainer
< source >( 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 (
stratau PreTrainedModel atauPeftModel) — Model yang akan dilatih. Bisa berupa:- String, berupa model id dari model pretrained yang dihosting di dalam model repo di huggingface.co, atau
path ke directory yang berisi model weights yang disimpan menggunakan
save_pretrained, misalnya
'./my_model_directory/'. Model dimuat menggunakanAutoModelForSequenceClassification.from_pretraineddengan keyword arguments diargs.model_init_kwargs. Jikadtypetidak ditentukan diargs.model_init_kwargs, default-nya adalahfloat32. Ini berbeda dari from_pretrained, di mana (sejak Transformers v5) dtype disimpulkan dari model config. - Objek PreTrainedModel untuk klasifikasi sekuens.
- Objek
PeftModeluntuk klasifikasi sekuens.
- 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
- 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 elementrain_datasetataueval_datasetyang telah diproses. Nilai defaultnya adalahDataCollatorForPreference. - 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_idsdanrejected_ids.Ketika
train_datasetadalah IterableDataset (misalnya dataset streaming),max_stepsharus diatur dalam argumen pelatihan, karena panjangnya tidak dapat disimpulkan dan jumlah total langkah pelatihan diperlukan untuk membatasi loop pelatihan serta mengonfigurasi penjadwal laju pembelajaran. - eval_dataset (Dataset, IterableDataset, DatasetDict, IterableDatasetDict atau
dict[str, Dataset | IterableDataset]) — Dataset yang digunakan untuk evaluasi. Dataset ini harus memenuhi persyaratan yang sama dengantrain_dataset. - processing_class (PreTrainedTokenizerBase, 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_tokenakan digunakan sebagai default. - compute_metrics (
Callable[[EvalPrediction], dict], opsional) — Fungsi yang akan digunakan untuk menghitung metrik saat evaluasi. Harus menerima EvalPrediction dan mengembalikan kamus dari string ke nilai metrik. Saat meneruskan RewardConfig denganbatch_eval_metricsdiset keTrue, fungsicompute_metricsAnda harus menerima argumen booleancompute_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 instanceAdamWpada model Anda dan scheduler yang diberikan oleh get_linear_schedule_with_warmup yang dikendalikan olehargs. - 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. Menimpaoptimdanoptim_argsdiargs. Tidak kompatibel dengan argumenoptimizers.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 olehcompute_metrics.Perhatikan bahwa label (parameter kedua) akan menjadi
Nonejika dataset tidak memilikinya. - quantization_config (BitsAndBytesConfig, opsional) —
Konfigurasi kuantisasi yang digunakan saat memuat model dari pengidentifikasi model. Gabungkan dengan
peft_configuntuk pelatihan QLoRA. Diabaikan jika model sudah diinstansiasi, atau jikaquantization_configjuga diatur diargs.model_init_kwargs. - peft_config (
PeftConfig, opsional) — Konfigurasi PEFT yang digunakan untuk membungkus model. JikaNone, model tidak dibungkus. Perhatikan bahwa jika model yang dimuat adalah causal LM, sangat disarankan untuk mengaturmodules_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
< source >( resume_from_checkpoint: str | bool | None = Nonetrial: optuna.Trial | dict[str, Any] | None = Noneignore_keys_for_eval: list[str] | None = None ) → ~trainer_utils.TrainOutput
Parameter
- resume_from_checkpoint (
strataubool, opsional) — Jika berupastr, jalur lokal ke checkpoint yang disimpan oleh instanceTrainersebelumnya. Jika berupabooldan bernilaiTrue, muat checkpoint terakhir di args.output_dir yang disimpan oleh instanceTrainersebelumnya. Jika ada, pelatihan akan dilanjutkan dari status model/optimizer/scheduler yang dimuat di sini. - trial (
optuna.Trialataudict[str, Any], opsional) — Jalankan trial atau kamus hiperparameter untuk pencarian hiperparameter. - ignore_keys_for_eval (
list[str], opsional) — Daftar kunci dalam output model Anda (jika berupa dictionary) yang harus diabaikan saat mengumpulkan prediksi untuk evaluasi selama pelatihan.
Mengembalikan
~trainer_utils.TrainOutput
Objek yang berisi jumlah langkah global, kerugian pelatihan, dan metrik.
Titik masuk utama pelatihan.
Akan menyimpan model, sehingga Anda dapat memuatnya kembali menggunakan from_pretrained().
Hanya akan menyimpan dari proses utama.
push_to_hub
< source >( commit_message: str | None = 'End of training'blocking: bool = Truetoken: str | None = Nonerevision: str | None = Noneprivate: bool | None = None**kwargs )
Parameter
- commit_message (
str, opsional, default"End of training") — Pesan untuk commit saat melakukan push. - blocking (
bool, opsional, defaultTrue) — Apakah fungsi harus hanya mengembalikan nilai setelahgit pushselesai. - token (
str, opsional, defaultnyaNone) — Token dengan izin tulis untuk menimpa argumen asli Trainer. - revision (
str, opsional) — Revisi git untuk di-commit. Secara default menggunakan head dari branch “main”. - private (
bool, opsional) — Apakah membuat repo menjadi privat saat dibuat. Defaultnya adalahargs.hub_private_repo. Tidak berpengaruh jika repo sudah ada. - kwargs (
dict[str, Any], opsional) — Argumen kata kunci tambahan yang diteruskan ke~Trainer.create_model_card.
Unggah self.model dan self.processing_class ke 🤗 model hub di repo self.args.hub_model_id.
RewardConfig
kelas trl.RewardConfig
< source >( 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 argumenmodeldari RewardTrainer diberikan sebagai string. Nilairevisionjuga digunakan saat memuat tokenizer. - trust_remote_code (
bool, opsional, defaultFalse) — Apakah mengizinkan pemuatan model dan tokenizer yang menyertakan kode Python kustom dari Hub. Diteruskan ke from_pretrained dan from_pretrained. - 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, defaultTrue) — 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. JikaNone, nilainya secara default adalahprocessing_class.eos_token. - max_length (
intatauNone, opsional, default1024) — Panjang maksimum dari sekuens yang ditokenisasi. Sampel akan disaring jika sekuens chosen atau rejected melebihi nilai ini. JikaNone, penyaringan tidak diterapkan. - pad_to_multiple_of (
intataustr, opsional, default"auto") — Jika diset, urutan akan di-*pad* menjadi kelipatan dari nilai ini."auto"melakukan *padding* menjadi kelipatan 128 pada Neuron (AWS Trainium), yang dikompilasi sekali per bentuk input, dan tidak melakukan *padding* di tempat lain.
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, defaultFalse) — Apakah akan memindahkan aktivasi ke CPU.
Parameter yang tidak didukung lagi
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 adalah10alih-alih500.gradient_checkpointing: Beralih keTruesebagai nilai bawaan, bukanFalse.bf16: Beralih keTruejikafp16tidak diatur, alih-alihFalse.learning_rate: Bawaan adalah1e-4alih-alih5e-5.