TRL documentation

Mô hình hóa phần thưởng

TRL

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v1.17.1).

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Mô hình hóa phần thưởng

Tổng quan

TRL hỗ trợ Trainer cho Outcome-supervised Reward Modeling (ORM) để huấn luyện các mô hình phần thưởng.

Phương pháp hậu huấn luyện này được đóng góp bởi Younes Belkada.

Bắt đầu nhanh

Ví dụ này minh họa cách huấn luyện một mô hình phần thưởng bằng cách sử dụng RewardTrainer từ TRL. Chúng tôi huấn luyện mô hình Qwen 3 0.6B trên UltraFeedback dataset, một bộ dữ liệu quy mô lớn, chi tiết và đa dạng về sở thích.

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

Loại và định dạng bộ dữ liệu mong đợi

RewardTrainer hỗ trợ loại dữ liệu preference (cả prompt ẩn và prompt tường minh). RewardTrainer tương thích với cả định dạng dữ liệu chuẩn và đối thoại. Khi được cung cấp một tập dữ liệu đối thoại, trình huấn luyện sẽ tự động áp dụng mẫu chat lên tập dữ liệu đó.

# 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."}]}

Nếu bộ dữ liệu của bạn không ở một trong các định dạng này, bạn có thể tiền xử lý để chuyển đổi nó sang định dạng mong đợi. Dưới đây là một ví dụ với bộ dữ liệu 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, ..."},
    ],
}

Đi sâu hơn vào phương pháp huấn luyện

Reward Models (RMs) thường được huấn luyện bằng cách học có giám sát trên các bộ dữ liệu chứa các cặp phản hồi được ưu tiên và không được ưu tiên. Mục tiêu là học được một hàm gán điểm cao hơn cho các phản hồi được ưu tiên, cho phép mô hình xếp hạng các đầu ra dựa trên sự ưu tiên.

Phần này phân tích cách mô hình hóa phần thưởng hoạt động trên thực tế, bao gồm các bước chính: xử lý trước và tính toán hàm mất mát.

Tiền xử lý và phân từ

Trong quá trình huấn luyện, mỗi ví dụ được kỳ vọng chứa trường chosen và rejected. Để biết thêm chi tiết về định dạng được kỳ vọng, hãy xem Dataset formats - Preference. RewardTrainer thực hiện tokenization cho mỗi đầu vào bằng cách sử dụng tokenizer của mô hình. Nếu prompt và completion (chosen và rejected) được cung cấp riêng biệt (trường hợp prompt tường minh), chúng sẽ được nối lại với nhau trước khi thực hiện tokenization.

Tính toán tổn thất

Giả sử $x$ là chuỗi đầu vào (prompt) và $y^+$ và $y^-$ lần lượt là chuỗi được chọn và chuỗi bị từ chối. Theo mô hình Bradley-Terry (Bradley & Terry, 1952), xác suất để $y^+$ được ưu tiên hơn $y^-$ với một hàm phần thưởng $r$ là $p(y^+ ≻ y^- |x) = \sigma(r(x, y^+)−r(x, y^-))$ , trong đó $σ$ là hàm sigmoid.

Mô hình phần thưởng $r_\theta(x, y)$ được huấn luyện để gán điểm cao hơn cho các phản hồi được ưu tiên $y^+$ so với các phản hồi không được ưu tiên $y^-$ . Hàm mất mát sau đó được định nghĩa là log-likelihood âm của các sở thích quan sát được: $\mathcal{L}(\theta) = - \mathbb{E}_{(x,y^+,y^-) \sim \mathcal{D}} \left[ \log \sigma(r_\theta(x, y^+) - r_\theta(x, y^-)) \right].$

