FORCE: Tăng 79% success rate khi fine-tune VLA bằng RL

Bạn đã từng fine-tune một VLA model rồi thấy nó giật lùi — success rate tụt xuống trong những epoch đầu, rồi không bao giờ phục hồi hoàn toàn? Hoặc phải ngồi can thiệp thủ công hàng trăm lần để "cứu" policy khỏi các vòng lặp sai lầm?

Đó chính xác là vấn đề mà nhóm nghiên cứu từ Shuyi Zhang và cộng sự (arXiv, tháng 6/2026) nhắm vào. Paper FORCE: Efficient VLA Reinforcement Fine-Tuning via Value-Calibrated Warm-up and Self-Distillation đề xuất một framework 3 giai đoạn tăng 79% success rate tuyệt đối, vượt các phương pháp RL trước 10%, và giảm 32.5% lượng mẫu cần thiết — tất cả mà không cần một lần human intervention nào.

Vấn đề: "Imitation Ceiling" và lý do RL fine-tuning khó

VLA model được huấn luyện bằng imitation learning (học bắt chước từ demonstrations) về bản chất bị giới hạn bởi imitation ceiling — khi chất lượng data không tốt, model không thể vượt qua mức hiệu suất của dữ liệu đó. Reinforcement Learning (RL) là con đường tự nhiên để phá vỡ giới hạn này: cho policy tự khám phá và học từ phản hồi của môi trường.

Tuy nhiên, RL fine-tuning VLA trong thực tế gặp 2 vấn đề cực kỳ khó chịu:

Vấn đề 1 — Catastrophic Initial Unlearning (mất kiến thức ban đầu thảm khốc): Khi bắt đầu RL, Q-function (hàm đánh giá chất lượng action) chưa được khởi tạo tốt. Nó thường overestimate Q-value cho các action mà policy chưa từng thực hiện (out-of-distribution actions). Policy bị cập nhật theo những tín hiệu sai lầm này, "quên đi" những gì nó đã học từ giai đoạn supervised fine-tuning. Hệ quả: success rate tụt mạnh ngay từ đầu, đôi khi không bao giờ phục hồi.

Vấn đề 2 — Low-Quality Exploration Data (data khám phá kém chất lượng): Policy yếu → rollout data kém → cập nhật từ data kém → policy vẫn yếu. Vòng lặp tiêu cực này khiến RL fine-tuning cực kỳ sample inefficient. Nhiều hệ thống phải dùng human-in-the-loop (HIL) — con người ngồi can thiệp khi robot làm sai để "sửa đường" cho policy — cực kỳ tốn kém khi scale up.

FORCE là gì?

FORCE là viết tắt cho Fine-tuning with vAlue-calibRated warm-up and sElf-distillation — một framework 3 giai đoạn giải quyết cả 2 vấn đề trên theo thứ tự:

1. Ổn định Q-function trước bằng Cal-QL offline
2. "Warm up" Q-function với on-policy data (xóa distributional shift)
3. Fine-tune policy online bằng self-distillation có sự lọc từ Q-function

Nguồn: Zhang et al., arXiv 2606.26006

Kiến trúc chi tiết: 3 giai đoạn của FORCE

Giai đoạn 1: Offline Cal-QL Pretraining

Trước khi chạm vào bất kỳ rollout nào, FORCE train Q-function thuần túy trên demonstration data bằng Calibrated Q-Learning (Cal-QL).

Cal-QL là biến thể của Conservative Q-Learning (CQL) với thêm một thành phần "calibration" để đảm bảo Q-function không overestimate Q-value cho các action nằm ngoài distribution của data. Objective function:

L_CalQL = L_TD + α × L_CQL + β × L_calibration

Trong đó:

• L_TD = Bellman temporal difference error (học từ transition)
• L_CQL = conservative penalty (phạt Q-value cao cho OOD actions)
• L_calibration = term bổ sung để align Q-value với thực tế

Kết quả: một Q-function biết "chê bai" các action kém và không quá tự tin về vùng chưa khám phá.

Hyperparameters giai đoạn 1:

offline_lr: 3.0e-4        # learning rate (Adam)
batch_size: 256
gamma: 0.99               # discount factor
tau: 0.005                # EMA coefficient for target network
cql_alpha: 0.1            # CQL regularization strength
critic_policy_ratio: 2    # cập nhật critic 2 lần mỗi lần cập nhật policy

Giai đoạn 2: Value-Calibrated Warm-Up

Đây là điểm sáng tạo cốt lõi của FORCE. Sau khi có Q-function offline, vấn đề là distributional shift: Q-function được train trên data của behavior policy (expert demonstrations), nhưng policy đang train bằng RL có thể đi theo hướng khác.

