Dự đoán
RLHF (Reinforcement Learning from Human Feedback) là bước nhảy vọt từ GPT-3 → ChatGPT. Con người dạy AI biết thế nào là 'helpful, honest, harmless', rồi RL giúp mô hình liên tục cải thiện.
Evaluating routing across providers.
AI Researcher
Kỹ thuật huấn luyện AI phù hợp với giá trị con người thông qua phản hồi và mô hình thưởng.
RLHF (Reinforcement Learning from Human Feedback) là bước nhảy vọt từ GPT-3 → ChatGPT. Con người dạy AI biết thế nào là 'helpful, honest, harmless', rồi RL giúp mô hình liên tục cải thiện.
Hãy tưởng tượng bạn đang dạy một đầu bếp trẻ tài năng nhưng "hoang dã". Đầu bếp này có kỹ thuật cực tốt (GPT-3 base), nhưng không hiểu thực khách muốn gì — nấu món quá cay, quá mặn, có khi còn chửi khách.
Bạn dạy đầu bếp qua 3 giai đoạn:
RLHF không dạy AI kiến thức mới — nó dạy AI giá trị. Base model (sau pretraining) đã có đủ tri thức. RLHF chỉ định hình cách mô hình sử dụng tri thức đó — khi nào nên nói, khi nào nên im lặng, cách từ chối lịch sự, khi nào nên làm rõ thay vì đoán.
Và trái tim kỹ thuật: Reward Model thay mặt con người chấm điểm hàng triệu response — biến "phản hồi người" (chậm, đắt) thành một hàm số đạo hàm được (nhanh, rẻ). Đây là cây cầu giúp RL cổ điển áp dụng được cho LLM.
Reward hacking xảy ra khi policy tìm cách tối đa điểm thưởng mà không thực sự cải thiện chất lượng. KL penalty, RM ensemble, cập nhật RM định kỳ, và reward shaping là các giải pháp.
β lớn → KL penalty nặng → policy bị 'kéo ghì' về SFT. Reward không tăng được nhiều. Ngược lại β quá nhỏ → policy drift xa, dễ reward hacking. Chọn β là trade-off trung tâm của RLHF (thường 0.01–0.2).
β nhỏ (0.01)
Policy tự do → reward model score tăng nhanh. Nhưng có thể bị hack: mô hình nịnh, xả văn, trả lời off-topic. Cần giám sát kỹ.
β vừa (0.05–0.2)
Sweet spot. Policy cải thiện rõ trên preference eval, KL với SFT vừa phải (~5–15), chất lượng thực tế tăng ổn định.
β lớn (>0.5)
Policy gần như = SFT. Reward không tăng được. Lãng phí compute. Bằng chứng: eval win-rate vs SFT chỉ nhỉnh hơn 50/50.
Trong thực tế, các lab như OpenAI và Anthropic dùng thêm adaptive KL control — β thay đổi theo KL thực đo được, đảm bảo KL nằm trong khoảng mục tiêu (thường 6–12 nats).
RLHF (Reinforcement Learning from Human Feedback) là một pipeline 3 giai đoạn được giới thiệu bởi Christiano et al. (2017) và áp dụng thành công vào LLM bởi InstructGPT (Ouyang et al., 2022). Mục tiêu: biến một mô hình ngôn ngữ lớn đã pretrain thành một trợ lý hữu ích, trung thực, và an toàn — phù hợp với preference của con người. Ba giai đoạn:
trong đó y_w là chosen, y_l là rejected.
Hàm mục tiêu của bước PPO (core equation của RLHF):
Thành phần KL penalty (β · log π_θ/π_SFT) tương đương khi lấy kỳ vọng. Đây là reward shaping per-token: reward thực tế mỗi token là R_φ (ở token cuối) minus β · KL cục bộ. β kiểm soát trade-off giữa "tối đa reward" và "giữ gần SFT".
import torch
import torch.nn as nn
import torch.nn.functional as F
from transformers import AutoModel, AutoTokenizer
class RewardModel(nn.Module):
"""
Reward Model: base LLM + một head tuyến tính cho ra scalar reward.
"""
def __init__(self, base_model_name: str):
super().__init__()
self.backbone = AutoModel.from_pretrained(base_model_name)
hidden = self.backbone.config.hidden_size
self.value_head = nn.Linear(hidden, 1, bias=False)
def forward(self, input_ids, attention_mask):
out = self.backbone(input_ids, attention_mask=attention_mask)
last_hidden = out.last_hidden_state
# Lấy hidden state của token cuối cùng (cuối response)
lengths = attention_mask.sum(dim=1) - 1
last = last_hidden[torch.arange(last_hidden.size(0)), lengths]
reward = self.value_head(last).squeeze(-1) # (batch,)
return reward
def rm_loss(reward_chosen, reward_rejected):
"""Bradley-Terry loss: khuyến khích reward(chosen) > reward(rejected)."""
return -F.logsigmoid(reward_chosen - reward_rejected).mean()
# Training loop
def train_step(rm, tokenizer, batch, optimizer):
# batch gồm danh sách (prompt, chosen, rejected)
chosen_texts = [p + c for p, c, _ in batch]
rejected_texts = [p + r for p, _, r in batch]
chosen_enc = tokenizer(chosen_texts, padding=True, truncation=True,
return_tensors="pt").to("cuda")
rejected_enc = tokenizer(rejected_texts, padding=True, truncation=True,
return_tensors="pt").to("cuda")
r_chosen = rm(**chosen_enc)
r_rejected = rm(**rejected_enc)
loss = rm_loss(r_chosen, r_rejected)
optimizer.zero_grad()
loss.backward()
optimizer.step()
return loss.item(), (r_chosen > r_rejected).float().mean().item()Objective RLHF max_π E[R − β · log(π/π_SFT)] có lời giải đóng (closed form) khi tối ưu trên không gian phân phối:
trong đó Z(x) là hệ số chuẩn hóa (partition function). Đây chính là softmax distribution với temperature 1/β. Lời giải này gợi ý:
# Dùng thư viện TRL (Hugging Face) — abstraction phổ biến cho RLHF.
from trl import PPOTrainer, PPOConfig, AutoModelForCausalLMWithValueHead
from transformers import AutoTokenizer
import torch
# 1. Load policy (π_θ) — khởi tạo từ π_SFT
policy = AutoModelForCausalLMWithValueHead.from_pretrained("sft-model")
ref_model = AutoModelForCausalLMWithValueHead.from_pretrained("sft-model")
ref_model.eval() # ref_model = π_SFT, đóng băng để tính KL
tokenizer = AutoTokenizer.from_pretrained("sft-model")
reward_model = load_reward_model("rm-model")
# 2. Cấu hình PPO
config = PPOConfig(
model_name="sft-model",
learning_rate=1e-5,
batch_size=64,
mini_batch_size=8,
ppo_epochs=4,
init_kl_coef=0.05, # β ban đầu
adap_kl_ctrl=True, # adaptive KL control
target=6.0, # target KL (nats)
cliprange=0.2, # PPO clip range
cliprange_value=0.2,
vf_coef=0.1,
gamma=1.0,
lam=0.95,
)
trainer = PPOTrainer(
config=config,
model=policy,
ref_model=ref_model,
tokenizer=tokenizer,
)
# 3. Training loop
for epoch in range(num_epochs):
for batch in prompt_dataloader:
prompts = batch["prompt"]
prompt_tensors = [tokenizer.encode(p, return_tensors="pt")[0] for p in prompts]
# (a) Policy sinh response
response_tensors = [
trainer.generate(p, max_new_tokens=200, do_sample=True, top_p=0.9)[0]
for p in prompt_tensors
]
responses = [tokenizer.decode(r) for r in response_tensors]
# (b) Reward model chấm
rewards = [
torch.tensor(reward_model.score(p, r))
for p, r in zip(prompts, responses)
]
# (c) PPO update — tự động áp dụng KL penalty với ref_model
stats = trainer.step(prompt_tensors, response_tensors, rewards)
# (d) Log
print(f"reward={stats['ppo/mean_scores']:.3f}, "
f"KL={stats['objective/kl']:.2f}, "
f"β={stats['objective/kl_coef']:.4f}")RLHF không phải lựa chọn duy nhất. Dưới đây là các biến thể và lựa chọn thay thế phổ biến:
Trong thực tế: RLHF là kỹ thuật tốn kém (hàng triệu USD (ước lượng theo nguồn bài, chưa kiểm chứng) cho preference annotation + compute), nhưng là con đường đã được chứng minh là hiệu quả để biến base LLM thành trợ lý hữu ích. DPO và các biến thể đơn giản hơn đang dần thay thế PPO trong nhiều pipeline — nhưng ý tưởng cốt lõi "học từ preference của con người" vẫn là trung tâm của mọi công nghệ alignment hiện đại.