Mô hình Bradley-Terry là không xác định, nghĩa là việc cộng một hằng số vào tất cả các phần thưởng sẽ không làm thay đổi xác suất ưu tiên. Để giải quyết vấn đề này, Helping or Herding? Reward Model Ensembles Mitigate but do not Eliminate Reward Hacking đề xuất thêm một số hạng tổn thất phụ nhằm khuyến khích các phần thưởng được đặt tâm quanh số 0. Điều này được kiểm soát bởi tham số center_rewards_coefficient trong RewardConfig. Giá trị được khuyến nghị là 1e-2.

Các chỉ số được ghi log

Trong quá trình huấn luyện và đánh giá, chúng ta ghi lại các chỉ số sau:

global_step: Tổng số bước tối ưu hóa đã thực hiện cho đến nay.
epoch: Số epoch hiện tại, dựa trên việc lặp qua tập dữ liệu.
num_tokens: Tổng số token đã được xử lý cho đến hiện tại.
loss: Mất trung bình trong khoảng thời gian ghi log gần nhất.
accuracy: Tỷ lệ các dự đoán chính xác (tức là mô hình gán điểm cao hơn cho phản hồi được chọn so với phản hồi bị từ chối) tính trung bình trên khoảng thời gian ghi log gần nhất.
min_reward: Điểm thưởng tối thiểu được mô hình gán. Giá trị này được tính trung bình trên khoảng thời gian ghi log.
mean_reward: Điểm thưởng trung bình do mô hình gán trong khoảng thời gian ghi log gần nhất.
max_reward: Điểm phần thưởng tối đa do mô hình gán. Giá trị này được tính trung bình trên khoảng thời gian ghi log.
margin: Biên độ trung bình (chênh lệch giữa phần thưởng được chọn và phần thưởng bị từ chối) trong khoảng thời gian ghi log gần nhất.
learning_rate: Tốc độ học hiện tại, có thể thay đổi động nếu sử dụng trình lập lịch.
grad_norm: Chuẩn L2 của các gradient, được tính trước khi cắt gradient.

Tùy chỉnh

Khởi tạo mô hình

Bạn có thể truyền trực tiếp các kwargs của phương thức from_pretrained() vào RewardConfig. Ví dụ, nếu bạn muốn tải một mô hình ở độ chính xác khác, tương tự như

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

Bạn có thể thực hiện điều này bằng cách truyền đối số model_init_kwargs={"dtype": torch.bfloat16} vào RewardConfig.

from trl import RewardConfig

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

Lưu ý rằng tất cả các đối số từ khóa của from_pretrained() đều được hỗ trợ, ngoại trừ num_labels, vốn được đặt tự động thành 1.

Huấn luyện adapter với PEFT

Chúng tôi hỗ trợ tích hợp chặt chẽ với thư viện 🤗 PEFT, cho phép bất kỳ người dùng nào thuận tiện huấn luyện các adapter và chia sẻ chúng trên Hub, thay vì phải huấn luyện toàn bộ mô hình.

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

Bạn cũng có thể tiếp tục huấn luyện PeftModel của mình. Để làm điều đó, trước tiên hãy tải một PeftModel bên ngoài RewardTrainer và truyền nó trực tiếp cho trainer mà không truyền đối số 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()

Khi huấn luyện adapter, bạn thường sử dụng tốc độ học cao hơn (≈1e‑3) vì chỉ có các tham số mới được học.
RewardConfig(learning_rate=1e-3, ...)

Gọi công cụ với Mô hình hóa phần thưởng

RewardTrainer hỗ trợ đầy đủ việc tinh chỉnh mô hình có khả năng tool calling. Trong trường hợp này, mỗi ví dụ trong bộ dữ liệu nên bao gồm:

Các tin nhắn hội thoại, bao gồm các cuộc gọi công cụ (tool_calls) và phản hồi công cụ (tin nhắn có vai trò tool)
Danh sách các công cụ khả dụng trong cột tools, thường được cung cấp dưới dạng schema JSON

Để biết chi tiết về cấu trúc bộ dữ liệu mong đợi, hãy xem phần Định dạng Dataset — Tool Calling.