FORCE thu thập on-policy rollouts — cho policy hiện tại chạy trong môi trường thực và ghi lại kết quả — rồi merge với offline demo data để tạo thành một mixed dataset.

# Warm-up phase: thu thập on-policy data
on_policy_data = []
for _ in range(warm_up_episodes):
    trajectory = run_episode(policy=vla_policy, env=robot_env)
    on_policy_data.extend(trajectory)

# Merge with offline demos
mixed_dataset = concat([demo_dataset, on_policy_data])

# Tiếp tục train Q-function trên mixed data
for batch in mixed_dataset:
    q_loss = cal_ql_loss(q_function, batch)
    q_function.update(q_loss)

Ý tưởng: Q-function được "nhìn thấy" những gì policy thực sự làm trong môi trường, từ đó điều chỉnh đánh giá của nó về vùng state-action mà policy sẽ gặp trong giai đoạn tiếp theo. Không còn mù quáng về phần distribution chưa được cover bởi demonstrations nữa.

Kết quả của warm-up: Q-function không còn bị "shock" khi policy bắt đầu RL — không còn catastrophic unlearning.

Giai đoạn 3: Online Fine-Tuning với VGPD

Giai đoạn cuối mới chính thức fine-tune policy bằng RL. Đây lúc Value-Guided Policy Self-Distillation (VGPD) phát huy tác dụng.

VGPD hoạt động thế nào? Thay vì để policy học từ tất cả rollout data (kể cả data kém chất lượng), VGPD dùng Q-function làm "bộ lọc thông minh":

def vgpd_update(policy, q_function, state, K=20, tau=0.1):
    # Bước 1: Sample K action candidates từ policy
    candidates = [policy.sample(state) for _ in range(K)]

    # Bước 2: Tính Q-value cho mỗi candidate
    q_values = [q_function(state, a) for a in candidates]

    # Bước 3: Dynamic baseline = trung bình Q-value
    v_ref = mean(q_values)

    # Bước 4: Lọc — chỉ giữ actions có Q > baseline
    good_mask = [q > v_ref for q in q_values]
    filtered = [(a, q) for a, q, m in zip(candidates, q_values, good_mask) if m]

    if not filtered:
        return None  # không cập nhật nếu không có action tốt

    # Bước 5: Exponential weighting theo Q-value
    actions, q_good = zip(*filtered)
    weights = softmax([q / tau for q in q_good])

    # Bước 6: Weighted imitation learning loss
    loss = sum(
        -w * policy.log_prob(state, a)
        for a, w in zip(actions, weights)
    )
    return loss

Cơ chế này tạo ra một automatic curriculum tự động: khi policy còn yếu, baseline V_ref thấp, nhiều actions qua được bộ lọc, policy học theo nhiều mẫu (giống behavioral cloning). Khi policy mạnh hơn, baseline tăng, bộ lọc khắt khe hơn, chỉ những actions xuất sắc nhất được dùng để cập nhật.

Expert buffer + Policy buffer: FORCE duy trì 2 replay buffer riêng biệt:

• Expert Buffer: demonstrations từ expert (data gốc)
• Policy Buffer: rollouts từ policy hiện tại

Sample 50-50 từ cả hai, áp dụng VGPD filter cho cả hai loại data. Điều này đảm bảo policy không "quên" knowledge từ demonstrations trong khi vẫn học từ những gì nó tự khám phá.

Cài đặt thực hành (theo algorithm paper)

Mặc dù paper chưa có GitHub repo công khai (tính đến 07/2026), bạn có thể implement FORCE từ specification trong paper. Dưới đây là hướng dẫn setup môi trường và implement theo từng bước.

Yêu cầu hệ thống

# Python environment
conda create -n force_vla python=3.10
conda activate force_vla

# Core dependencies
pip install torch==2.3.0 torchvision
pip install transformers>=4.40.0
pip install gymnasium mujoco  # for simulation

# Nếu dùng ManiSkill (benchmark trong paper)
pip install mani-skill2

# Nếu dùng LIBERO
pip install libero

GPU requirements:

• Minimum: A40 (48GB VRAM) cho VGPD với K=20 candidates
• Recommended: A100 80GB hoặc H100 80GB
• Training time: ~18k environment steps cho StackCube (≈ vài giờ trên A100)

Base VLA models

FORCE được thử nghiệm với:

• Octo — open-source generalist robot policy, dễ download và fine-tune
• π₀ (Pi Zero) — flow-based VLA từ Physical Intelligence
• π₀.₅ — phiên bản cải tiến của π₀

