SimpleVLA-RL (2): Kiến trúc & Thuật toán

Mở đầu: Từ ý tưởng đến hiện thực

Trong phần 1, chúng ta đã hiểu tại sao SimpleVLA-RL quan trọng: nó phá vỡ trần hiệu suất của SFT bằng cách cho VLA model tự luyện tập với reward nhị phân. Bây giờ là lúc trả lời câu hỏi bằng cách nào — kiến trúc nào, thuật toán nào, và những thiết kế kỹ thuật nào giúp hệ thống này hoạt động.

Bài viết này sẽ đi sâu vào ba trụ cột kỹ thuật: (1) backbone OpenVLA-OFT và cách nó biểu diễn hành động dưới dạng token, (2) thuật toán GRPO với asymmetric clipping, và (3) dynamic sampling — kỹ thuật tưởng đơn giản nhưng quyết định thành bại của toàn bộ hệ thống.

Backbone: OpenVLA-OFT

Tổng quan kiến trúc

SimpleVLA-RL được xây dựng trên OpenVLA-OFT (Open Vision-Language-Action with Optimal Fine-Tuning), một biến thể cải tiến của OpenVLA gốc. Kiến trúc bao gồm:

1. Language Model: LLaMA2-7B làm "bộ não" trung tâm, xử lý cả ngôn ngữ và hành động
2. Vision Encoders: Hai encoder song song:
   • SigLIP cho semantic features (hiểu "đây là cái cốc")
   • DINOv2 cho spatial features (hiểu "cái cốc ở tọa độ (x, y, z)")
3. Action Head: Chuyển đổi output của LLaMA thành hành động robot 7-DoF

Cách thức hoạt động: ảnh từ camera được đưa qua cả hai vision encoder, features được concatenate và project vào không gian embedding của LLaMA2. Kết hợp với task instruction bằng ngôn ngữ tự nhiên (ví dụ: "pick up the red cup"), LLaMA2 sinh ra chuỗi action tokens.

Token-based Actions: Tại sao không dùng regression?

Đây là quyết định thiết kế then chốt, và nó quyết định khả năng áp dụng RL.

Cách truyền thống (regression): Action head output trực tiếp 7 giá trị liên tục (6-DoF pose + gripper). Dùng loss function như L1 hoặc MSE. OpenVLA-OFT gốc dùng MLP head với L1 loss.

Cách SimpleVLA-RL chọn (token-based): Mỗi chiều hành động được discretize thành các bin, rồi biểu diễn dưới dạng token — giống hệt cách LLM sinh text. Mỗi action step tạo ra 256 tokens. Action chunking gom nhiều steps thành một sequence:

• LIBERO: chunk size = 8 steps → 8 x 256 = 2048 tokens
• RoboTwin: chunk size = 25 steps → 25 x 256 = 6400 tokens

Tại sao token-based lại quan trọng cho RL? Ba lý do:

1. Phân phối xác suất tự nhiên: Mỗi token có một phân phối xác suất trên vocabulary, cho phép tính log-probability — thành phần cốt lõi của policy gradient. Với regression output, bạn phải giả định một phân phối (Gaussian), và giả định này thường không chính xác.

2. Tương thích với GRPO: GRPO (và PPO, REINFORCE, v.v.) cần tính ratio π(a|s)/π_old(a|s). Với token-based actions, ratio này tính tự nhiên qua autoregressive generation. Với regression, bạn cần parameterize distribution riêng.

3. Exploration tự nhiên: Tăng temperature khi sampling tokens tự động tăng exploration — không cần thêm noise riêng. Ở temperature 1.6, model đủ "ngẫu hứng" để thử các hành động mới lạ.

So sánh với OpenVLA-OFT gốc

Quyết định chuyển sang single-view cũng đáng chú ý. Multi-view cho thông tin 3D tốt hơn, nhưng single-view giảm đáng kể computational cost cho RL rollouts — và với đủ dữ liệu training, single-view vẫn đạt performance tương đương.

GRPO: Thuật toán tối ưu

Group Relative Policy Optimization là gì?

GRPO (Group Relative Policy Optimization) ban đầu được phát triển cho RLHF trong LLM (bởi nhóm DeepSeek), và SimpleVLA-RL là một trong những công trình đầu tiên áp dụng nó cho robot manipulation.

Ý tưởng cốt lõi: thay vì dùng một critic network riêng để ước lượng value function (như PPO), GRPO tính advantage tương đối trong batch — so sánh các trajectories với nhau.

Cách GRPO hoạt động, từng bước

Bước 1: Sampling. Với mỗi query (state ban đầu + task instruction), model sinh ra G = 8 trajectories khác nhau (nhờ temperature cao). Mỗi trajectory là một chuỗi action tokens.

Bước 2: Evaluate. Chạy tất cả 8 trajectories trong simulation, đánh giá binary reward:

