Tinh chỉnh với Trl - TRL: SFT, DPO, PPO, GRPO, mô hình phần thưởng cho LLM RLHF

{/* Trang này được tạo tự động từ SKILL.md của kỹ năng bởi website/scripts/generate-skill-docs.py. Chỉnh sửa nguồn SKILL.md, không phải trang này. */}`#Tinh chỉnh bằng Trl

TRL: SFT, DPO, PPO, GRPO, mô hình phần thưởng cho LLM RLHF.

Siêu dữ liệu kỹ năng

Nguồn	Tùy chọn — cài đặt với
`Hermes skills install official/mlops/trl-fine-tuning
`
Đường dẫn

optional-skills/mlops/training/trl-fine-tuning ` | | Phiên bản |

1.0.0 ` | | Tác giả | Nghiên cứu dàn nhạc | | Giấy phép | MIT | | Phụ thuộc |

trl

, `transformers

, `datasets

, `peft

, `accelerate

, torch | | Nền tảng | Linux, macOS, Windows | | Thẻ |

Post-Training

, `TRL

, `Reinforcement Learning

, `Fine-Tuning

, `SFT

, `DPO

, `PPO

, `GRPO

, `RLHF

, `Preference Alignment

, HuggingFace |

Tham khảo: đầy đủ SKILL.md

thông tin

Sau đây là định nghĩa kỹ năng đầy đủ mà Hermes tải khi kỹ năng này được kích hoạt. Đây là những gì tác nhân coi là hướng dẫn khi kỹ năng được kích hoạt.

#TRL - Học gia cố máy biến áp

Bắt đầu nhanh

TRL cung cấp các phương pháp sau đào tạo để căn chỉnh các mô hình ngôn ngữ cho phù hợp với sở thích của con người.

Cài đặt:

`

pip install trl transformers datasets peft accelerate

`
``**Tinh chỉnh có giám sát** (điều chỉnh hướng dẫn):

`
`Python
from trl import SFTTrainer`trainer = SFTTrainer(
    model="Qwen/Qwen2.5-0.5B",
    train_dataset=dataset,  # Prompt-completion pairs
)
trainer.train()

`
``**DPO** (điều chỉnh theo sở thích):

`
`Python
from trl import DPOTrainer, DPOConfig`config = DPOConfig(output_dir="model-dpo", beta=0.1)
trainer = DPOTrainer(
    model=model,
    args=config,
    train_dataset=preference_dataset,  # chosen/rejected pairs
    processing_class=tokenizer
)
trainer.train()

`

## Quy trình công việc chung

### Quy trình làm việc 1: Đường dẫn RLHF đầy đủ (SFT → Mô hình phần thưởng → PPO)

Quy trình hoàn chỉnh từ mô hình cơ sở đến mô hình phù hợp với con người.

Sao chép danh sách kiểm tra này:

`
RLHF Training:

- [ ] Step 1: Supervised fine-tuning (SFT)
- [ ] Step 2: Train reward model
- [ ] Step 3: PPO reinforcement learning
- [ ] Step 4: Evaluate aligned model

`
``**Bước 1: Tinh chỉnh có giám sát**

Huấn luyện mô hình cơ sở trên dữ liệu hướng dẫn sau:

``` python
from transformers import AutoModelForCausaLLM, AutoTokenizer
from trl import SFTTrainer, SFTConfig
from datasets import load_dataset

# Load model
model = AutoModelForCausaLLM.from_pretrained("Qwen/Qwen2.5-0.5B")
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-0.5B")

# Load instruction dataset
dataset = load_dataset("trl-lib/Capybara", split="train")

# Configure training
training_args = SFTConfig(
    output_dir="Qwen2.5-0.5B-SFT",
    per_device_train_batch_size=4,
    num_train_epochs=1,
    learning_rate=2e-5,
    logging_steps=10,
    save_strategy="epoch"
)

# Train
trainer = SFTTrainer(
    model=model,
    args=training_args,
    train_dataset=dataset,
    tokenizer=tokenizer
)
trainer.train()
trainer.save_model()

`
``**Bước 2: Đào tạo mô hình phần thưởng**

Mô hình đào tạo để dự đoán sở thích của con người:

