Reward Modeling trong các mô hình LLM

🧠 Reward Modeling là gì?

Reward Modeling (Mô hình hóa phần thưởng) là bước đầu tiên trong quá trình huấn luyện mô hình AI để hiểu cái gì là “tốt” theo đánh giá của con người.

Thay vì chỉ học từ dữ liệu đầu vào và đầu ra như trước kia, bây giờ ta dạy mô hình học cách đánh giá chất lượng của một câu trả lời.

📌 Tóm gọn: Mục tiêu là tạo ra một mô hình đánh giá (reward model), giúp chấm điểm các câu trả lời của mô hình AI theo tiêu chuẩn của con người.

🛠️ Cách hoạt động (Có ví dụ)

Giả sử:

Bạn đang xây một chatbot. Bạn có 1 câu hỏi:

❓ “Làm thế nào để nấu phở bò?”

Và AI đưa ra 2 câu trả lời khác nhau:

• Trả lời A: Nói chi tiết từ nước dùng đến gia vị, thời gian nấu.
• Trả lời B: Nói qua loa, thiếu bước, không hấp dẫn.

Bạn đưa 2 câu trả lời cho con người đánh giá, và họ bảo:

• A > B (Tức là A tốt hơn B)

➡️ Vậy mô hình Reward Model sẽ học:

• Với đầu vào là câu hỏi và 2 câu trả lời A, B → mô hình cần dự đoán điểm số sao cho điểm của A cao hơn điểm của B.

🧮 Cách tính Loss Function

Ta gọi:

• ( r(A) ) là điểm reward mà mô hình dự đoán cho A
• ( r(B) ) là điểm reward mà mô hình dự đoán cho B

Mục tiêu:

• Nếu A tốt hơn B → ta muốn ( r(A) > r(B) )

Mô hình được huấn luyện để tối đa hóa xác suất A thắng B, thông qua hàm mất mát sau:

$$\mathcal{L} = -\log \left( \frac{e^{r(A)}}{e^{r(A)} + e^{r(B)}} \right)$$

Đây là binary cross entropy giữa A và B — tương tự như mô hình phân loại A thắng hay không.

🎯 Liên tưởng thực tế

🎮 Game chấm điểm

Hãy tưởng tượng bạn làm một game show nấu ăn:

• Mỗi người nấu xong, có 1 ban giám khảo chấm điểm.
• Bây giờ bạn muốn xây một máy chấm điểm tự động.

Thì:

• Reward model = máy chấm điểm
• Bạn đưa cho máy 2 dĩa thức ăn và bảo: "Giám khảo chọn dĩa A ngon hơn."
• Máy học cách chấm điểm sao cho lần sau cũng sẽ chọn giống giám khảo.

✅ Tóm tắt

Dưới đây là một ví dụ Python + PyTorch để mô phỏng quá trình huấn luyện một Reward Model đơn giản, dựa trên đánh giá của con người rằng “Câu A tốt hơn câu B”.

✅ Mục tiêu mô phỏng

• Mỗi input là một cặp (A, B)
• Human preference: A tốt hơn B → reward(A) > reward(B)
• Huấn luyện một mô hình đơn giản để học cách đánh giá reward cho mỗi câu

🧪 Ví dụ dữ liệu mô phỏng

Ta sẽ dùng embedding giả lập (vector ẩn của câu trả lời) thay cho model NLP thực tế (ví dụ như BERT), để đơn giản hóa.

💻 Code:

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F

# Tạo reward model đơn giản: 2-layer MLP
class RewardModel(nn.Module):
    def __init__(self, input_dim=10):
        super(RewardModel, self).__init__()
        self.fc1 = nn.Linear(input_dim, 64)
        self.fc2 = nn.Linear(64, 1)  # output 1 giá trị reward

    def forward(self, x):
        x = F.relu(self.fc1(x))
        return self.fc2(x)

# Tạo dữ liệu giả: mỗi câu trả lời là 1 vector ẩn 10 chiều
def generate_fake_data(n_samples=100):
    data = []
    for _ in range(n_samples):
        A = torch.randn(10)
        B = torch.randn(10)
        # Giả định A luôn "tốt hơn" B
        data.append((A, B))
    return data

# Loss function: preference loss (pairwise ranking)
def preference_loss(r_A, r_B):
    return -torch.log(torch.sigmoid(r_A - r_B))

# Khởi tạo model và optimizer
model = RewardModel()
optimizer = optim.Adam(model.parameters(), lr=1e-3)

# Tạo dữ liệu giả
train_data = generate_fake_data(1000)

# Huấn luyện
for epoch in range(10):
    total_loss = 0
    for A, B in train_data:
        r_A = model(A)
        r_B = model(B)
        loss = preference_loss(r_A, r_B)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        total_loss += loss.item()
    print(f"Epoch {epoch+1}: Loss = {total_loss:.4f}")

🧠 Diễn giải

• RewardModel: mô hình MLP nhỏ, nhận vector ẩn của một câu và trả về điểm reward.

• generate_fake_data: tạo 1000 cặp câu A và B, trong đó A được giả định là tốt hơn B.

• preference_loss: là công thức:

  $$\mathcal{L} = -\log \left( \frac{e^{r(A)}}{e^{r(A)} + e^{r(B)}} \right) = -\log(\sigma(r(A) - r(B)))$$

• Mỗi vòng lặp, mô hình học để chấm điểm cao hơn cho A so với B.