# Pseudocode
rewards = []
for trajectory in trajectories:
    success = env.evaluate(trajectory)
    rewards.append(1.0 if success else 0.0)
# Ví dụ: rewards = [1, 0, 1, 1, 0, 0, 1, 0]

Bước 3: Compute group-relative advantage. Normalize rewards trong group:

mean_r = mean(rewards)   # = 0.5
std_r = std(rewards)     # ≈ 0.535
advantages = [(r - mean_r) / std_r for r in rewards]
# Trajectories thành công có advantage dương, thất bại có advantage âm

Bước 4: Policy update. Tối đa hóa objective:

L = E[ min(ratio * A, clip(ratio, 1-ε_low, 1+ε_high) * A) ]

Trong đó:

• ratio = π_new(a|s) / π_old(a|s) — tỷ lệ xác suất giữa policy mới và cũ
• A — advantage từ bước 3
• ε_low = 0.2, ε_high = 0.28 — clipping bounds bất đối xứng

Asymmetric Clipping: Chiến thuật tinh vi

Đây là một trong những đóng góp kỹ thuật quan trọng nhất. Trong PPO chuẩn, clipping đối xứng: [1-ε, 1+ε] với ε = 0.2, tức [0.8, 1.2]. SimpleVLA-RL dùng bất đối xứng: [0.8, 1.28].

Tại sao? Hãy nghĩ về tình huống cụ thể:

• Hành động hiếm nhưng thành công: Một action mà policy cũ gán xác suất rất thấp (ví dụ: đẩy thay vì gắp) nhưng dẫn đến thành công. Ratio lớn (π_new >> π_old). Với symmetric clipping, ratio bị cắt ở 1.2 — policy chỉ tăng xác suất "nhẹ nhàng". Với asymmetric clipping (cắt ở 1.28), policy được phép tăng xác suất mạnh hơn cho hành động tốt mà nó chưa từng thử.

• Hành động phổ biến nhưng thất bại: Ratio nhỏ (π_new < π_old). Clipping ở 0.8 — giảm xác suất, nhưng không giảm quá nhanh để tránh mất đa dạng.

Nói đơn giản: ε_high > ε_low nghĩa là "tăng nhanh hơn giảm" — khuyến khích exploration mạnh mẽ hơn, đặc biệt quan trọng khi binary reward tạo ra tín hiệu gradient yếu.

Không KL Divergence: Đơn giản hóa triệt để

PPO truyền thống thường thêm KL penalty để policy mới không đi quá xa policy cũ:

L = L_clip - β * KL(π_new || π_old)

SimpleVLA-RL bỏ hoàn toàn KL term (β = 0). Lý do:

1. Tiết kiệm bộ nhớ GPU: Không cần lưu reference model (7B parameters) → tiết kiệm ~14GB VRAM trên mỗi GPU.
2. SFT đã cho base tốt: VLA model sau SFT đã có policy "hợp lý" — nó biết cách tiếp cận vật thể, biết cách di chuyển gripper. RL chỉ cần tinh chỉnh, không cần thay đổi lớn. Clipping bound đã đủ để ngăn policy diverge.
3. Empirical: Thí nghiệm cho thấy thêm KL không cải thiện kết quả, thậm chí giảm performance vì nó hạn chế exploration.

Dynamic Sampling: Kỹ thuật tưởng đơn giản nhưng quyết định

Vấn đề: Vanishing Gradients

Nhớ lại bước 3 — compute advantage. Nếu tất cả 8 trajectories đều thành công (rewards = [1,1,1,1,1,1,1,1]), thì:

mean_r = 1.0
std_r = 0.0  # Tất cả giống nhau!
advantages = [0, 0, 0, 0, 0, 0, 0, 0]  # Không có tín hiệu!

Tương tự nếu tất cả đều thất bại. Khi advantage = 0 cho mọi trajectory, gradient = 0, model không học được gì.

Đây là vấn đề đặc biệt nghiêm trọng với binary reward. Với dense reward (0.1, 0.3, 0.7, 0.9), ngay cả khi tất cả trajectories đều thành công, advantage vẫn khác 0 vì reward khác nhau. Nhưng binary reward chỉ có 2 giá trị, nên xác suất batch đồng nhất rất cao.

Giải pháp: Loại bỏ batch đồng nhất

SimpleVLA-RL áp dụng dynamic sampling: kiểm tra mỗi batch, nếu tất cả trajectories có cùng reward (all-success hoặc all-fail), bỏ batch đó và sample lại.

# Pseudocode
while True:
    trajectories = model.generate(query, num_samples=8, temperature=1.6)
    rewards = [env.evaluate(t) for t in trajectories]
    
    if len(set(rewards)) > 1:  # Có cả thành công lẫn thất bại
        break  # Batch này hữu ích, sử dụng
    # Nếu không, sample lại