`Python
from transformers import AutoModelForSequenceClassification
from trl import RewardTrainer, RewardConfig

# Load SFT model as base
model = AutoModelForSequenceClassification.from_pretrained(
    "Qwen2.5-0.5B-SFT",
    num_labels=1  # Single reward score
)
tokenizer = AutoTokenizer.from_pretrained("Qwen2.5-0.5B-SFT")

# Load preference data (chosen/rejected pairs)
dataset = load_dataset("trl-lib/ultrafeedback_binariZed", split="train")

# Configure training
training_args = RewardConfig(
    output_dir="Qwen2.5-0.5B-Reward",
    per_device_train_batch_size=2,
    num_train_epochs=1,
    learning_rate=1e-5
)

# Train reward model
trainer = RewardTrainer(
    model=model,
    args=training_args,
    processing_class=tokenizer,
    train_dataset=dataset
)
trainer.train()
trainer.save_model()

`
``**Bước 3: Học tăng cường PPO**

Tối ưu hóa chính sách sử dụng mô hình khen thưởng:

`bash
Python -m trl.scripts.ppo \

    --model_name_or_path Qwen2.5-0.5B-SFT \
    --reward_model_path Qwen2.5-0.5B-Reward \
    --dataset_name trl-internal-testing/descriptiveness-sentiment-trl-style \
    --output_dir Qwen2.5-0.5B-PPO \
    --learning_rate 3e-6 \
    --per_device_train_batch_size 64 \
    --total_episodes 10000

`
``**Bước 4: Đánh giá**

``` python
from transformers import pipeline

# Load aligned model
generator = pipeline("text-generation", model="Qwen2.5-0.5B-PPO")

# Test
prompt = "Explain quantum computing to a 10-year-old"
output = generator(prompt, max_length=200)[0]["generated_text"]
print(output)

`

### Quy trình 2: Căn chỉnh tùy chọn đơn giản với DPO

Căn chỉnh mô hình với các ưu tiên mà không cần mô hình phần thưởng.

Sao chép danh sách kiểm tra này:

`
DPO Training:

- [ ] Step 1: Prepare preference dataset
- [ ] Step 2: Configure DPO
- [ ] Step 3: Train with DPOTrainer
- [ ] Step 4: Evaluate alignment

`
``**Bước 1: Chuẩn bị tập dữ liệu ưu tiên**

Định dạng tập dữ liệu:

`
``` json
{
  "prompt": "What is the cAPItal of France?",
  "chosen": "The cAPItal of France is Paris.",
  "rejected": "I don't know."
}

`
``Tải tập dữ liệu:

`
`Python
from datasets import load_dataset`dataset = load_dataset("trl-lib/ultrafeedback_binariZed", split="train")

# Or load your own
# dataset = load_dataset("JSON", data_files="preferences.JSON")

`
``**Bước 2: Định cấu hình DPO**

``` python
from trl import DPOConfig`config = DPOConfig(
    output_dir="Qwen2.5-0.5B-DPO",
    per_device_train_batch_size=4,
    num_train_epochs=1,
    learning_rate=5e-7,
    beta=0.1,  # KL penalty strength
    max_prompt_length=512,
    max_length=1024,
    logging_steps=10
)

`
``**Bước 3: Luyện tập với DPOTrainer**

`Python
from transformers import AutoModelForCausaLLM, AutoTokenizer
from trl import DPOTrainer`model = AutoModelForCausaLLM.from_pretrained("Qwen/Qwen2.5-0.5B-Instruct")
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-0.5B-Instruct")

trainer = DPOTrainer(
    model=model,
    args=config,
    train_dataset=dataset,
    processing_class=tokenizer
)

trainer.train()
trainer.save_model()

`
``**CLI thay thế**:

`
`bash
trl dpo \

    --model_name_or_path Qwen/Qwen2.5-0.5B-Instruct \
    --dataset_name argilla/Capybara-Preferences \
    --output_dir Qwen2.5-0.5B-DPO \
    --per_device_train_batch_size 4 \
    --learning_rate 5e-7 \
    --beta 0.1

`

### Quy trình 3: RL trực tuyến tiết kiệm bộ nhớ với GRPO

Huấn luyện bằng phương pháp học tăng cường sử dụng trí nhớ tối thiểu.