RewardTrainer

lớp 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 )

Tham số

model (str hoặc PreTrainedModel hoặc PeftModel) — Mô hình cần huấn luyện. Có thể là:
- Một chuỗi, là model id của một model được huấn luyện trước lưu trữ trong một model repo trên huggingface.co, hoặc một đường dẫn đến một thư mục chứa các trọng số model được lưu bằng save_pretrained, ví dụ: './my_model_directory/'. Model được nạp bằng AutoModelForSequenceClassification.from_pretrained với các tham số từ khóa trong args.model_init_kwargs. Nếu dtype không được chỉ định trong args.model_init_kwargs, giá trị mặc định sẽ là float32. Điều này khác với from_pretrained, nơi mà (từ Transformers v5) dtype được suy ra từ cấu hình model.
- Một đối tượng PreTrainedModel phân loại chuỗi.
- Đối tượng PeftModel phân loại chuỗi.
args (RewardConfig, tuỳ chọn) — Cấu hình cho trainer này. Nếu là None, một cấu hình mặc định sẽ được sử dụng.
data_collator (DataCollator, tùy chọn) — Hàm được sử dụng để tạo một batch từ danh sách các phần tử của train_dataset hoặc eval_dataset đã được xử lý. Mặc định sẽ là DataCollatorForPreference.
train_dataset (Dataset hoặc IterableDataset) — Dataset để sử dụng cho huấn luyện. Trainer này hỗ trợ preference loại (cả prompt ẩn và rõ ràng). Định dạng của các mẫu có thể là:
- Chuẩn: Mỗi mẫu chứa văn bản thuần túy.
- Conversational: Mỗi mẫu chứa các tin nhắn có cấu trúc (ví dụ: role và content).
Trainer cũng hỗ trợ các bộ dữ liệu đã xử lý (đã token hóa) miễn là chúng chứa các trường chosen_ids và rejected_ids.