Kỹ thuật này nghe đơn giản, nhưng nếu không có nó, RL training hoàn toàn fail. Paper cho thấy ablation: không có dynamic sampling, performance giảm 15-20% so với có dynamic sampling.

Trực giác

Hãy nghĩ dynamic sampling như việc chọn bài tập ở đúng mức độ khó. Nếu bạn luôn giải bài quá dễ (all-success), bạn không học thêm gì. Nếu luôn giải bài quá khó (all-fail), bạn cũng không học. Bạn học nhiều nhất khi bài tập ở ranh giới giữa có thể và không thể — và đó chính xác là điều dynamic sampling đảm bảo.

Temperature: Cân bằng Exploration và Exploitation

SimpleVLA-RL dùng temperature = 1.6 khi sinh trajectories (rollout), và temperature = 0 (greedy) khi inference.

Tại sao 1.6?

Temperature 1.0 là "mặc định" — phân phối xác suất giữ nguyên từ model. Temperature > 1.0 làm phẳng phân phối, tăng xác suất cho các tokens ít phổ biến. Ở temperature 1.6:

• Token phổ biến nhất (ví dụ: "di chuyển xuống") vẫn có xác suất cao nhất
• Nhưng các tokens ít phổ biến (ví dụ: "đẩy sang trái") có xác suất cao hơn đáng kể so với temperature 1.0
• Kết quả: model thử nhiều chiến thuật khác nhau thay vì lặp lại cùng một cách

Temperature 1.6 là sweet spot — đủ cao để explore, nhưng không quá cao để sinh ra hành động hoàn toàn ngẫu nhiên (temperature > 2.0 thường quá random).

Hai chế độ hoạt động

Sự tách biệt này quan trọng: training và inference có mục tiêu khác nhau. Training cần đa dạng để phát hiện chiến thuật mới. Inference cần nhất quán để đạt tỷ lệ thành công cao nhất.

Binary Reward: Đơn giản nhưng đủ

Reward được áp dụng cho toàn bộ trajectory

Một chi tiết quan trọng: reward R = 1 hoặc R = 0 được gán cho tất cả tokens trong trajectory, không chỉ token cuối cùng. Điều này có nghĩa:

# Nếu trajectory thành công
token_rewards = [1, 1, 1, 1, ..., 1]  # Tất cả tokens đều nhận R=1

# Nếu trajectory thất bại
token_rewards = [0, 0, 0, 0, ..., 0]  # Tất cả tokens đều nhận R=0

Tại sao không gán reward riêng cho từng token? Vì chúng ta không biết token nào là quan trọng. Trong một trajectory dài 2048 tokens, có thể token thứ 500 (quyết định đẩy thay vì gắp) là yếu tố quyết định thành bại, nhưng chúng ta không có cách nào biết. Bằng cách gán cùng một reward cho tất cả, GRPO sẽ tự động tìm ra tokens nào cần tăng/giảm xác suất thông qua group-relative advantage.

So sánh với Dense Reward

Binary reward trade off tín hiệu gradient yếu hơn để đổi lấy scalability và robustness — và kết hợp với dynamic sampling, nhược điểm này được khắc phục hiệu quả.

Data Flow: Từ đầu đến cuối

Hãy theo dõi một vòng lặp training hoàn chỉnh:

1. Query Generation: Chọn một task (ví dụ: "pick up the red cup") và một initial state ngẫu nhiên trong simulation.

2. Rollout: VLA model sinh 8 trajectories song song, mỗi trajectory gồm:

• Input: ảnh camera + task instruction
• Output: chuỗi action tokens (2048 cho LIBERO)
• Temperature: 1.6

3. Execution: Mỗi trajectory được thực thi trong simulation environment (LIBERO/RoboTwin).

4. Reward Assignment: Kiểm tra task completion → R = 1 hoặc 0.

5. Dynamic Sampling Check: Nếu tất cả rewards giống nhau → bỏ batch, quay lại bước 1. Nếu có cả 0 và 1 → tiếp tục.

6. Advantage Computation: Normalize rewards trong group → advantages.

7. Policy Update: GRPO update với asymmetric clipping.

8. Repeat: Quay lại bước 1 với policy đã cập nhật.

Toàn bộ quá trình này chạy trên 8 GPU NVIDIA A800 80GB, sử dụng framework veRL (v0.2) để parallelize rollout và training.

So sánh GRPO với PPO

GRPO đánh đổi accuracy của advantage estimation (PPO dùng learned critic chính xác hơn) lấy simplicity và efficiency. Với VLA model 7B parameters, việc bỏ critic network tiết kiệm ~14GB VRAM — đủ để tăng batch size hoặc giảm số GPU cần thiết.

Hyperparameters quan trọng