Với Octo (open-source nhất):

# Clone và cài đặt Octo
git clone https://github.com/octo-models/octo.git
cd octo && pip install -e .

# Download pre-trained checkpoint
python -c "
from octo.model.octo_model import OctoModel
model = OctoModel.load_pretrained('hf://rail-berkeley/octo-base')
"

Giai đoạn 1: Cal-QL Offline Training

import torch
import torch.nn as nn

class CalQL:
    def __init__(self, q_net, target_q_net, gamma=0.99, alpha=0.1):
        self.q = q_net
        self.target_q = target_q_net
        self.gamma = gamma
        self.alpha = alpha

    def compute_loss(self, batch):
        obs, actions, rewards, next_obs, dones = batch

        # TD target
        with torch.no_grad():
            target_q = rewards + (1 - dones) * self.gamma * self.target_q(next_obs)

        # Q-value for in-distribution actions (from demo)
        current_q = self.q(obs, actions)
        td_loss = nn.MSELoss()(current_q, target_q)

        # CQL penalty: log-sum-exp over random actions minus in-dist Q
        random_actions = torch.randn_like(actions)
        random_q = self.q(obs, random_actions)
        cql_loss = (torch.logsumexp(random_q, dim=0) - current_q).mean()

        total_loss = td_loss + self.alpha * cql_loss
        return total_loss

Monitoring training

# Metrics quan trọng cần track
metrics = {
    'q_value_mean': [],        # Phải tăng dần
    'q_value_std': [],         # Phải giảm sau warm-up
    'success_rate': [],        # Mục tiêu > 80%
    'episode_length': [],      # Phải giảm (robot hiệu quả hơn)
    'vgpd_filter_rate': [],    # % actions bị lọc bởi VGPD
}

Kết quả thực nghiệm

ManiSkill Simulation — so sánh với baselines

Real-World Franka Robot

Đáng chú ý là FORCE không chỉ thành công hơn mà còn hiệu quả hơn — robot hoàn thành task trong ~39 bước thay vì 113 bước. Điều này cho thấy policy học được cách thực hiện task trực tiếp và chính xác hơn, không phải mò mẫm.

Ablation Study — vai trò của từng thành phần

Cả Warm-Up và VGPD đều đóng góp đáng kể. Bỏ một trong hai đều làm tăng số bước cần thiết để đạt 80% success rate.

So sánh với các phương pháp RL fine-tuning VLA khác

Hiện tại có nhiều hướng tiếp cận RL fine-tuning VLA:

Điểm mạnh và hạn chế

Điểm mạnh

• Không cần human intervention: Critical khi muốn scale lên hàng trăm robot
• Multi-model compatible: Đã test với Octo và π₀ — architecture-agnostic
• Self-improving: VGPD tạo automatic curriculum, policy tự nâng cao bar của mình
• Sample efficient: 32.5% ít samples hơn ConRFT để đạt cùng performance

Hạn chế

• Phức tạp hơn SFT: 3-stage pipeline đòi hỏi tune nhiều hyperparameter hơn
• Overhead Q-function: Cần train và maintain Q-function song song với policy
• Chưa có code: Paper không kèm GitHub repo (tính đến 07/2026) — phải implement từ đầu theo pseudocode
• K=20 candidates per step: VGPD cần forward pass 20 lần mỗi bước update — tốn VRAM

Kết luận

FORCE là một bước tiến thực chất trong bài toán RL fine-tuning VLA. Thay vì thêm con người vào vòng lặp hay hy vọng policy tự figure out qua brute-force exploration, FORCE dùng Q-function đã được calibrate cẩn thận như một "cố vấn thông minh" — lọc ra những action xứng đáng để học và đặt ra baseline ngày càng cao hơn khi policy tiến bộ.

79% cải thiện tuyệt đối không phải con số nhỏ. Và việc không cần human intervention là điều kiện tiên quyết để RL fine-tuning VLA có thể scale lên hệ thống production thực sự.

Xem thêm các nghiên cứu liên quan về RL fine-tuning VLA:

• RISE: Self-Improving Robot Policy qua RL
• HiLSERL: RL trên Robot Thực với LeRobot

Bài viết liên quan

• SimpleVLA-RL: RL fine-tuning VLA đơn giản với GRPO
• EXPO-FT: Fine-tune π₀.₅ bằng Online RL trong 19 phút
• ProcVLM: Dense Reward cho VLA RL

Nguồn: FORCE: Efficient VLA Reinforcement Fine-Tuning via Value-Calibrated Warm-up and Self-Distillation — Zhang et al., arXiv 2606.26006, tháng 6/2026