# Trainer RLOO

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

## Tổng quan

TRL hỗ trợ RLOO Trainer để huấn luyện các mô hình ngôn ngữ, như được mô tả trong bài báo [Back to Basics: Revisiting REINFORCE Style Optimization for Learning from Human Feedback in LLMs](https://huggingface.co/papers/2402.14740) của [Arash Ahmadian](https://huggingface.co/ArashAhmadian), Chris Cremer, [Matthias Gallé](https://huggingface.co/mgalle), [Marzieh Fadaee](https://huggingface.co/MarziehFadaee), [Julia Kreutzer](https://huggingface.co/JuliaKreutzerCohere), [Ahmet Üstün](https://huggingface.co/ahmetu) và [Sara Hooker](https://huggingface.co/sarahooker).

Tóm tắt từ bài báo như sau:

> Việc căn chỉnh AI dưới hình thức Học tăng cường từ phản hồi của con người (Reinforcement Learning from Human Feedback - RLHF) ngày càng được coi là một thành phần thiết yếu cho các mô hình ngôn ngữ lớn có hiệu suất cao. Tối ưu hóa chính sách gần (Proximal Policy Optimization - PPO) đã được các tài liệu gần đây xác định là phương pháp chuẩn cho phần RL của RLHF. Tuy nhiên, phương pháp này liên quan đến cả chi phí tính toán cao và việc tinh chỉnh siêu tham số nhạy cảm. Chúng tôi cho rằng hầu hết các nguyên tắc động lực dẫn đến sự phát triển của PPO ít là mối lo ngại thực tế trong RLHF và ủng hộ một phương pháp ít tốn kém tính toán hơn, đồng thời duy trì và thậm chí tăng hiệu suất. Chúng tôi xem xét lại cách thức biểu diễn việc căn chỉnh từ sở thích của con người trong bối cảnh RL. Giữ sự đơn giản làm nguyên tắc chỉ đạo, chúng tôi chỉ ra rằng nhiều thành phần của PPO là không cần thiết trong bối cảnh RLHF và rằng các biến thể tối ưu hóa theo phong cách REINFORCE đơn giản hơn nhiều vượt trội hơn cả PPO và các phương pháp “không RL” mới được đề xuất như DPO và RAFT. Công việc của chúng tôi cho thấy việc thích ứng cẩn thận với các đặc điểm căn chỉnh của LLM cho phép tận dụng tối ưu hóa RL trực tuyến với chi phí thấp.

Phương pháp hậu huấn luyện này được đóng góp bởi [Costa Huang](https://github.com/vwxyzjn) và sau đó được tái cấu trúc bởi [Shirin Yamani](https://huggingface.co/ShirinYamani).

## Bắt đầu nhanh

Ví dụ này minh họa cách huấn luyện một mô hình bằng phương pháp RLOO. Chúng ta huấn luyện [mô hình Qwen 0.5B Instruct](https://huggingface.co/Qwen/Qwen2-0.5B-Instruct) với các prompt từ [dataset DeepMath-103K](https://huggingface.co/datasets/trl-lib/DeepMath-103K). Bạn có thể xem dữ liệu trong dataset tại đây:

<iframe src="https://huggingface.co/datasets/trl-lib/DeepMath-103K/embed/viewer/default/train?row=0" frameborder="0" width="100%" height="560px"
>

Dưới đây là script để huấn luyện mô hình. `accuracy_reward` cần math-verify, bạn có thể cài đặt bằng `pip install trl[math_verify]`.

```python
# train_rloo.py
from datasets import load_dataset
from trl import RLOOTrainer
from trl.rewards import accuracy_reward

dataset = load_dataset("trl-lib/DeepMath-103K", split="train")

trainer = RLOOTrainer(
    model="Qwen/Qwen2-0.5B-Instruct",
    reward_funcs=accuracy_reward,
    train_dataset=dataset,
)
trainer.train()
```

Chạy script bằng lệnh sau:

```bash
torchrun --nproc_per_node 8 train_rloo.py
```

## Tìm hiểu sâu hơn về phương pháp RLOO

RLOO là một thuật toán học trực tuyến, nghĩa là nó được cải thiện theo từng lần lặp bằng cách sử dụng dữ liệu do chính mô hình đã được huấn luyện tạo ra trong quá trình huấn luyện. Trực giác đằng sau mục tiêu của RLOO là tối đa hóa lợi thế của các phần hoàn thành được tạo ra, đồng thời đảm bảo rằng mô hình vẫn ở gần chính sách tham chiếu. Để hiểu cách RLOO hoạt động, nó có thể được chia thành bốn bước chính: **tạo các phần hoàn thành**, **tính toán lợi thế**, **ước lượng phân kỳ KL** và **tính toán tổn thất**.

![RLOO](https://huggingface.co/datasets/trl-lib/documentation-images/resolve/main/rloo.png)

### Tạo các câu trả lời hoàn chỉnh

Tại mỗi bước huấn luyện, chúng ta lấy mẫu một lô prompt và tạo ra một tập hợp gồm \\( G \\) phần hoàn thành cho mỗi prompt (ký hiệu là \\( o_i \\)).

### Tính phần thưởng

Trong RLOO, phần thưởng bao gồm hai thành phần: phần thưởng do mô hình phần thưởng (hoặc hàm phần thưởng) cung cấp và một hình phạt KL nhằm ngăn chặn chính sách lệch quá xa so với một chính sách tham chiếu cố định

1. Với mỗi trong số các chuỗi  \\( G \\) được tạo ra  \\( o_i = (o_{i,1}, \dots, o_{i,T}) \\) có điều kiện dựa trên truy vấn  \\( q \\), chúng ta tính một phần thưởng vô hướng bằng cách sử dụng mô hình phần thưởng  \\( R(o_i, q) \\).
2. Đồng thời, chúng ta ước lượng độ phân kỳ KL giữa chính sách hiện tại \\( \pi_\theta \\) và chính sách tham chiếu cố định \\( \pi_{\text{ref}} \\) trên toàn bộ chuỗi. Ước lượng KL cho chuỗi \\( o_i \\) là:

$$ \mathbb{D}_{\mathrm{KL}}\!\left[\pi_\theta\|\pi_{\mathrm{ref}}\right] = \sum_{t=1}^T \log \frac{\pi_\theta(o_{i,t} \mid q, o_{i,<t})}{\pi_{\mathrm{ref}}(o_{i,t} \mid q, o_{i,<t})}. $$

Phần thưởng cuối cùng được gán cho chuỗi \\( o_i \\) là:

$$ r_i = R(o_i, q) - \beta \, \mathbb{D}_{\mathrm{KL}}\!\left[\pi_\theta \|\pi_{\mathrm{ref}}\right], $$

trong đó \\( \beta > 0 \\) kiểm soát cường độ của hình phạt KL.

> [!TIP]
> Trong cài đặt hoàn toàn trực tuyến (`num_iterations = 1`, mặc định), dữ liệu được tạo ra bởi chính sách hiện tại. Trong trường hợp này, hình phạt KL được tính trực tiếp bằng chính sách hiện tại.
>
> Trong bối cảnh tổng quát hơn (ví dụ, nhiều bước gradient trên mỗi batch), dữ liệu thay vào đó được tạo ra bởi một bản sao trước đó \\( \pi_{\text{old}} \\). Để giữ cho hình phạt nhất quán với phân phối lấy mẫu, KL được định nghĩa theo chính sách này:
>
> \\( \mathbb{D}_{\mathrm{KL}}\!\left[\pi_{\text{old}} \,\|\, \pi_{\text{ref}}\right]. \\)
>
> Tương đương, với một chuỗi được lấy mẫu \\( o \\), ước lượng Monte Carlo là:
>
> \\( \mathbb{D}_{\mathrm{KL}}\!\left[\pi_{\text{old}} \|\pi_{\mathrm{ref}}\right] = \sum_{t=1}^T \log \frac{\pi_{\text{old}}(o_{i,t} \mid q, o_{i,<t})}{\pi_{\mathrm{ref}}(o_{i,t} \mid q, o_{i,<t})}. \\)

### Tính toán lợi thế

Sau khi phần thưởng cho mỗi kết quả hoàn thành đã được tính toán, chúng ta tính một đường cơ sở (baseline) là phần thưởng trung bình của tất cả các mẫu khác trong cùng một lô (batch), loại trừ mẫu hiện tại. Đường cơ sở này được sử dụng để giảm phương sai của ước lượng gradient chính sách. Lợi thế (advantage) cho mỗi kết quả hoàn thành sau đó được xác định bằng hiệu giữa phần thưởng của chính nó và đường cơ sở leave-one-out này.

Về mặt hình thức, đối với một lô gồm G hoàn thành, đường cơ sở cho hoàn thành là: $$ b_i = \frac{1}{G-1} \sum_{j \neq i} r_j $$

sau đó lợi thế cho mỗi kết quả hoàn thành được tính là hiệu giữa phần thưởng của nó và giá trị cơ sở:

$$
A_i = r_i - b_i
$$

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

Mất REINFORCE đơn giản được định nghĩa là:

$$ \mathcal{L}_{\text{RLOO}}(\theta) = - \frac{1}{G} \sum_{i=1}^G \hat{A}_i \, \log \pi_\theta(o_i \mid q) $$

Trong thực tế, thực hiện nhiều bước gradient trên cùng một batch khiến các hành động trở nên off-policy so với các tham số hiện tại. Để khắc phục điều này, chúng tôi đưa vào tỷ lệ importance sampling. Để ngăn chặn các cập nhật quá lớn khi chính sách thay đổi giữa bước lấy mẫu và bước gradient, chúng tôi cắt (clip) tỷ lệ này:

$$ \mathcal{L}_{\text{RLOO}}(\theta) = - \frac{1}{G} \sum_{i=1}^G \min \left( \frac{\pi_\theta(o_i \mid q)}{\pi_{\theta_\text{old}}(o_i \mid q)} \hat{A}_i, \, \text{clip}\left(\frac{\pi_\theta(o_i \mid q)}{\pi_{\theta_\text{old}}(o_i \mid q)}, 1-\epsilon, 1+\epsilon\right) \hat{A}_i \right) $$

Trong cài đặt trực tuyến hoàn toàn, một bước (mặc định), \\( \frac{\pi_\theta(o_i \mid q)}{\pi_{\theta_\text{old}}(o_i \mid q)} = 1 \\) và điều này rút gọn về REINFORCE tiêu chuẩn.

> [!NOTE]
> Khác với GRPO, RLOO không truyền ngược gradient qua số hạng KL. Ở đây, KL chỉ được dùng thuần túy để định hình phần thưởng: nó được tính dưới `no_grad` và được gộp vào phần thưởng vô hướng \\( r_i \\), trở thành lợi thế đã tách rời \\( \hat{A}_i \\).
>
> Nói cách khác, con đường duy nhất mà gradient đi vào chính sách là hạng tử tỷ lệ quan trọng \\( \frac{\pi_\theta(o_i \mid q)}{\pi_{\theta_\text{old}}(o_i \mid q)} \\), và hạng tử KL không được backpropagate vào chính sách.
>
> Ngược lại, [GRPO](grpo_trainer) thêm một số hạng KL rõ ràng, có thể tính đạo hàm vào hàm mục tiêu, được tính toán trực tiếp với chính sách hiện tại \\( \pi_\theta \\), do đó gradient của nó chảy qua cả số hạng tỷ lệ lẫn hình phạt KL.

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

- `num_tokens`: Tổng số token đã được xử lý cho đến nay, bao gồm cả prompt và completion.
- `step_time`: Thời gian trung bình (tính bằng giây) cho mỗi bước huấn luyện (bao gồm cả quá trình sinh).
- `completions/mean_length`: Độ dài trung bình của các câu trả lời được tạo ra.
- `completions/min_length`: Độ dài tối thiểu của các phần hoàn thành được tạo ra.
- `completions/max_length`: Độ dài tối đa của các phần hoàn thành được tạo ra.
- `completions/mean_terminated_length`: Độ dài trung bình của các phần hoàn thành được tạo ra kết thúc bằng EOS.
- `completions/min_terminated_length`: Độ dài tối thiểu của các phần hoàn thành được tạo ra kết thúc bằng EOS.
- `completions/max_terminated_length`: Độ dài tối đa của các phần hoàn thành được tạo ra kết thúc bằng EOS.
- `completions/clipped_ratio`: Tỷ lệ các câu trả lời bị cắt (clipped).
- `rewards/{reward_func_name}/mean`: Phần thưởng trung bình từ một hàm phần thưởng cụ thể.
- `rewards/{reward_func_name}/std`: Độ lệch chuẩn của phần thưởng từ một hàm phần thưởng cụ thể.
- `reward`: Phần thưởng trung bình tổng thể sau khi cộng phần thưởng giữa các hàm (được trọng số hóa bởi `reward_weights`).
- `reward_std`: Độ lệch chuẩn của phần thưởng tổng hợp trên các hàm (được trọng số hóa bởi `reward_weights`), được tính trên toàn bộ lô.
- `frac_reward_zero_std`: Tỷ lệ các mẫu trong lô sinh có độ lệch chuẩn phần thưởng bằng 0, cho thấy mức độ đa dạng thấp cho prompt đó (tất cả các câu trả lời đều đúng hoặc đều sai).
- `entropy`: Entropy trung bình của các dự đoán token trên các chuỗi hoàn thành được tạo ra. (Nếu `mask_truncated_completions=True`, các token của các chuỗi bị mask sẽ được loại trừ.)
- `aux_loss`: Tổn phụ trợ cân bằng tải của mô hình Mixture-of-Experts, trước khi được nhân với `router_aux_loss_coef` và cộng vào tổn. Chỉ được ghi log khi mô hình là mô hình MoE và `router_aux_loss_coef` khác không.
- `kl`: Trung bình của độ phân kỳ KL giữa mô hình và mô hình tham chiếu, được tính trên các phần hoàn thành đã tạo. Chỉ được ghi log nếu `beta` khác không.
- `clip_ratio/region_mean`: Tỷ lệ các xác suất chuỗi mà mục tiêu RLOO bị cắt (clip) để giữ trong vùng tin cậy:  \\( \text{clip}\left( r_{i}(\theta), 1 - \epsilon_\mathrm{low}, 1 + \epsilon_\mathrm{high} \right)\,, \quad r_{i}(\theta) = \frac{\pi_\theta(o_{i} \mid q)}{\pi_{\theta_{\text{old}}}(o_{i} \mid q)} \\). Giá trị cao hơn có nghĩa là nhiều mẫu bị cắt hơn, điều này hạn chế mức độ thay đổi của chính sách $\pi_\theta$.
- `clip_ratio/low_mean`: Tỷ lệ trung bình của xác suất chuỗi bị cắt ở cận dưới của vùng tin cậy: \\(r_{i,t}(\theta) < 1 - \epsilon_\mathrm{low}\\).
- `clip_ratio/low_min`: Chỉ báo clip nhỏ nhất cho mỗi phần hoàn thành tại cận dưới của vùng tin cậy: \\(r_{i,t}(\theta) < 1 - \epsilon_\mathrm{low}\\).
- `clip_ratio/high_mean`: Tỷ lệ trung bình của xác suất chuỗi bị cắt ở cận trên của vùng tin cậy: \\(r_{i,t}(\theta) > 1 + \epsilon_\mathrm{high}\\).
- `clip_ratio/high_max`: Chỉ báo clip trên mỗi completion lớn nhất tại cận trên của vùng tin cậy: \\(r_{i,t}(\theta) > 1 + \epsilon_\mathrm{high}\\).

## Tùy chỉnh

### Tăng tốc huấn luyện với sinh nội dung do vLLM hỗ trợ

Việc tạo sinh (generation) thường là nút thắt cổ chai chính khi huấn luyện bằng các phương pháp trực tuyến. Để tăng tốc quá trình tạo sinh, bạn có thể sử dụng [vLLM](https://github.com/vllm-project/vllm), một bộ máy suy luận (inference engine) có thông lượng cao và độ trễ thấp dành cho LLM. Để bật tính năng này, trước tiên hãy cài đặt gói bằng

```shell
pip install trl[vllm]
```

Chúng tôi hỗ trợ hai cách sử dụng vLLM trong quá trình huấn luyện: **chế độ máy chủ** và **chế độ colocate**.

#### Tùy chọn 1: Chế độ Colocate

Trong chế độ này, vLLM chạy bên trong tiến trình trainer và chia sẻ bộ nhớ GPU với mô hình huấn luyện. Điều này giúp tránh việc khởi động một server riêng và có thể cải thiện mức sử dụng GPU, nhưng có thể dẫn đến tranh chấp bộ nhớ trên các GPU huấn luyện. Đây là chế độ mặc định.

```python
from trl import RLOOConfig

training_args = RLOOConfig(
    ...,
    use_vllm=True,  # vllm_mode="colocate" by default
)
```

#### Tùy chọn 2: Chế độ máy chủ

Trong chế độ này, vLLM chạy trong một tiến trình riêng (và sử dụng các GPU riêng) và giao tiếp với trainer qua HTTP. Đây là lựa chọn lý tưởng nếu bạn có các GPU dành riêng cho suy luận.

1. **Khởi động máy chủ vLLM**:

   ```bash
   VLLM_SERVER_DEV_MODE=1 vllm serve <model_name> \
       --weight-transfer-config '{"backend": "nccl"}' \
       --logprobs-mode processed_logprobs \
       --max-logprobs -1
   ```

2. **Bật chế độ máy chủ trong script huấn luyện của bạn**:

   ```python
   from trl import RLOOConfig

   training_args = RLOOConfig(
       ...,
       use_vllm=True,
       vllm_mode="server",
   )
   ```

> [!WARNING]
> Hãy đảm bảo rằng server đang sử dụng các GPU khác với trainer, nếu không bạn có thể gặp lỗi NCCL. Bạn có thể chỉ định các GPU cần sử dụng bằng biến môi trường `CUDA_VISIBLE_DEVICES`.

> [!TIP]
> Tùy thuộc vào kích thước mô hình và yêu cầu bộ nhớ GPU tổng thể cho việc huấn luyện, bạn có thể cần điều chỉnh tham số `vllm_gpu_memory_utilization` trong [RLOOConfig](/docs/trl/v1.18.2/vi/rloo_trainer#trl.RLOOConfig) để tránh tình trạng khai thác không đủ hoặc lỗi hết bộ nhớ.
>
> Chúng tôi cung cấp một [HF Space](https://huggingface.co/spaces/trl-lib/recommend-vllm-memory) để giúp ước lượng mức sử dụng bộ nhớ GPU được khuyến nghị dựa trên cấu hình mô hình và cài đặt thí nghiệm của bạn. Chỉ cần sử dụng nó như sau để nhận khuyến nghị `vllm_gpu_memory_utilization`:
>
> 
>
> Nếu giá trị khuyến nghị không hoạt động trong môi trường của bạn, chúng tôi đề xuất thêm một bộ đệm nhỏ (ví dụ: +0.05 hoặc +0.1) vào giá trị khuyến nghị để đảm bảo tính ổn định.
>
> Nếu bạn vẫn gặp lỗi hết bộ nhớ, hãy đặt `vllm_enable_sleep_mode` thành True và các tham số cũng như bộ nhớ đệm của vllm sẽ được chuyển ra ngoài trong bước tối ưu hóa. Để biết thêm thông tin, xem [Giảm mức sử dụng bộ nhớ với vLLM Sleep Mode](reducing_memory_usage#vllm-sleep-mode).

> [!TIP]
> Mặc định, RLOO sử dụng `MASTER_ADDR=localhost` và `MASTER_PORT=12345` cho vLLM, nhưng bạn có thể ghi đè các giá trị này bằng cách đặt các biến môi trường tương ứng.

Để biết thêm thông tin, hãy xem [Tăng tốc huấn luyện với vLLM](speeding_up_training#vllm-for-fast-generation-in-online-methods).

### RLOO ở quy mô lớn: huấn luyện Mô hình 70B+ trên nhiều nút

Khi huấn luyện các mô hình lớn như **Qwen2.5-72B**, bạn cần một số tối ưu hóa chính để đảm bảo quá trình huấn luyện hiệu quả và có khả năng mở rộng trên nhiều GPU và node. Những tối ưu hóa này bao gồm:

- **DeepSpeed ZeRO Stage 3**: ZeRO tận dụng song song hóa dữ liệu để phân phối trạng thái mô hình (trọng số, gradient, trạng thái optimizer) trên nhiều GPU và CPU, giảm thiểu yêu cầu về bộ nhớ và tính toán trên mỗi thiết bị. Vì các mô hình lớn không thể chứa vừa trên một GPU duy nhất, việc sử dụng ZeRO Stage 3 là bắt buộc để huấn luyện các mô hình như vậy. Để biết thêm chi tiết, xem [DeepSpeed Integration](deepspeed_integration).
- **torchrun**: trình khởi chạy của PyTorch sẽ khởi tạo một tiến trình cho mỗi GPU trên mọi nút và kết nối chúng thông qua một điểm hội tụ chung. Để biết thêm chi tiết, hãy xem [Phân phối huấn luyện](distributing_training).
- **vLLM**: Xem phần trước để biết cách sử dụng vLLM để tăng tốc độ sinh.

Dưới đây là một ví dụ về script SLURM để huấn luyện một mô hình 70B với RLOO trên nhiều nút. Script này huấn luyện mô hình trên 4 nút và sử dụng nút thứ 5 cho việc tạo sinh được hỗ trợ bởi vLLM.

```sh
#!/bin/bash
#SBATCH --nodes=5
#SBATCH --gres=gpu:8

# Get the list of allocated nodes
NODELIST=($(scontrol show hostnames $SLURM_JOB_NODELIST))

# Assign the first 4 nodes for training and the 5th node for vLLM
TRAIN_NODES="${NODELIST[@]:0:4}"  # Nodes 0, 1, 2, 3 for training
VLLM_NODE="${NODELIST[4]}"  # Node 4 for vLLM

# Run training on the first 4 nodes (Group 1)
srun --nodes=4 --ntasks=4 --nodelist="${NODELIST[@]:0:4}" torchrun \
     --nnodes 4 \
     --nproc_per_node 8 \
     --node_rank $SLURM_PROCID \
     --rdzv_backend c10d \
     --rdzv_endpoint ${NODELIST[0]}:29500 \
     train_rloo.py \
     --server_ip $VLLM_NODE &

# Run vLLM server on the 5th node (Group 2)
srun --nodes=1 --ntasks=1 --nodelist="${NODELIST[4]}" env VLLM_SERVER_DEV_MODE=1 vllm serve Qwen/Qwen2.5-72B --tensor-parallel-size 8 \
    --weight-transfer-config '{"backend": "nccl"}' \
    --logprobs-mode processed_logprobs \
    --max-logprobs -1 &

wait
```

```python
import argparse

from datasets import load_dataset
from trl import RLOOTrainer, RLOOConfig

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--vllm_server_host", type=str, default="", help="The server IP")
    args = parser.parse_args()

    # Example dataset from TLDR
    dataset = load_dataset("trl-lib/tldr", split="train")

    # Dummy reward function: count the number of unique characters in the completions
    def reward_num_unique_chars(completions, **kwargs):
        return [len(set(c)) for c in completions]

    training_args = RLOOConfig(
        output_dir="Qwen2.5-72B-RLOO",
        per_device_train_batch_size=4,
        bf16=True,
        deepspeed="examples/deepspeed_configs/zero3.json",
        use_vllm=True,
        vllm_mode="server",
        vllm_server_host=args.vllm_server_host.replace("ip-", "").replace("-", "."),  # from ip-X-X-X-X to X.X.X.X
    )

    trainer = RLOOTrainer(model="Qwen/Qwen2.5-72B", args=training_args, reward_funcs=reward_num_unique_chars, train_dataset=dataset)
    trainer.train()

if __name__=="__main__":
    main()
```

### Sử dụng hàm phần thưởng tùy chỉnh

[RLOOTrainer](/docs/trl/v1.18.2/vi/rloo_trainer#trl.RLOOTrainer) hỗ trợ sử dụng các hàm phần thưởng tùy chỉnh thay vì các mô hình phần thưởng dày đặc. Để đảm bảo tính tương thích, hàm phần thưởng của bạn phải đáp ứng các yêu cầu sau:

Các hàm reward có thể là các callable Python đồng bộ hoặc các coroutine `async def` bất đồng bộ. Khi bạn cung cấp nhiều hàm reward bất đồng bộ, chúng sẽ được chờ đồng thời (chạy song song thông qua `asyncio.gather`) để độ trễ của chúng chồng lên nhau.

1. **Các đối số đầu vào**:
   - Hàm phải nhận các đối số sau dưới dạng đối số từ khóa:
     - `prompts` (chứa các prompts),
     - `completions` (chứa các phần hoàn thành đã tạo),
     - `completion_ids` (chứa các completion đã được token hóa),
     - `trainer_state` ([TrainerState](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/callback#transformers.TrainerState)): Trạng thái hiện tại của trainer. Có thể sử dụng để triển khai các hàm phần thưởng động, chẳng hạn như curriculum learning, trong đó phần thưởng được điều chỉnh dựa trên tiến độ huấn luyện.
     - `log_extra`: một callable `log_extra(column: str, values: list)` để thêm các cột bổ sung vào bảng completions. Xem Ví dụ 6.
     - `log_metric`: một hàm có thể gọi `log_metric(name: str, value: float)` để ghi log các chỉ số vô hướng dưới dạng biểu đồ bên cạnh `kl`, `entropy`, v.v. Xem Ví dụ 6.
     - Tất cả tên cột (ngoại trừ `prompt`) mà bộ dữ liệu có thể có. Ví dụ, nếu bộ dữ liệu chứa một cột có tên `ground_truth`, hàm sẽ được gọi với `ground_truth` như một đối số từ khóa.

     Cách dễ nhất để đáp ứng yêu cầu này là sử dụng `**kwargs` trong chữ ký hàm.
   - Tùy thuộc vào định dạng bộ dữ liệu, đầu vào sẽ khác nhau:
     - Đối với [định dạng chuẩn](dataset_formats#standard), `prompts` và `completions` sẽ là các danh sách chuỗi.
     - Đối với [định dạng hội thoại](dataset_formats#conversational), `prompts` và `completions` sẽ là các danh sách từ điển tin nhắn.

2. **Giá trị trả về**: Hàm phải trả về một danh sách các số float. Mỗi số float đại diện cho phần thưởng tương ứng với một kết quả hoàn thành duy nhất.

#### Ví dụ 1: Phần thưởng cho các câu trả lời dài hơn

Dưới đây là một ví dụ về hàm phần thưởng cho định dạng chuẩn, phần thưởng cho các câu trả lời dài hơn:

```python
def reward_func(completion_ids, **kwargs):
    """Reward function that assigns higher scores to longer completions (in terms of token count)."""
    return [float(len(ids)) for ids in completion_ids]
```

Bạn có thể kiểm tra nó như sau:

```python
>>> prompts = ["The sky is", "The sun is"]  # not used in the reward function, but the trainer will pass it
>>> completions = [" blue.", " in the sky."]  # not used in the reward function, but the trainer will pass it
>>> completion_ids = [[6303, 13], [304, 279, 12884, 13]]
>>> reward_func(prompts=prompts, completions=completions, completion_ids=completion_ids)
[2.0, 4.0]
```

#### Ví dụ 1.1: Thưởng cho các phần hoàn thành dài hơn (dựa trên số ký tự)

Tương tự như ví dụ trước, nhưng lần này hàm phần thưởng được dựa trên số lượng ký tự thay vì token.

```python
def reward_func(completions, **kwargs):
    """Reward function that assigns higher scores to longer completions (in terms of character count)."""
    return [float(len(completion)) for completion in completions]
```

Bạn có thể kiểm tra nó như sau:

```python
>>> prompts = ["The sky is", "The sun is"]
>>> completions = [" blue.", " in the sky."]
>>> completion_ids = [[6303, 13], [304, 279, 12884, 13]]  # not used in the reward function, but the trainer will pass it
>>> reward_func(prompts=prompts, completions=completions, completion_ids=completion_ids)
[6.0, 12.0]
```

#### Ví dụ 2: Thưởng cho các phần hoàn thành có định dạng cụ thể

Dưới đây là một ví dụ về hàm phần thưởng kiểm tra xem phần hoàn thành có đúng định dạng cụ thể hay không. Ví dụ này được lấy cảm hứng từ hàm _phần thưởng định dạng_ được sử dụng trong bài báo [DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning](https://huggingface.co/papers/2501.12948). Nó được thiết kế cho định dạng hội thoại, trong đó các prompt và phần hoàn thành bao gồm các tin nhắn có cấu trúc.

```python
import re

def format_reward_func(completions, **kwargs):
    """Reward function that checks if the completion has a specific format."""
    pattern = r"^<think>.*?</think><answer>.*?</answer>$"
    completion_contents = [completion[0]["content"] for completion in completions]
    matches = [re.match(pattern, content) for content in completion_contents]
    return [1.0 if match else 0.0 for match in matches]
```

Bạn có thể kiểm tra hàm này như sau:

```python
>>> prompts = [
...     [{"role": "user", "content": "What is the result of (1 + 2) * 4?"}],
...     [{"role": "user", "content": "What is the result of (3 + 1) * 2?"}],
... ]
>>> completions = [
...     [{"role": "assistant", "content": "<think>The sum of 1 and 2 is 3, which we multiply by 4 to get 12.</think><answer>(1 + 2) * 4 = 12</answer>"}],
...     [{"role": "assistant", "content": "The sum of 3 and 1 is 4, which we multiply by 2 to get 8. So (3 + 1) * 2 = 8."}],
... ]
>>> format_reward_func(prompts=prompts, completions=completions)
[1.0, 0.0]
```

#### Ví dụ 3: Hoàn thành phần thưởng dựa trên một tham chiếu

Dưới đây là một ví dụ về hàm phần thưởng kiểm tra xem câu trả liệu có chính xác hay không. Ví dụ này được lấy cảm hứng từ hàm _phần thưởng độ chính xác_ được sử dụng trong bài báo [DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning](https://huggingface.co/papers/2501.12948). Ví dụ này được thiết kế cho [định dạng chuẩn](dataset_formats#standard), trong đó tập dữ liệu chứa một cột có tên là `ground_truth`.

```python
import re

def reward_func(completions, ground_truth, **kwargs):
    # Regular expression to capture content inside \boxed{}
    matches = [re.search(r"\\boxed\{(.*?)\}", completion) for completion in completions]
    contents = [match.group(1) if match else "" for match in matches]
    # Reward 1 if the content is the same as the ground truth, 0 otherwise
    return [1.0 if c == gt else 0.0 for c, gt in zip(contents, ground_truth)]
```

Bạn có thể kiểm tra hàm này như sau:

```python
>>> prompts = ["Problem: Solve the equation $2x + 3 = 7$. Solution:", "Problem: Solve the equation $3x - 5 = 10$."]
>>> completions = [r" The solution is \boxed{2}.", r" The solution is \boxed{6}."]
>>> ground_truth = ["2", "5"]
>>> reward_func(prompts=prompts, completions=completions, ground_truth=ground_truth)
[1.0, 0.0]
```

#### Ví dụ 4: Các hàm phần thưởng đa nhiệm

Dưới đây là một ví dụ về việc sử dụng nhiều hàm phần thưởng trong [RLOOTrainer](/docs/trl/v1.18.2/vi/rloo_trainer#trl.RLOOTrainer). Trong ví dụ này, chúng ta định nghĩa hai hàm phần thưởng dành riêng cho từng tác vụ: `math_reward_func` và `coding_reward_func`. Hàm `math_reward_func` cấp phần thưởng cho các bài toán dựa trên tính chính xác của chúng, trong khi `coding_reward_func` cấp phần thưởng cho các bài toán lập trình dựa trên việc giải pháp có chạy được hay không.

```python
from datasets import Dataset
from trl import RLOOTrainer

# Define a dataset that contains both math and coding problems
dataset = Dataset.from_list(
    [
        {"prompt": "What is 2+2?", "task": "math"},
        {"prompt": "Write a function that returns the sum of two numbers.", "task": "code"},
        {"prompt": "What is 3*4?", "task": "math"},
        {"prompt": "Write a function that returns the product of two numbers.", "task": "code"},
    ]
)

# Math-specific reward function
def math_reward_func(prompts, completions, task, **kwargs):
    rewards = []
    for prompt, completion, t in zip(prompts, completions, task):
        if t == "math":
            # Calculate math-specific reward
            correct = check_math_solution(prompt, completion)
            reward = 1.0 if correct else -1.0
            rewards.append(reward)
        else:
            # Return None for non-math tasks
            rewards.append(None)
    return rewards

# Coding-specific reward function
def coding_reward_func(prompts, completions, task, **kwargs):
    rewards = []
    for prompt, completion, t in zip(prompts, completions, task):
        if t == "code":
            # Calculate coding-specific reward
            works = test_code_solution(prompt, completion)
            reward = 1.0 if works else -1.0
            rewards.append(reward)
        else:
            # Return None for non-coding tasks
            rewards.append(None)
    return rewards

# Use both task-specific reward functions
trainer = RLOOTrainer(
    model="Qwen/Qwen2-0.5B-Instruct",
    reward_funcs=[math_reward_func, coding_reward_func],
    train_dataset=dataset,
)

trainer.train()
```

Trong ví dụ này, `math_reward_func` và `coding_reward_func` được thiết kế để hoạt động với một tập dữ liệu hỗn hợp chứa cả các bài toán toán học và lập trình. Cột `task` trong tập dữ liệu được dùng để xác định hàm thưởng nào sẽ được áp dụng cho từng bài toán. Nếu không có hàm thưởng phù hợp cho một mẫu trong tập dữ liệu, hàm thưởng sẽ trả về `None`, và [RLOOTrainer](/docs/trl/v1.18.2/vi/rloo_trainer#trl.RLOOTrainer) sẽ tiếp tục với các hàm và tác vụ hợp lệ. Điều này cho phép [RLOOTrainer](/docs/trl/v1.18.2/vi/rloo_trainer#trl.RLOOTrainer) xử lý nhiều hàm thưởng với phạm vi áp dụng khác nhau.

Lưu ý rằng [RLOOTrainer](/docs/trl/v1.18.2/vi/rloo_trainer#trl.RLOOTrainer) sẽ bỏ qua các phần thưởng `None` được trả về bởi các hàm phần thưởng và chỉ xem xét các phần thưởng được trả về bởi các hàm liên quan. Điều này đảm bảo rằng mô hình được huấn luyện trên các tác vụ liên quan và bỏ qua các tác vụ không có hàm phần thưởng liên quan.

#### Ví dụ 5: Các hàm phần thưởng bất đồng bộ

Các hàm phần thưởng tùy chỉnh cũng có thể được định nghĩa dưới dạng coroutine `async def`. Điều này hữu ích nếu phần thưởng của bạn phụ thuộc vào I/O chậm (ví dụ: gọi một dịch vụ từ xa). Khi bạn truyền nhiều hàm phần thưởng async, [RLOOTrainer](/docs/trl/v1.18.2/vi/rloo_trainer#trl.RLOOTrainer) sẽ thực thi chúng đồng thời để độ trễ của chúng chồng lên nhau.

Dưới đây là một ví dụ tối giản về một hàm thưởng bất đồng bộ mô phỏng một thao tác bị giới hạn bởi I/O:

```python
import asyncio

async def async_reward_func(prompts, completions, **kwargs):
    # Simulate an I/O-bound call (e.g., HTTP request, database lookup)
    await asyncio.sleep(0.01)
    # Simple toy reward: 1.0 if the completion is non-empty, else 0.0
    return [1.0 if completion else 0.0 for completion in completions]
```

#### Ví dụ 6: Ghi log các cột và chỉ số bổ sung

Dưới đây là một ví dụ về hàm phần thưởng ghi log các cột bổ sung vào bảng completions và các chỉ số vô hướng dưới dạng biểu đồ.

```python
import re

def reward_func(completions, ground_truth, log_extra=None, log_metric=None, **kwargs):
    extracted = [re.search(r"\\boxed\{(.*?)\}", c) for c in completions]
    extracted = [m.group(1) if m else None for m in extracted]
    rewards = [1.0 if e == gt else 0.0 for e, gt in zip(extracted, ground_truth)]

    if log_extra:
        log_extra("golden_answer", list(ground_truth))
        log_extra("extracted_answer", [e or "[none]" for e in extracted])

    if log_metric:
        log_metric("accuracy", sum(rewards) / len(rewards))

    return rewards
```

#### Truyền hàm phần thưởng cho trình huấn luyện

Để sử dụng hàm phần thưởng tùy chỉnh của bạn, hãy truyền nó vào [RLOOTrainer](/docs/trl/v1.18.2/vi/rloo_trainer#trl.RLOOTrainer) như sau:

```python
from trl import RLOOTrainer

trainer = RLOOTrainer(
    reward_funcs=reward_func,
    ...,
)
```

Bạn có thể truyền nhiều hàm phần thưởng dưới dạng một danh sách; danh sách này có thể bao gồm cả các hàm đồng bộ và bất đồng bộ:

```python
from trl import RLOOTrainer

trainer = RLOOTrainer(
    reward_funcs=[reward_func, async_reward_func1, async_reward_func2],
    ...,
)
```

và phần thưởng sẽ được tính là tổng các phần thưởng từ mỗi hàm, hoặc tổng có trọng số nếu `reward_weights` được cung cấp trong cấu hình.

Lưu ý rằng [RLOOTrainer](/docs/trl/v1.18.2/vi/rloo_trainer#trl.RLOOTrainer) hỗ trợ nhiều hàm phần thưởng có các kiểu khác nhau. Xem tài liệu tham số để biết thêm chi tiết.

## Huấn luyện Mô hình Ngôn ngữ Thị giác

RLOO hỗ trợ huấn luyện các Mô hình Ngôn ngữ - Thị giác (VLM) trên các bộ dữ liệu đa phương thức chứa cả văn bản và hình ảnh.

### Các Mô hình Được hỗ trợ

Đã kiểm tra với:

- **Gemma3** — ví dụ: `google/gemma-3-4b-it`
- **LLaVA-NeXT** — ví dụ: `llava-hf/llava-v1.6-mistral-7b-hf`
- **Qwen2-VL** — ví dụ: `Qwen/Qwen2-VL-2B-Instruct`
- **Qwen2.5-VL** — ví dụ: `Qwen/Qwen2.5-VL-3B-Instruct`
- **SmolVLM2** — ví dụ: `HuggingFaceTB/SmolVLM2-2.2B-Instruct`

> [!TIP]
> Không đảm bảo tương thích với tất cả các VLM. Nếu bạn cho rằng một model nên được hỗ trợ, hãy mở một issue trên GitHub — hoặc tốt hơn nữa, gửi một pull request kèm theo các thay đổi cần thiết.

### Bắt đầu nhanh

Sử dụng [rloo\_vlm.py](https://github.com/huggingface/trl/blob/main/examples/rloo_visual_math/rloo_visual_math.py) để tinh chỉnh một VLM. Lệnh ví dụ để huấn luyện trên [`lmms-lab/multimodal-open-r1-8k-verified`](https://huggingface.co/datasets/lmms-lab/multimodal-open-r1-8k-verified):

```bash
torchrun --nproc_per_node 8 examples/rloo_visual_math/rloo_visual_math.py \
  --deepspeed examples/deepspeed_configs/zero3.json \
  --model_name_or_path Qwen/Qwen2.5-VL-3B-Instruct \
  --output_dir rloo-Qwen2.5-VL-3B-Instruct \
  --learning_rate 1e-5 \
  --dtype bfloat16 \
  --max_completion_length 1024 \
  --use_vllm \
  --vllm_mode colocate \
  --use_peft \
  --lora_target_modules "q_proj", "v_proj" \
  --log_completions
```

### Mẹo cấu hình

- Sử dụng LoRA trên các lớp chiếu ngôn ngữ-thị giác
- Bật lượng tử hóa 4-bit để giảm mức sử dụng bộ nhớ
- VLMs đòi hỏi nhiều bộ nhớ — hãy bắt đầu với kích thước batch nhỏ hơn
- Hầu hết các model đều tương thích với vLLM (chế độ `server` và `colocate`)

### Định dạng Dữ liệu

Mỗi mẫu huấn luyện nên bao gồm:

- `prompt`: Văn bản được định dạng qua mẫu chat của bộ xử lý
- `image`/`images`: Ảnh PIL hoặc danh sách các ảnh PIL

Trainer tự động xử lý việc chuyển đổi ảnh sang tensor thông qua bộ xử lý ảnh của model.

## RLOOTrainer[[trl.RLOOTrainer]]

#### trl.RLOOTrainer[[trl.RLOOTrainer]]

```python
trl.RLOOTrainer(model: str | PreTrainedModel | PeftModel, reward_funcs: str | transformers.modeling_utils.PreTrainedModel | collections.abc.Callable[..., list[float | None]] | list[str | transformers.modeling_utils.PreTrainedModel | collections.abc.Callable[..., list[float | None]]], args: trl.trainer.rloo_config.RLOOConfig | 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 | transformers.processing_utils.ProcessorMixin | None = None, reward_processing_classes: transformers.tokenization_utils_base.PreTrainedTokenizerBase | list[transformers.tokenization_utils_base.PreTrainedTokenizerBase] | 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), quantization_config: BitsAndBytesConfig | None = None, peft_config: PeftConfig | None = None)
```

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

**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 `<ModelArchitecture>.from_pretrained` (trong đó `<ModelArchitecture>` được suy ra từ cấu hình mô hình) 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 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). Chỉ hỗ trợ các mô hình ngôn ngữ nhân quả. - Một đối tượng [PeftModel](https://huggingface.co/docs/peft/v0.22.0/en/package_reference/peft_model#peft.PeftModel). Chỉ hỗ trợ các mô hình ngôn ngữ nhân quả.

reward_funcs (`RewardFunc | list[RewardFunc]`) : Các hàm reward được sử dụng để tính toán phần thưởng. Để tính phần thưởng, chúng ta gọi tất cả các hàm reward với prompts và completions, sau đó cộng tổng các phần thưởng. Có thể là:  - Một hàm reward duy nhất, chẳng hạn như: - Một chuỗi: *model ID* của một model đã được huấn luyện trước, được lưu trữ trong một model repo trên huggingface.co, hoặc đường dẫn đến một *thư mục* chứa các trọng số model đượ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/'`. Model được nạp bằng [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoModelForSequenceClassification.from_pretrained) với `num_labels=1` và các tham số keyword trong `args.model_init_kwargs`. - Một đối tượng [PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel): Chỉ hỗ trợ các model phân loại chuỗi. - Một hàm reward tùy chỉnh: Hàm này nhận các prompts và các completions được tạo ra, cùng với bất kỳ cột bổ sung nào trong dataset. Nó phải trả về một danh sách các phần thưởng. Các hàm reward tùy chỉnh có thể đồng bộ hoặc bất đồng bộ và cũng có thể trả về `None` khi phần thưởng không áp dụng cho các mẫu đó. Điều này hữu ích cho việc huấn luyện đa nhiệm, nơi các hàm reward khác nhau áp dụng cho các loại mẫu khác nhau. Khi một hàm reward trả về `None` cho một mẫu, hàm reward đó sẽ bị loại khỏi việc tính toán phần thưởng cho mẫu đó. Để biết thêm chi tiết, xem [Using a custom reward function](#using-a-custom-reward-function).  Trạng thái của trainer cũng được truyền vào hàm reward. Trạng thái của trainer là một instance của [TrainerState](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/callback#transformers.TrainerState) và có thể được truy cập bằng cách truy cập tham số `trainer_state` trong chữ ký của hàm reward. - Một danh sách các hàm reward, trong đó mỗi phần tử có thể độc lập là bất kỳ loại nào ở trên. Việc trộn lẫn các loại khác nhau trong danh sách (ví dụ: một model ID dạng chuỗi và một hàm reward tùy chỉnh) là được phép.

args ([RLOOConfig](/docs/trl/v1.18.2/vi/rloo_trainer#trl.RLOOConfig), *tùy chọn*) : Cấu hình cho trình huấn luyện này. Nếu là `None`, một cấu hình mặc định sẽ được sử dụng.

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. Nó phải bao gồm một cột `"prompt"`. Mọi cột bổ sung khác trong dataset sẽ bị bỏ qua. Đị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).  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à 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](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), [ProcessorMixin](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/processors#transformers.ProcessorMixin), *tùy chọn*) : Lớp xử lý được dùng để xử lý dữ liệu. Bên đệm (padding side) phải được đặt là "left". Nếu là `None`, lớp xử lý sẽ được tải từ tên mô hình bằng [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoProcessor.from_pretrained). Một token đệm, `tokenizer.pad_token`, phải được đặt. Nếu lớp xử lý chưa đặt token đệm, `tokenizer.eos_token` sẽ được dùng làm mặc định.

reward_processing_classes ([PreTrainedTokenizerBase](https://huggingface.co/docs/transformers/v5.23.0/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase) hoặc `list[PreTrainedTokenizerBase]`, *tùy chọn*) : Các lớp xử lý tương ứng với các hàm phần thưởng được chỉ định trong `reward_funcs`. Có thể là:  - Một lớp xử lý duy nhất: Được sử dụng khi `reward_funcs` chỉ chứa một hàm phần thưởng. - Một danh sách các lớp xử lý: Phải khớp với thứ tự và độ dài của các hàm phần thưởng trong `reward_funcs`. Nếu được đặt thành `None`, hoặc nếu một phần tử trong danh sách tương ứng với một [PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel) là `None`, tokenizer cho mô hình sẽ được tải tự động bằng [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoTokenizer.from_pretrained). Đối với các phần tử trong `reward_funcs` là các hàm phần thưởng tùy chỉnh (không phải [PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel)), các mục tương ứng trong `reward_processing_classes` sẽ bị bỏ qua.

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

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ị bỏ qua nếu mô hình đã được khởi tạo.

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 mô hình. Nếu là `None`, mô hình sẽ không được bọc.

Trainer cho phương pháp Reinforce Leave One Out (RLOO). Thuật toán này ban đầu được đề xuất trong bài báo [Back to Basics: Revisiting REINFORCE Style Optimization for Learning from Human Feedback in LLMs](https://huggingface.co/papers/2402.14740).

Ví dụ:

```python
>>> from trl import RLOOTrainer
>>> from trl.rewards import accuracy_reward
>>> from datasets import load_dataset

>>> dataset = load_dataset("trl-lib/DeepMath-103K", split="train")

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

#### train[[trl.RLOOTrainer.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.RLOOTrainer.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.RLOOTrainer.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`.

## RLOOConfig[[trl.RLOOConfig]]

#### trl.RLOOConfig[[trl.RLOOConfig]]

```python
trl.RLOOConfig(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 = 1e-06, 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 | None = False, 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, router_aux_loss_coef: float | None = None, disable_dropout: bool = False, num_generations: int | None = 2, num_generations_eval: int | None = None, max_completion_length: int | None = 512, ds3_gather_for_generation: bool = True, shuffle_dataset: bool | None = True, pad_to_multiple_of: int | str | None = 'auto', generation_batch_size: int | None = None, steps_per_generation: int | None = None, temperature: float = 1.0, top_p: float = 1.0, top_k: int = 0, min_p: float | None = None, generation_kwargs: dict | str | None = None, chat_template_kwargs: dict | str | None = None, repetition_penalty: float = 1.0, cache_implementation: str | None = None, use_vllm: bool = False, vllm_mode: str = 'colocate', vllm_model_impl: str = 'vllm', vllm_enable_sleep_mode: bool = False, vllm_structured_outputs_regex: str | None = None, vllm_server_base_url: str | None = None, vllm_server_host: str = '0.0.0.0', vllm_server_port: int = 8000, vllm_server_timeout: float = 240.0, vllm_group_port: int = 51216, vllm_gpu_memory_utilization: float = 0.3, vllm_max_model_length: int | None = None, vllm_tensor_parallel_size: int = 1, beta: float = 0.05, num_iterations: int = 1, epsilon: float = 0.2, epsilon_high: float | None = None, reward_weights: list[float] | None = None, normalize_advantages: bool = False, reward_clip_range: tuple[float, float] | None = None, mask_truncated_completions: bool = False, sync_ref_model: bool = False, ref_model_mixup_alpha: float = 0.6, ref_model_sync_steps: int = 512, log_completions: bool = False, log_multimodal: bool = True, num_completions_to_print: int | None = None, log_unique_prompts: bool = False, use_transformers_continuous_batching: bool = False, transformers_continuous_batching_config: dict | str | None = None, use_transformers_paged: bool = False)
```

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

**Các tham số kiểm soát mô hình và mô hình tham chiếu:**

model_init_kwargs (`str` hoặc `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.AutoModelForCausalLM.from_pretrained), được sử dụng khi đối số `model` của [RLOOTrainer](/docs/trl/v1.18.2/vi/rloo_trainer#trl.RLOOTrainer) được cung cấp dưới dạng chuỗi. Giá trị `revision` cũng được sử dụng khi nạp các lớp xử lý.

trust_remote_code (`bool`, *tùy 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.AutoModelForCausalLM.from_pretrained) và [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoProcessor.from_pretrained). Nó cũng được áp dụng cho việc tải reward-model và reward-tokenizer.

router_aux_loss_coef (`float`, *optional*) : Hệ số của tổn thất phụ cân bằng tải cho các mô hình Mixture-of-Experts (MoE), được cộng vào tổn thất huấn luyện với trọng số này. Khi không được đặt, giá trị được khai báo trong cấu hình mô hình sẽ được sử dụng. Đặt thành `0.0` để tắt tính năng này. Gặp lỗi khi sử dụng với mô hình không phải MoE.

disable_dropout (`bool`, *tùy chọn*, mặc định là `False`) : Có vô hiệu hóa dropout trong mô hình hay không. Điều này hữu ích khi huấn luyện với một mô hình tham chiếu, vì nó ngăn mô hình tạo ra các logprobs khác nhau cho cùng một đầu vào.

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

remove_unused_columns (`bool`, *tùy chọn*, mặc định là `False`) : Có nên chỉ giữ lại cột `"prompt"` trong bộ dữ liệu hay không. Nếu bạn sử dụng một hàm thưởng tùy chỉnh yêu cầu bất kỳ cột nào khác ngoài `"prompts"` và `"completions"`, bạn nên giữ giá trị này là `False`.

num_generations (`int`, *tuỳ chọn*, mặc định là `2`) : Số lượng bản sinh được lấy mẫu cho mỗi prompt. Kích thước lô hiệu dụng (num_processes * per_device_batch_size * gradient_accumulation_steps) phải chia hết cho giá trị này.

num_generations_eval (`int`, *optional*) : Số lượng thế hệ cần lấy mẫu trong quá trình đánh giá. Điều này cho phép sử dụng ít thế hệ hơn trong đánh giá để tiết kiệm tài nguyên tính toán. Nếu là `None`, sẽ sử dụng giá trị của `num_generations`.

max_completion_length (`int` hoặc `None`, *tùy chọn*, mặc định là `512`) : Độ dài tối đa của phần hoàn thành được tạo ra.

ds3_gather_for_generation (`bool`, *tuỳ chọn*, mặc định là `True`) : Cài đặt này áp dụng cho DeepSpeed ZeRO-3. Nếu được bật, trọng số của mô hình chính sách sẽ được thu thập cho quá trình sinh, giúp tăng tốc độ sinh. Tuy nhiên, việc tắt tuỳ chọn này cho phép huấn luyện các mô hình vượt quá dung lượng VRAM của một GPU đơn lẻ, dù phải đánh đổi bằng tốc độ sinh chậm hơn. Việc tắt tuỳ chọn này không tương thích với sinh bằng vLLM.

shuffle_dataset (`bool`, *tùy chọn*, mặc định là `True`) : Có trộn (shuffle) bộ dữ liệu huấn luyện hay không.

pad_to_multiple_of (`int` hoặc `str`, *không bắt buộc*, mặc định là `"auto"`) : Nếu được đặt, các id của prompts và completions 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 sinh:**

generation_batch_size (`int`, *optional*) : Kích thước batch để sử dụng cho quá trình sinh. Nếu là `None`, giá trị mặc định sẽ là kích thước batch huấn luyện hiệu dụng: `per_device_train_batch_size * num_processes * steps_per_generation`. Nói cách khác, có một batch sinh được xử lý cho mỗi bước tối ưu hóa. Loại trừ lẫn nhau với `steps_per_generation`.

steps_per_generation (`int`, *tùy chọn*) : Số bước cho mỗi lần sinh. Nếu là `None`, giá trị mặc định sẽ là `gradient_accumulation_steps`. Loại trừ lẫn nhau với `generation_batch_size`.

temperature (`float`, *tùy chọn*, mặc định là `1.0`) : Nhiệt độ cho việc lấy mẫu. Nhiệt độ càng cao, các phần hoàn thành càng ngẫu nhiên hơn.

top_p (`float`, *optional*, mặc định là `1.0`) : Giá trị kiểm soát xác suất tích lũy của các token hàng đầu cần xem xét. Phải nằm trong khoảng (0, 1]. Đặt thành `1.0` để xem xét tất cả các token.

top_k (`int`, *optional*, mặc định là `0`) : Số lượng token từ vựng có xác suất cao nhất cần giữ lại cho top-k-filtering. Nếu là `0`, top-k-filtering sẽ bị vô hiệu hóa và tất cả các token đều được xem xét.

min_p (`float`, *optional*) : Xác suất tối thiểu của token, sẽ được nhân với xác suất của token có khả năng cao nhất. Giá trị này phải nằm trong khoảng từ `0.0` đến `1.0`. Các giá trị điển hình thường nằm trong khoảng `0.01-0.2`.

generation_kwargs (`dict[str, Any]`, *tùy chọn*) : Các đối số từ khóa bổ sung để truyền cho [GenerationConfig](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/text_generation#transformers.GenerationConfig) (nếu dùng transformers) hoặc `SamplingParams` (nếu dùng vLLM) khi lấy mẫu các câu trả lời hoàn chỉnh. Điều này có thể được dùng để tùy chỉnh thêm hành vi sinh, chẳng hạn như đặt `suppress_tokens`, `num_beams`, v.v. Nếu nó chứa các khóa xung đột với các tham số sinh khác (như `min_p`, `top_p`, v.v.), chúng sẽ ghi đè lên các tham số đó.

chat_template_kwargs (`dict[str, Any]`, *tùy chọn*) : Các đối số từ khóa bổ sung để truyền cho hàm `apply_chat_template` khi tạo các câu trả lời hoàn chỉnh.

repetition_penalty (`float`, *optional*, mặc định là `1.0`) : Giá trị `float` để phạt các token mới dựa trên việc chúng có xuất hiện trong prompt và văn bản đã tạo ra cho đến hiện tại hay không. Các giá trị > `1.0` khuyến khích mô hình sử dụng các token mới, trong khi các giá trị < `1.0` khuyến khích mô hình lặp lại các token.

cache_implementation (`str`, *tùy chọn*) : Triển khai phương thức cache để tạo nhanh hơn khi `use_vllm` được đặt thành `False`.

**Các tham số kiểm soát tăng tốc sinh nội dung được hỗ trợ bởi vLLM:**

use_vllm (`bool`, *tùy chọn*, mặc định là `False`) : Có sử dụng vLLM để tạo các câu trả lời hoàn chỉnh hay không. Nếu đặt thành `True`, trình huấn luyện sẽ sử dụng vLLM để tạo thay vì model.generate() mặc định. Yêu cầu `vllm` phải được cài đặt.

vllm_mode (`str`, *tùy chọn*, mặc định là `"colocate"`) : Chế độ sử dụng cho tích hợp vLLM khi `use_vllm` được đặt thành `True`. Phải là một trong `"server"` hoặc `"colocate"`. - `"server"`: Trainer sẽ gửi các yêu cầu sinh nội dung đến một máy chủ vLLM riêng biệt. Hãy đảm bảo rằng một máy chủ vLLM đang chạy (khởi động bằng `vllm serve`). - `"colocate"`: vLLM sẽ chạy trong cùng tiến trình và chia sẻ các GPU huấn luyện. Cách này tránh được nhu cầu về một máy chủ riêng biệt nhưng có thể gây ra tranh chấp tài nguyên với quá trình huấn luyện.

vllm_model_impl (`str`, *tùy chọn*, mặc định là `"vllm"`) : Bản triển khai mô hình để sử dụng cho vLLM. Phải là một trong `"transformers"` hoặc `"vllm"`. `"transformers"`: Sử dụng backend `transformers` cho bản triển khai mô hình. `"vllm"`: Sử dụng thư viện `vllm` cho bản triển khai mô hình.

vllm_enable_sleep_mode (`bool`, *tùy chọn*, mặc định là `False`) : Bật chế độ ngủ của vLLM để chuyển tải trọng số/bộ nhớ đệm trong bước tối ưu hóa. Giữ mức sử dụng bộ nhớ GPU thấp, nhưng việc đánh thức engine sẽ thêm độ trễ chuyển dữ liệu giữa host và thiết bị.

vllm_structured_outputs_regex (`str`, *tùy chọn*) : Regex cho structured outputs của vLLM. Nếu `None` (mặc định), structured outputs sẽ bị tắt.

**Các tham số điều khiển máy chủ vLLM (chỉ được sử dụng khi `vllm_mode` là `"server"`):**

vllm_server_base_url (`str`, *tùy chọn*) : URL gốc cho máy chủ vLLM (ví dụ: `"http://localhost:8000"`). Nếu được cung cấp, `vllm_server_host` và `vllm_server_port` sẽ bị bỏ qua.

vllm_server_host (`str`, *tùy chọn*, mặc định là `"0.0.0.0"`) : Host của máy chủ vLLM để kết nối. Bỏ qua nếu `vllm_server_base_url` được cung cấp.

vllm_server_port (`int`, *tuỳ chọn*, mặc định là `8000`) : Cổng của máy chủ vLLM để kết nối. Bỏ qua nếu `vllm_server_base_url` được cung cấp.

vllm_server_timeout (`float`, *tuỳ chọn*, mặc định là `240.0`) : Tổng thời gian chờ (tính bằng giây) để chờ máy chủ vLLM khởi động. Nếu máy chủ chưa sẵn sàng sau thời gian chờ, một `ConnectionError` sẽ được ném ra.

vllm_group_port (`int`, *optional*, mặc định là `51216`) : Số cổng cho nhóm cập nhật trọng số. Cổng này được sử dụng để liên lạc với máy chủ vLLM. Trừ khi cổng đang bị chiếm dụng, bạn không cần phải thay đổi nó.

**Các tham số kiểm soát việc thực thi vLLM colocated (chỉ được sử dụng khi `vllm_mode` là `"colocate"`):**

vllm_gpu_memory_utilization (`float`, *tuỳ chọn*, mặc định là `0.3`) : Kiểm soát mức sử dụng bộ nhớ GPU cho vLLM. Cài đặt này chỉ áp dụng khi `vllm_mode` được đặt thành `"colocate"`. Nếu bạn đang sử dụng `vllm_mode="server"`, tham số này phải được truyền riêng khi khởi động máy chủ vLLM thông qua cờ `--vllm_gpu_memory_utilization`.

vllm_max_model_length (`int`, *tuỳ chọn*) : Cửa sổ ngữ cảnh cho vLLM. Đặt giá trị này ít nhất bằng độ dài prompt tối đa trong bộ dữ liệu cộng thêm `max_completion_length`; nếu bỏ qua, giá trị sẽ được suy ra từ cấu hình mô hình.

vllm_tensor_parallel_size (`int`, *optional*, mặc định là `1`) : Kiểm soát kích thước song song tensor cho vLLM. Cài đặt này chỉ áp dụng khi `vllm_mode` được đặt thành `"colocate"`. Nếu bạn đang sử dụng `vllm_mode="server"`, tham số này phải được truyền riêng khi khởi động máy chủ vLLM thông qua cờ `--vllm_tensor_parallel_size`.

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

beta (`float`, *optional*, mặc định là `0.05`) : Hệ số KL. Nếu là `0.0`, mô hình tham chiếu sẽ không được nạp, giúp giảm mức sử dụng bộ nhớ và cải thiện tốc độ huấn luyện.

num_iterations (`int`, *tuỳ chọn*, mặc định là `1`) : Số lần lặp cho mỗi lô (được ký hiệu là μ trong thuật toán).

epsilon (`float`, *optional*, mặc định là `0.2`) : Giá trị epsilon cho việc cắt (clipping).

epsilon_high (`float`, *tuỳ chọn*) : Giá trị epsilon cận trên để cắt. Nếu không được chỉ định, giá trị mặc định sẽ giống với cận dưới được chỉ định trong tham số `epsilon`. Bài báo [DAPO](https://huggingface.co/papers/2503.14476) khuyến nghị `0.28`.

reward_weights (`list[float]`, *optional*) : Trọng số cho mỗi hàm phần thưởng. Phải khớp với số lượng các hàm phần thưởng. Nếu là `None`, tất cả các phần thưởng được gán trọng số bằng nhau với trọng số `1.0`.

normalize_advantages (`bool`, *tùy chọn*, mặc định là `False`) : Có nên chuẩn hóa các lợi thế (advantages) hay không. Việc chuẩn hóa được thực hiện trên mỗi lô (batch) sinh để có trung bình là `0.0` và độ lệch chuẩn là `1.0`.

reward_clip_range (`tuple[float, float]`, *optional*) : Phạm vi cắt (clip) cho phần thưởng dưới dạng (min, max). Nếu là `None`, sẽ không áp dụng cắt.

mask_truncated_completions (`bool`, *tùy chọn*, mặc định là `False`) : Khi được bật, các phần hoàn thành bị cắt ngắn sẽ bị loại khỏi việc tính toán loss, ngăn chúng bị phạt sai và gây nhiễu trong quá trình huấn luyện. Theo bài báo [DAPO](https://huggingface.co/papers/2503.14476), đây là một thực hành tốt cho sự ổn định của huấn luyện.

sync_ref_model (`bool`, *tùy chọn*, mặc định là `False`) : Có đồng bộ hóa mô hình tham chiếu với mô hình hoạt động mỗi `ref_model_sync_steps` bước hay không, sử dụng tham số `ref_model_mixup_alpha`. Cơ chế đồng bộ hóa này bắt nguồn từ bài báo [TR-DPO](https://huggingface.co/papers/2404.09656).

ref_model_mixup_alpha (`float`, *optional*, mặc định là `0.6`) : tham số α từ bài báo [TR-DPO](https://huggingface.co/papers/2404.09656), kiểm soát tỷ lệ pha trộn giữa chính sách hiện tại và chính sách tham chiếu trước đó trong quá trình cập nhật. Chính sách tham chiếu được cập nhật theo phương trình: `π_ref = α * π_θ + (1 - α) * π_ref_prev`. Để sử dụng tham số này, bạn phải đặt `sync_ref_model=True`.

ref_model_sync_steps (`int`, *tuỳ chọn*, mặc định là `512`) : tham số τ từ bài báo [TR-DPO](https://huggingface.co/papers/2404.09656), xác định tần suất đồng bộ hóa chính sách hiện tại với chính sách tham chiếu. Để sử dụng tham số này, bạn phải đặt `sync_ref_model=True`.

**Các tham số kiểm soát việc ghi log:**

log_completions (`bool`, *tùy chọn*, mặc định là `False`) : Có nên ghi nhật ký một mẫu các cặp (prompt, completion) mỗi `logging_steps` bước hay không. Nếu `rich` được cài đặt, nó sẽ in ra mẫu đó. Nếu ghi nhật ký `wandb` và/hoặc `trackio` được bật, nó sẽ ghi mẫu đó vào `wandb` và/hoặc `trackio`.

log_multimodal (`bool`, *tùy chọn*, mặc định là `True`) : Xác định có ghi nhật ký nội dung đa phương tiện (ảnh, video, v.v.) cùng với các kết quả hoàn thành hay không. Tắt tính năng này để giảm kích thước nhật ký khi sử dụng dữ liệu đa phương tiện độ phân giải cao.

num_completions_to_print (`int`, *optional*) : Số lượng completion được in ra bằng `rich`. Nếu là `None`, tất cả các completion sẽ được ghi log.

log_unique_prompts (`bool`, *tùy chọn*, mặc định là `False`) : Có ghi log các prompt duy nhất hay không. Nếu `True`, chỉ các prompt duy nhất được ghi log. Nếu `False`, tất cả các prompt đều được ghi log.

**Các tham số kiểm soát tăng tốc sinh văn bản được hỗ trợ bởi continuous batching của transformers:**

use_transformers_continuous_batching (`bool`, *tùy chọn*, mặc định là `False`) : Có sử dụng động cơ continuous batching của transformers để tạo các câu trả lời hoàn chỉnh hay không. Yêu cầu `transformers>=5.8.0`.

transformers_continuous_batching_config (`dict`, *tùy chọn*) : Các đối số từ khóa cho `ContinuousBatchingConfig`.

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

use_transformers_paged :   Tham số `use_transformers_paged` đã bị ngừng hỗ trợ và sẽ bị loại bỏ trong phiên bản v2.0.0. Hãy sử dụng `use_transformers_continuous_batching` thay thế.

Lớp cấu hình cho [RLOOTrainer](/docs/trl/v1.18.2/vi/rloo_trainer#trl.RLOOTrainer).

Lớp này chỉ bao gồm các tham số đặc thù cho huấn luyện RLOO. Để 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-6` thay vì `5e-5`.

## Tham khảo

1. [Bài báo RLOO](https://openreview.net/pdf?id=r1lgTGL5DE)
2. [Bài viết Quay về cơ bản: Xem xét lại tối ưu hóa kiểu REINFORCE để học từ phản hồi của con người trong LLM](https://huggingface.co/papers/2402.14740)
3. [Bài báo - REINFORCE++: Một cách tiếp cận đơn giản và hiệu quả để căn chỉnh các mô hình ngôn ngữ lớn](https://huggingface.co/papers/2501.03262)
4. [Bài viết trên blog - Đưa RL trở lại RLHF](https://huggingface.co/blog/putting_rl_back_in_rlhf_with_rloo)
5. [Bài viết trên blog - Giải mã RLHF và các biến thể của nó: Tiến bộ và những hiểu biết thực tiễn về kỹ thuật](https://hijkzzz.notion.site/unraveling-rlhf-and-its-variants-engineering-insights#147d9a33ecc9806090f3d5c749d31f05)
6. [Youtube - RLOO: Tối ưu hóa tiết kiệm chi phí cho việc học từ phản hồi của con người trong LLM](https://www.youtube.com/watch?v=86asXGPK6RU&ab_channel=BuzzRobot)

## Hướng dẫn chuyển đổi từ bản triển khai cũ (0.21 trở xuống)

Với việc phát hành phiên bản 0.22.0, chúng tôi đã làm mới [RLOOTrainer](/docs/trl/v1.18.2/vi/rloo_trainer#trl.RLOOTrainer) để phù hợp hơn với các trainer online khác trong thư viện, chẳng hạn như [GRPOTrainer](/docs/trl/v1.18.2/vi/grpo_trainer#trl.GRPOTrainer). Bản triển khai mới này giới thiệu một số thay đổi đối với các tham số cấu hình và cấu trúc tổng thể của trainer. Dưới đây là tóm tắt các thay đổi chính đối với [RLOOConfig](/docs/trl/v1.18.2/vi/rloo_trainer#trl.RLOOConfig):

| TRL ≤ 0.21.x | TRL ≥ 0.22.0 |
| --- | --- |
| `rloo_k` | được đổi tên thành `num_generations` |
| `cliprange` | được đổi tên thành `epsilon` |
| `kl_coef` | được đổi tên thành `beta` |
| `exp_name` | được đổi tên thành `run_name`. Sử dụng `run_name = f"{exp_name}__{seed}__{int(time.time())}"` để tái tạo hành vi cũ |
| `normalize_reward` | được đổi tên thành `normalize_advantages`. Lưu ý: hàm này luôn chuẩn hóa advantages (mặc dù tên cũ không phản ánh điều đó) |
| `num_ppo_epochs` | được đổi tên thành `num_iterations` (mặc định: `1`) |
| `token_level_kl` | **đã bị loại bỏ** – KL hiện chỉ được tính ở cấp độ chuỗi |
| `dataset_num_proc` | **đã bị loại bỏ** – vì không được sử dụng |
| `num_mini_batches` | được đổi tên thành `steps_per_generation` |
| `total_episodes` | thay vào đó, hãy dùng `max_steps=total_episodes / gradient_accumulation_steps` |
| `local_rollout_forward_batch_size` | **đã bị loại bỏ** – giờ được đặt tự động thành `per_device_train_batch_size` (hoặc `per_device_eval_batch_size` trong quá trình đánh giá) |
| `num_sample_generations` | **đã bị loại bỏ** – sử dụng `logging_steps` để kiểm soát tần suất ghi log khi tạo |
| `response_length` | được đổi tên thành `max_completion_length` (mặc định: `512`) |
| `stop_token` | **đã bị xóa** |
| `stop_token_id` | **đã bị loại bỏ** – hãy dùng `processing_class.eos_token_id` thay thế |
| `missing_eos_penalty` | **đã bị loại bỏ** – sao chép bằng một hàm thưởng tùy chỉnh kiểm tra xem `eos_token_id` có nằm trong `completion_ids` hay không |

Dưới đây là tóm tắt các thay đổi chính đối với [RLOOTrainer](/docs/trl/v1.18.2/vi/rloo_trainer#trl.RLOOTrainer):

| TRL ≤ 0.21.x | TRL ≥ 0.22.0 |
| --- | --- |
| `config` | được đổi tên thành `args` |
| `reward_model` | được đổi tên thành `reward_funcs`, hiện hỗ trợ cả các mô hình phần thưởng và các hàm phần thưởng tùy chỉnh |
| `policy` | được đổi tên thành `model` |
| `ref_policy` | **đã bị loại bỏ** – mô hình tham chiếu hiện được tạo tự động từ `model` |
| `data_collator` | **đã bị xóa** |