Dưới đây là bảng tổng hợp các hyperparameters chính của SimpleVLA-RL:

Learning rate 5e-6 đáng chú ý — thấp hơn nhiều so với SFT thông thường (1e-4). Lý do: RL training dễ gây catastrophic forgetting — model quên kiến thức từ SFT nếu cập nhật quá mạnh. Learning rate thấp đảm bảo model cải thiện dần dần mà không phá vỡ foundation.

Setup: Cách reproduce

Nếu bạn muốn reproduce kết quả SimpleVLA-RL, đây là setup cơ bản:

# Environment
conda create -n simplevla python=3.10
conda activate simplevla

# Core dependencies
pip install torch==2.4.0 --index-url https://download.pytorch.org/whl/cu124
pip install flash-attn==2.5.8
pip install verl==0.2

# Clone repos
git clone https://github.com/PRIME-RL/SimpleVLA-RL
git clone https://github.com/moojink/openvla-oft

# Install
cd SimpleVLA-RL && pip install -e .

Yêu cầu phần cứng tối thiểu: 8x GPU A800/H100 80GB. Đây là rào cản lớn nhất — không phải ai cũng có cluster 8 GPU high-end. Tuy nhiên, community đang làm việc trên phiên bản LoRA + gradient checkpointing để chạy trên 2-4 GPU.

Để tìm hiểu thêm về cách setup LeRobot cho các thí nghiệm tương tự, bạn có thể tham khảo series AI cho Robot.

Bài học kiến trúc

Nhìn lại toàn bộ thiết kế của SimpleVLA-RL, có vài bài học quan trọng:

1. Token-based > Regression cho RL

Quyết định chuyển từ regression sang token-based actions không chỉ là chi tiết kỹ thuật — nó mở khóa khả năng áp dụng RL. Đây là ví dụ điển hình của việc representation quyết định algorithm: chọn đúng cách biểu diễn dữ liệu quan trọng hơn chọn đúng thuật toán.

2. Simple > Complex

Không KL, không critic, không dense reward — mỗi thứ bỏ đi đều có lý do rõ ràng, và ablation study chứng minh rằng bỏ chúng không giảm performance. Bài học: luôn bắt đầu với giải pháp đơn giản nhất, chỉ thêm complexity khi có bằng chứng nó cần thiết.

3. Cách tiếp cận RL dành cho VLA

Khác với RL cho game (reward dày đặc, episode ngắn), RL cho robot manipulation có đặc thù riêng: reward thưa, trajectory dài, state space liên tục. SimpleVLA-RL cho thấy rằng thay vì cố ép framework RL truyền thống vào robotics, điều chỉnh framework cho phù hợp (binary reward + dynamic sampling + asymmetric clipping) cho kết quả tốt hơn.

Hạn chế và hướng phát triển

Dù ấn tượng, SimpleVLA-RL vẫn có những hạn chế cần nhận biết:

1. Yêu cầu phần cứng lớn: 8x A800 GPU không phải phòng lab nào cũng có. Cần nghiên cứu thêm về parameter-efficient RL (LoRA, QLoRA).

2. Phụ thuộc vào simulation: RL cần hàng nghìn rollouts, chỉ khả thi trong sim. Real-world RL vẫn là thách thức vì cost mỗi rollout quá cao.

3. Sim-to-real gap: Real-world improvement (120%) thấp hơn sim improvement (430%), cho thấy sim-to-real transfer vẫn là bottleneck.

4. Task-specific training: Hiện tại mỗi task cần RL riêng. Multi-task RL cho VLA vẫn là open question — liệu một RL training có thể cải thiện nhiều tasks cùng lúc?

Kết luận

SimpleVLA-RL là minh chứng cho nguyên tắc "less is more" trong machine learning. Bằng cách loại bỏ những component không cần thiết (KL, critic, dense reward) và thêm những kỹ thuật đơn giản nhưng hiệu quả (dynamic sampling, asymmetric clipping), nhóm tác giả đã tạo ra một hệ thống vượt trội hơn các phương pháp phức tạp hơn nhiều.

Nếu bạn đang nghiên cứu về VLA models hoặc muốn áp dụng RL cho robot manipulation, SimpleVLA-RL là starting point lý tưởng: code mở, phương pháp rõ ràng, và kết quả reproducible. Khi kết hợp với các mô hình pi-zero (pi0) và xu hướng Embodied AI 2026, chúng ta đang chứng kiến sự chuyển đổi từ "robot học từ người" sang "robot tự học từ kinh nghiệm" — và SimpleVLA-RL là một bước tiến quan trọng trên hành trình đó.

Bài viết liên quan

• SimpleVLA-RL (1): Tổng quan & Ý tưởng
• VLA Models: Khi ngôn ngữ điều khiển robot
• Robot Manipulation với VLA