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

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

## 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](https://huggingface.co/ybelkada).

## 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](/docs/trl/v1.18.2/vi/reward_trainer#trl.RewardTrainer) từ TRL. Chúng tôi huấn luyện mô hình [Qwen 3 0.6B](https://huggingface.co/Qwen/Qwen3-0.6B) trên [UltraFeedback dataset](https://huggingface.co/datasets/trl-lib/ultrafeedback_binarized), một bộ dữ liệu quy mô lớn, chi tiết và đa dạng về sở thích.

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

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

[RewardTrainer](/docs/trl/v1.18.2/vi/reward_trainer#trl.RewardTrainer) hỗ trợ loại dữ liệu [preference](dataset_formats#preference) (cả prompt ẩn và prompt tường minh). [RewardTrainer](/docs/trl/v1.18.2/vi/reward_trainer#trl.RewardTrainer) tương thích với cả định dạng dữ liệu [chuẩn](dataset_formats#standard) và [đối thoại](dataset_formats#conversational). 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 đó.

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

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](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, ..."},
    ],
}
```

## Đ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](dataset_formats#preference). [RewardTrainer](/docs/trl/v1.18.2/vi/reward_trainer#trl.RewardTrainer) sẽ tokenize mỗi đầu vào bằ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 rõ ràng), chúng sẽ được nối lại với nhau trước khi tokenize.

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

Giả sử \\( x \\) là chuỗi đầu vào (prompt) và \\( y^+ \\) cùng \\( 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](https://www.jstor.org/stable/2334029)), xác suất để \\( y^+ \\) được ưu tiên hơn \\( y^- \\) khi có 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 ưa thích \\( y^+ \\) so với các phản hồi không được ưa thích \\( 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]. $$

> [!TIP]
> 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](https://huggingface.co/papers/2312.09244) đề 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](/docs/trl/v1.18.2/vi/reward_trainer#trl.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](/docs/trl/v1.18.2/vi/reward_trainer#trl.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ư

```python
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](/docs/trl/v1.18.2/vi/reward_trainer#trl.RewardConfig).

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

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

Bạn cũng có thể tiếp tục huấn luyện [PeftModel](https://huggingface.co/docs/peft/v0.22.0/en/package_reference/peft_model#peft.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](/docs/trl/v1.18.2/vi/reward_trainer#trl.RewardTrainer) và truyền nó trực tiếp cho trainer mà không truyền đối số `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]
> 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.
>
> ```python
> RewardConfig(learning_rate=1e-3, ...)
> ```

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

[RewardTrainer](/docs/trl/v1.18.2/vi/reward_trainer#trl.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](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)
```

[Nguồn](https://github.com/huggingface/trl/blob/v1.18.2/trl/trainer/reward_trainer.py#L233)

**Tham số:**

model (`str` hoặc [PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel) hoặc [PeftModel](https://huggingface.co/docs/peft/v0.22.0/en/package_reference/peft_model#peft.PeftModel)) : Mô hình cần được huấn luyện. Có thể là:  - Một chuỗi, là *model id* của một mô hình được huấn luyện trước lưu trữ trong kho mô hình trên huggingface.co, hoặc một đường dẫn đến *thư mục* chứa trọng số mô hình được lưu bằng [save_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel.save_pretrained), ví dụ: `'./my_model_directory/'`. Mô hình được nạp bằng `AutoModelForSequenceClassification.from_pretrained` với các đối 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](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel.from_pretrained), nơi mà (từ Transformers v5) dtype được suy ra từ cấu hình mô hình. - Một đối tượng [PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel) cho phân loại chuỗi. - Một đối tượng [PeftModel](https://huggingface.co/docs/peft/v0.22.0/en/package_reference/peft_model#peft.PeftModel) cho phân loại chuỗi.

args ([RewardConfig](/docs/trl/v1.18.2/vi/reward_trainer#trl.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](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset) hoặc [IterableDataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.IterableDataset)) : Dataset để sử dụng cho huấn luyện. Trainer này hỗ trợ loại [preference](#preference) (cả prompt ẩn và prompt tường minh). Định dạng của các mẫu có thể là:  - [Standard](dataset_formats#standard): Mỗi mẫu chứa văn bản thuần. - [Conversational](dataset_formats#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 dataset đã được xử lý (tokenized) miễn là chúng chứa các trường `chosen_ids` và `rejected_ids`.  Khi `train_dataset` là một [IterableDataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.IterableDataset) (ví dụ: một dataset streaming), `max_steps` phải được đặt trong các đối số huấn luyện, vì độ dài của nó không thể suy ra được và cần biết tổng số bước huấn luyện để 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](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) hoặc `dict[str, Dataset | IterableDataset]`) : Dataset để sử dụng cho đánh giá. Nó phải đáp ứng các yêu cầu tương tự như `train_dataset`.

processing_class ([PreTrainedTokenizerBase](https://huggingface.co/docs/transformers/v5.23.0/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase), *optional*) : Tokenizer được sử dụng để xử lý dữ liệu. Nếu là `None`, tokenizer sẽ được tải từ tên của model bằng [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoTokenizer.from_pretrained). Phải đặt một padding token, `processing_class.pad_token`. Nếu processing class chưa đặt padding token, `processing_class.eos_token` sẽ được 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ố đánh giá. Hàm này phải nhận một [EvalPrediction](https://huggingface.co/docs/transformers/v5.23.0/en/internal/trainer_utils#transformers.EvalPrediction) và trả về một từ điển ánh xạ từ chuỗi sang giá trị chỉ số. Khi truyền [RewardConfig](/docs/trl/v1.18.2/vi/reward_trainer#trl.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 đối số boolean `compute_result`. Đối số này sẽ được kích hoạt sau lô đá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 độ lô.

callbacks (danh sách [TrainerCallback](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/callback#transformers.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](https://huggingface.co/docs/transformers/main_classes/callback). 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](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]`, *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](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/optimizer_schedules#transformers.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]]`, *tùy 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]`, *tùy 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 đã được 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` nhận được. Lưu ý rằng nhãn (tham số thứ hai) sẽ là `None` nếu tập dữ liệu không có nhãn.

quantization_config ([BitsAndBytesConfig](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/quantization#transformers.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](https://huggingface.co/docs/peft/v0.22.0/en/package_reference/config#peft.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](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.Trainer) và kế thừa tất cả các thuộc tính và phương thức của nó.

Ví dụ:

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

[Nguồn](https://github.com/huggingface/trl/blob/v1.18.2/transformers/trainer.py#L1450)

**Tham số:**

resume_from_checkpoint (`str` hoặc `bool`, *tùy chọn*) : Nếu là `str`, đường dẫn cục bộ đến checkpoint đã lưu bởi một phiên `Trainer` trước đó. Nếu là `bool` và bằng `True`, nạp 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 nạp tại đây.

trial (`optuna.Trial` hoặc `dict[str, Any]`, *tùy chọ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 nó 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[[trl.RewardTrainer.save_model]]

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

[Nguồn](https://github.com/huggingface/trl/blob/v1.18.2/transformers/trainer.py#L4077)

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[[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)
```

[Nguồn](https://github.com/huggingface/trl/blob/v1.18.2/transformers/trainer.py#L4337)

**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ó nên 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 đối số gốc của Trainer.

revision (`str`, *tùy chọn*) : Bản sửa git để commit từ. Mặc định là đầu của nhánh "main".

private (`bool`, *tùy chọn*) : Xác định xem có làm cho kho riêng tư khi nó được tạo hay không. Mặc định là `args.hub_private_repo`. Không có hiệu lực nếu kho đã tồn tại.

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

**Trả về:**

URL của kho lưu trữ nơi mô hình đã được đẩy lên nếu `blocking=False`, hoặc một đối tượng `Future` theo dõi tiến trình của lệnh commit nếu `blocking=True`.

Tải `self.model` và `self.processing_class` lên 🤗 model hub tại 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)
```

[Nguồn](https://github.com/huggingface/trl/blob/v1.18.2/trl/trainer/reward_config.py#L23)

**Các tham số kiểm soát mô hình:**

model_init_kwargs (`dict[str, Any]`, *tùy chọn*) : Các đối số từ khóa cho [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoModelForSequenceClassification.from_pretrained), được sử dụng khi đối số `model` của [RewardTrainer](/docs/trl/v1.18.2/vi/reward_trainer#trl.RewardTrainer) được cung cấp dưới dạng chuỗi. Giá trị `revision` cũng được sử dụng khi nạp tokenizer.

trust_remote_code (`bool`, *tuỳ chọn*, mặc định là `False`) : 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](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoModelForSequenceClassification.from_pretrained) và [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoTokenizer.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 token đặc biệt đượ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`) : Xác định 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 để sử dụng cho việc xử lý bộ dữ liệu.

eos_token (`str`, *tùy chọn*) : Token dùng để chỉ báo hiệu kết thúc một lượt hoặc một chuỗi. Nếu là `None`, giá trị 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`, *tuỳ 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](https://huggingface.co/papers/2312.09244), 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ó offload các activations 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](/docs/trl/v1.18.2/vi/reward_trainer#trl.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](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.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](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.TrainingArguments).

Sử dụng [HfArgumentParser](https://huggingface.co/docs/transformers/v5.23.0/en/internal/trainer_utils#transformers.HfArgumentParser), chúng ta có thể chuyển lớp này thành các đối số [argparse](https://docs.python.org/3/library/argparse#module-argparse) có thể được chỉ định trên dòng lệnh.

> [!NOTE]
> Các tham số này có giá trị mặc định khác với [TrainingArguments](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.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`.