Khi train_dataset là một IterableDataset (ví dụ: một dataset dạng streaming), max_steps phải được cài đặt trong các đối số huấn luyện, vì độ dài của nó không thể suy ra được và tổng số bước huấn luyện là cần thiết để giới hạn vòng lặp huấn luyện và cấu hình trình lập lịch tốc độ học.
eval_dataset (Dataset, IterableDataset, DatasetDict, IterableDatasetDict hoặc dict[str, Dataset | IterableDataset]) — Dataset được sử dụng để đánh giá. Nó phải đáp ứng các yêu cầu tương tự như train_dataset.
processing_class (PreTrainedTokenizerBase, optional) — Tokenizer được sử dụng để xử lý dữ liệu. Nếu None, tokenizer sẽ được tải từ tên của model bằng from_pretrained. Một padding token, processing_class.pad_token, phải được cài đặt. Nếu processing class chưa cài đặt padding token, processing_class.eos_token sẽ được sử dụng làm mặc định.
compute_metrics (Callable[[EvalPrediction], dict], tùy chọn) — Hàm sẽ được sử dụng để tính toán các chỉ số trong quá trình đánh giá. Hàm này phải nhận một EvalPrediction và trả về một từ điển ánh xạ từ chuỗi tên chỉ số đến giá trị của chúng. Khi truyền RewardConfig với batch_eval_metrics được đặt thành True, hàm compute_metrics của bạn phải nhận một tham số boolean compute_result. Tham số này sẽ được kích hoạt sau batch đánh giá cuối cùng để báo hiệu rằng hàm cần tính toán và trả về các thống kê tổng hợp toàn cục thay vì tích lũy các thống kê ở cấp độ batch.
callbacks (danh sách TrainerCallback, tùy chọn) — Danh sách các callback để tùy chỉnh vòng lặp huấn luyện. Những callback này sẽ được thêm vào danh sách các callback mặc định được mô tả chi tiết tại đây.
Nếu bạn muốn xóa một trong các callback mặc định đang được sử dụng, hãy dùng phương thức remove_callback.
optimizers (tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None], tùy chọn, mặc định là (None, None)) — Một tuple chứa optimizer và scheduler cần sử dụng. Mặc định sẽ là một instance của AdamW trên model của bạn và một scheduler được cung cấp bởi get_linear_schedule_with_warmup được điều khiển bởi args.
optimizer_cls_and_kwargs (tuple[Type[torch.optim.Optimizer], Dict[str, Any]], tuỳ chọn) — Một tuple chứa lớp optimizer và các đối số từ khóa cần sử dụng. Ghi đè optim và optim_args trong args. Không tương thích với đối số optimizers .
Khác với optimizers, đối số này giúp tránh việc phải đặt các tham số mô hình lên đúng thiết bị trước khi khởi tạo Trainer.
preprocess_logits_for_metrics (Callable[[torch.Tensor, torch.Tensor], torch.Tensor], tuỳ chọn) — Một hàm tiền xử lý logits ngay trước khi lưu chúng vào bộ nhớ đệm ở mỗi bước đánh giá. Hàm này phải nhận hai tensor, gồm logits và nhãn, và trả về logits sau khi đã xử lý theo mong muốn. Các thay đổi do hàm này thực hiện sẽ được phản ánh trong các dự đoán mà compute_metrics.
Lưu ý rằng nhãn (tham số thứ hai) sẽ là None nếu tập dữ liệu không có chúng.
quantization_config (BitsAndBytesConfig, tuỳ chọn) — Cấu hình lượng tử hóa được sử dụng khi tải mô hình từ một định danh mô hình. Kết hợp với peft_config để huấn luyện QLoRA. Bỏ qua nếu mô hình đã được khởi tạo, hoặc nếu quantization_config cũng được đặt trong args.model_init_kwargs.
peft_config (PeftConfig, tùy chọn) — Cấu hình PEFT được sử dụng để bọc model. Nếu là None, model sẽ không được bọc. Lưu ý rằng nếu model được nạp là một causal LM, rất khuyến nghị đặt modules_to_save=["score"] trong cấu hình PEFT để đảm bảo rằng reward head được huấn luyện đúng cách.

Trainer cho các Mô hình Phần thưởng được giám sát theo Kết quả (ORM).

Lớp này là một lớp bao quanh lớp Trainer và kế thừa tất cả các thuộc tính và phương thức của nó.

Ví dụ:

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

< source >

Tham số

resume_from_checkpoint (str hoặc bool, tùy chọn) — Nếu là str, đường dẫn cục bộ đến một checkpoint đã lưu bởi một phiên Trainer trước đó. Nếu là bool và bằng True, tải checkpoint cuối cùng trong args.output_dir do một phiên Trainer trước đó lưu lại. Nếu có, quá trình huấn luyện sẽ tiếp tục từ trạng thái model/optimizer/scheduler được tải ở đây.
trial (optuna.Trial hoặc dict[str, Any], tùy chọn) — Lần chạy thử nghiệm hoặc từ điển siêu tham số cho việc tìm kiếm siêu tham số.
ignore_keys_for_eval (list[str], tùy chọn) — Một danh sách các khóa trong đầu ra của mô hình của bạn (nếu đó là một từ điển) cần được bỏ qua khi thu thập các dự đoán để đánh giá trong quá trình huấn luyện.

Trả về

~trainer_utils.TrainOutput

Đối tượng chứa số bước toàn cục, tổn thất huấn luyện và các chỉ số.

Điểm vào chính cho quá trình huấn luyện.

save_model

< source >

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

Sẽ lưu mô hình, để bạn có thể tải lại bằng from_pretrained().

Chỉ lưu từ tiến trình chính.

push_to_hub

< source >

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

Tham số