Để biết hướng dẫn GRPO chuyên sâu — thiết kế chức năng khen thưởng, thông tin chi tiết về đào tạo quan trọng (hành vi mất, thu gọn chế độ, điều chỉnh) và các mẫu nhiều giai đoạn nâng cao — hãy xem **[references/grpo-training.md](https://GitHub.com/NousResearch/Hermes-agent/blob/main/optional-skills/mlops/training/trl-fine-tuning/references/grpo-training.md)**. Tập lệnh đào tạo sẵn sàng sản xuất có trong **[templates/basic_grpo_training.py](https://GitHub.com/NousResearch/Hermes-agent/blob/main/optional-skills/mlops/training/trl-fine-tuning/templates/basic_grpo_training.py)**.

Sao chép danh sách kiểm tra này:

`
GRPO Training:
- [ ] Step 1: Define reward function
- [ ] Step 2: Configure GRPO
- [ ] Step 3: Train with GRPOTrainer

`
``**Bước 1: Xác định hàm thưởng**

``` python
def reward_function(completions, **kwargs):
    """
    Compute rewards for completions.

Args:
        completions: List of generated texts

Returns:
        List of reward scores (floats)
    """
    rewards = []
    for completion in completions:

        # Example: reward based on length and unique words
        score = len(completion.split())  # Favor longer responses
        score += len(set(completion.lower().split()))  # Reward unique words
        rewards.append(score)
    return rewards

`
``Hoặc sử dụng mô hình khen thưởng:

`
``` python
from transformers import pipeline`reward_model = pipeline("text-classification", model="reward-model-path")

def reward_from_model(completions, prompts, **kwargs):

    # Combine prompt + completion
    full_texts = [p + c for p, c in zip(prompts, completions)]
    # Get reward scores
    results = reward_model(full_texts)
    return [r["score"] for r in results]

`
``**Bước 2: Định cấu hình GRPO**

``` python
from trl import GRPOConfig`config = GRPOConfig(
    output_dir="Qwen2-GRPO",
    per_device_train_batch_size=4,
    num_train_epochs=1,
    learning_rate=1e-5,
    num_generations=4,  # Generate 4 completions per prompt
    max_new_tokens=128
)

`
``**Bước 3: Luyện tập với GRPOTrainer**

`Python
from datasets import load_dataset
from trl import GRPOTrainer

# Load prompt-only dataset
dataset = load_dataset("trl-lib/tldr", split="train")

trainer = GRPOTrainer(
    model="Qwen/Qwen2-0.5B-Instruct",
    reward_funcs=reward_function,  # Your reward function
    args=config,
    train_dataset=dataset
)

trainer.train()

`
``**CLI**:

`
`bash
trl grpo \

    --model_name_or_path Qwen/Qwen2-0.5B-Instruct \
    --dataset_name trl-lib/tldr \
    --output_dir Qwen2-GRPO \
    --num_generations 4

`

## Khi nào nên sử dụng so với các lựa chọn thay thế`**Sử dụng TRL khi:**
- Cần căn chỉnh mô hình phù hợp với sở thích của con người
- Có dữ liệu ưu tiên (cặp được chọn/từ chối)
- Muốn sử dụng học tăng cường (PPO, GRPO)
- Cần đào tạo mô hình khen thưởng
- Làm RLHF (full pipe)

**Lựa chọn phương pháp**:
- **SFT**: Có cặp nhắc hoàn thành, muốn có hướng dẫn cơ bản sau
- **DPO**: Có sở thích, muốn căn chỉnh đơn giản (không cần mô hình phần thưởng)
- **PPO**: Có mô hình khen thưởng, cần kiểm soát tối đa RL
- **GRPO**: Bị hạn chế về bộ nhớ, muốn RL trực tuyến
- **Mô hình phần thưởng**: Xây dựng đường dẫn RLHF, cần ghi điểm cho các thế hệ`**Sử dụng các lựa chọn thay thế thay thế:**
- **HuggingFace Trainer**: Tinh chỉnh cơ bản không cần RL
- **Axolotl**: Cấu hình đào tạo dựa trên YAML
- **LitGPT**: Mang tính giáo dục, tinh chỉnh tối thiểu
- **Unsloth**: Huấn luyện LoRA nhanh

## Các vấn đề thường gặp`**Vấn đề: OOM trong quá trình đào tạo DPO**

Giảm kích thước lô và độ dài chuỗi:

`
``` python
config = DPOConfig(
    per_device_train_batch_size=1,  # Reduce from 4
    max_length=512,  # Reduce from 1024
    gradient_accumulation_steps=8  # Maintain effective batch
)

`
``Hoặc sử dụng điểm kiểm tra độ dốc:

`
`Python
model.gradient_checkpointing_enable()

`
``**Vấn đề: Chất lượng căn chỉnh kém**

Điều chỉnh tham số beta:

`
`Python

# Higher beta = more conservative (stays closer to reference)
config = DPOConfig(beta=0.5)  # Default 0.1

# Lower beta = more aggressive alignment
config = DPOConfig(beta=0.01)

`
``**Vấn đề: Mô hình khen thưởng không học được**

Kiểm tra loại tổn thất và tốc độ học tập:

`
``` python
config = RewardConfig(
    learning_rate=1e-5,  # Try different LR
    num_train_epochs=3  # Train longer
)

`
``Đảm bảo tập dữ liệu ưu tiên có người chiến thắng rõ ràng:

`
`Python

# Verify dataset
print(dataset[0])
# Should have clear chosen > rejected

`
``**Vấn đề: Đào tạo PPO không ổn định**

Điều chỉnh hệ số KL:

`
``` python
config = PPOConfig(
    kl_coef=0.1,  # Increase from 0.05
    CLIprange=0.1  # Reduce from 0.2
)

`

## Chủ đề nâng cao`**Hướng dẫn đào tạo SFT**: Xem [references/sft-training.md](https://GitHub.com/NousResearch/Hermes-agent/blob/main/optional-skills/mlops/training/trl-fine-tuning/references/sft-training.md) để biết các định dạng tập dữ liệu, mẫu trò chuyện, chiến lược đóng gói và đào tạo đa GPU.**Các biến thể DPO**: Xem [references/dpo-variants.md](https://GitHub.com/NousResearch/Hermes-agent/blob/main/optional-skills/mlops/training/trl-fine-tuning/references/dpo-variants.md) để biết IPO, cDPO, RPO và các hàm mất DPO khác với siêu tham số được đề xuất.

**Mô hình phần thưởng**: Xem [references/reward-modeling.md](https://GitHub.com/NousResearch/Hermes-agent/blob/main/optional-skills/mlops/training/trl-fine-tuning/references/reward-modeling.md) để biết phần thưởng kết quả so với quá trình, tổn thất Bradley-Terry và đánh giá mô hình phần thưởng.

**Phương pháp RL trực tuyến**: Xem [references/online-rl.md](https://GitHub.com/NousResearch/Hermes-agent/blob/main/optional-skills/mlops/training/trl-fine-tuning/references/online-rl.md) để biết PPO, GRPO, RLOO và OnlineDPO với cấu hình chi tiết.

**Tìm hiểu sâu về GRPO**: Xem [references/grpo-training.md](https://GitHub.com/NousResearch/Hermes-agent/blob/main/optional-skills/mlops/training/trl-fine-tuning/references/grpo-training.md) để biết các mẫu GRPO cấp chuyên gia - triết lý thiết kế chức năng khen thưởng, thông tin chi tiết về đào tạo (tại sao tổn thất tăng, phát hiện sập chế độ), điều chỉnh siêu tham số, đào tạo nhiều giai đoạn và khắc phục sự cố. Mẫu sẵn sàng sản xuất trong [templates/basic_grpo_training.py](https://GitHub.com/NousResearch/Hermes-agent/blob/main/optional-skills/mlops/training/trl-fine-tuning/templates/basic_grpo_training.py).

## Yêu cầu về phần cứng
- **GPU**: NVIDIA (yêu cầu CUDA)

- **VRAM**: Tùy thuộc vào kiểu máy và phương pháp
  - SFT 7B: 16GB (có LoRA)
  - DPO 7B: 24GB (lưu mẫu tham chiếu)
  - PPO 7B: 40GB (chính sách + mô hình thưởng)
  - GRPO 7B: 24GB (tiết kiệm bộ nhớ hơn)
- **Đa GPU**: Được hỗ trợ qua 
`accelerate

- **Độ chính xác hỗn hợp**: Khuyến nghị BF16 (A100/H100)

**Tối ưu hóa bộ nhớ**:
- Sử dụng LoRA/QLoRA cho tất cả các phương pháp
- Kích hoạt tính năng kiểm tra độ dốc
- Sử dụng kích thước lô nhỏ hơn với sự tích lũy độ dốc

## Tài nguyên
- Tài liệu: https://huggingface.co/docs/trl/
- GitHub: https://GitHub.com/huggingface/trl
- Giấy tờ:
  - "Đào tạo mô hình ngôn ngữ làm theo hướng dẫn có phản hồi của con người" (InstructGPT, 2022)
  - "Tối ưu hóa tùy chọn trực tiếp: Mô hình ngôn ngữ của bạn bí mật là mô hình phần thưởng" (DPO, 2023)
  - "Tối ưu hóa chính sách tương đối nhóm" (GRPO, 2024)
- Ví dụ: https://GitHub.com/huggingface/trl/tree/main/examples/scripts