commit_message (str, tùy chọn, mặc định là "End of training") — Thông điệp để commit khi đẩy lên.
blocking (bool, tùy chọn, mặc định là True) — Xác định xem hàm có chỉ trả về khi git push đã hoàn tất hay không.
token (str, tùy chọn, mặc định là None) — Token có quyền ghi để ghi đè lên các args gốc của Trainer.
revision (str, tùy chọn) — Phiên bản git để commit từ. Mặc định là đầu của nhánh “main”.
kwargs (dict[str, Any], tùy chọn) — Các đối số từ khóa bổ sung được truyền đến ~Trainer.create_model_card.

Tải self.model và self.processing_class lên 🤗 model hub tại repo self.args.hub_model_id.

RewardConfig

lớp 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 = Nonegradient_checkpointing: bool = Truegradient_checkpointing_kwargs: dict[str, typing.Any] | str | None = Nonetorch_compile: bool = Falsetorch_compile_backend: str | None = Nonetorch_compile_mode: str | None = Noneuse_liger_kernel: bool = Falseliger_kernel_config: dict[str, bool] | None = Noneuse_cache: bool = Falseneftune_noise_alpha: float | None = Nonetorch_empty_cache_steps: int | None = Noneauto_find_batch_size: bool = Falselogging_strategy: transformers.trainer_utils.IntervalStrategy | str = 'steps'logging_steps: float = 10logging_first_step: bool = Falselog_on_each_node: bool = Truelogging_nan_inf_filter: bool = Trueinclude_num_input_tokens_seen: str | bool = 'no'log_level: str = 'passive'log_level_replica: str = 'warning'disable_tqdm: bool | None = Nonereport_to: None | str | list[str] = 'none'run_name: str | None = Noneproject: str = 'huggingface'trackio_space_id: str | None = Nonetrackio_bucket_id: str | None = Nonetrackio_static_space_id: typing.Union[str, NoneType, typing.Literal[False]] = Noneeval_strategy: transformers.trainer_utils.IntervalStrategy | str = 'no'eval_steps: float | None = Noneeval_delay: float = 0per_device_eval_batch_size: int = 8prediction_loss_only: bool = Falseeval_on_start: bool = Falseeval_do_concat_batches: bool = Trueeval_use_gather_object: bool = Falseeval_accumulation_steps: int | None = Noneinclude_for_metrics: list[str] = <factory>batch_eval_metrics: bool = Falsesave_only_model: bool = Falsesave_strategy: transformers.trainer_utils.SaveStrategy | str = 'steps'save_steps: float = 500save_on_each_node: bool = Falsesave_total_limit: int | None = Noneenable_jit_checkpoint: bool = Falsepush_to_hub: bool = Falsehub_token: str | None = Nonehub_private_repo: bool | None = Nonehub_model_id: str | None = Nonehub_strategy: transformers.trainer_utils.HubStrategy | str = 'every_save'hub_always_push: bool = Falsehub_revision: str | None = Noneload_best_model_at_end: bool = Falsemetric_for_best_model: str | None = Nonegreater_is_better: bool | None = Noneignore_data_skip: bool = Falserestore_callback_states_from_checkpoint: bool = Falsefull_determinism: bool = Falseseed: int = 42data_seed: int | None = Noneuse_cpu: bool = Falseaccelerator_config: dict | str | None = Noneparallelism_config: accelerate.parallelism_config.ParallelismConfig | None = Nonedataloader_drop_last: bool = Falsedataloader_num_workers: int = 0dataloader_pin_memory: bool = Truedataloader_persistent_workers: bool = Falsedataloader_prefetch_factor: int | None = Nonedataloader_multiprocessing_context: str | None = Nonedataloader_in_order: bool = Trueremove_unused_columns: bool = Truelabel_names: list[str] | None = Nonetrain_sampling_strategy: str = '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 )

Các tham số điều khiển mô hình

model_init_kwargs (dict[str, Any], tùy chọn) — Các đối số dạng từ khóa cho from_pretrained, được sử dụng khi đối số model của RewardTrainer được cung cấp dưới dạng chuỗi. Giá trị revision cũng được sử dụng khi tải tokenizer.
trust_remote_code (bool, tùy chọn, mặc định là False) — Có cho phép tải các model và tokenizer có kèm theo mã Python tùy chỉnh từ Hub hay không. Tham số này được chuyển tiếp đến from_pretrained và from_pretrained.
chat_template_path (str, tùy chọn) — Nếu được chỉ định, sẽ đặt chat template của model. Giá trị này có thể là đường dẫn đến một tokenizer (thư mục cục bộ hoặc model trên Hugging Face Hub) hoặc đường dẫn trực tiếp đến một tệp template Jinja. Khi sử dụng tệp Jinja, bạn phải đảm bảo rằng các special token được tham chiếu trong template đã được thêm vào tokenizer và rằng lớp embedding của model được điều chỉnh kích thước cho phù hợp.
disable_dropout (bool, tùy chọn, mặc định là True) — Có vô hiệu hóa dropout trong mô hình hay không.

Các tham số kiểm soát tiền xử lý dữ liệu

dataset_num_proc (int, tùy chọn) — Số lượng tiến trình được sử dụng để xử lý tập dữ liệu.
eos_token (str, tùy chọn) — Token được sử dụng để chỉ báo hiệu kết thúc một lượt hoặc chuỗi. Nếu là None, mặc định sẽ là processing_class.eos_token.
max_length (int hoặc None, tùy chọn, mặc định là 1024) — Độ dài tối đa của chuỗi đã được token hóa. Các mẫu sẽ bị loại bỏ nếu chuỗi được chọn hoặc bị từ chối vượt quá giá trị này. Nếu là None, sẽ không áp dụng bộ lọc nào.
pad_to_multiple_of (int hoặc str, tùy chọn, mặc định là "auto") — Nếu được đặt, các chuỗi sẽ được đệm (padding) đến một bội số của giá trị này. "auto" sẽ đệm đến bội số của 128 trên Neuron (AWS Trainium), nơi biên dịch một lần cho mỗi hình dạng đầu vào, và không đệm ở các nơi khác.

Các tham số kiểm soát quá trình huấn luyện

center_rewards_coefficient (float, tùy chọn) — Hệ số để khuyến khích mô hình phần thưởng xuất ra các phần thưởng có trung bình bằng không (được đề xuất bởi bài báo này, Phương trình 2). Giá trị khuyến nghị: 0.01.
activation_offloading (bool, tùy chọn, mặc định là False) — Có nên chuyển các activation sang CPU hay không.

Các tham số đã bị ngừng hỗ trợ

pad_token —
Tham số pad_token đã bị ngừng hỗ trợ và sẽ bị loại bỏ trong phiên bản v2.0.0. Hãy đặt trực tiếp tokenizer.pad_token và truyền nó dưới dạng processing_class cho trainer thay vì cách cũ.

Lớp cấu hình cho RewardTrainer.

Lớp này chỉ bao gồm các tham số đặc thù cho huấn luyện Reward. Để xem danh sách đầy đủ các đối số huấn luyện, vui lòng tham khảo tài liệu TrainingArguments. Lưu ý rằng các giá trị mặc định trong lớp này có thể khác với các giá trị trong TrainingArguments.

Sử dụng HfArgumentParser, chúng ta có thể chuyển lớp này thành các đối số argparse có thể được chỉ định trên dòng lệnh.

Các tham số này có giá trị mặc định khác với TrainingArguments:

logging_steps: Mặc định là 10 thay vì 500.

gradient_checkpointing: Mặc định là True thay vì False.

bf16: Mặc định là True nếu fp16 không được đặt, thay vì False.

learning_rate: Mặc định là 1e-4 thay vì 5e-5.

Update on GitHub

←KTO RLOO→