Qwen-VLA: Train Robot Manipulation Đa Nhiệm trên LIBERO Đạt 97.9%

Hãy tưởng tượng bạn cần xây một đội ngũ kỹ sư. Bạn có hai lựa chọn: hoặc thuê 10 chuyên gia mỗi người chỉ làm đúng 1 việc, hoặc thuê 3 người giỏi toàn diện đảm nhận tất cả. Trong AI robotics, hầu hết các lab đang làm theo kiểu đầu tiên — mỗi task có một VLA riêng, mỗi robot arm có một policy riêng, mỗi benchmark cần fine-tune lại từ đầu.

Qwen-VLA từ nhóm Qwen tại Alibaba đặt câu hỏi khác: Liệu một mô hình duy nhất có thể học tất cả không? Câu trả lời là có — và nó đạt 97.9% trên LIBERO trong khi vẫn handle navigation, manipulation thực tế, và egocentric action modeling trong cùng một bộ weights.

Vấn Đề: Specialist Hell trong VLA

Trước Qwen-VLA, bức tranh VLA trông như thế này: bạn có OpenVLA cho manipulation đơn giản, pi0 cho ALOHA bimanual, GR00T N1 cho Unitree G1, một model khác cho navigation. Mỗi model học xong thì giỏi đúng cái nó được train, nhưng không chuyển được sang task khác.

Vấn đề sâu xa hơn là về data efficiency: mỗi specialist phải học lại visual grounding, spatial reasoning, và action generation từ đầu. Trong khi đó, một generalist có thể chia sẻ representations giữa các task — điều mà não người làm rất tốt nhưng AI robotics vẫn đang vật lộn.

Qwen-VLA giải quyết điều này bằng cách cast manipulation, navigation, egocentric action, và trajectory prediction vào một không gian action-and-trajectory chung, được điều hướng bởi embodiment-aware text prompts.

Kiến Trúc: Qwen3.5-4B + 1.15B DiT Decoder

Qwen-VLA có hai phần chính:

1. VLM Backbone: Qwen3.5-4B

Backbone là Qwen3.5-4B — model vision-language 4 tỷ tham số của Alibaba. Nó đã được pretrain trên lượng lớn text và image data, nên hiểu sâu về visual grounding, spatial reasoning, và ngôn ngữ tự nhiên.

Vai trò của backbone: nhận camera frames + language instruction → encode thành token representations giàu ngữ nghĩa.

2. Action Decoder: 1.15B DiT Flow-Matching

Phần thứ hai là 1.15B DiT (Diffusion Transformer) action decoder dùng flow-matching objective. Đây là nơi action thực sự được sinh ra.

Flow-matching khác diffusion truyền thống ở chỗ: thay vì học cách denoise từ noise hoàn toàn, nó học một "velocity field" ánh xạ trực tiếp từ phân phối noise sang phân phối action. Kết quả: inference chỉ cần vài Euler integration steps — đủ nhanh cho real-time control.

Input: Camera frames + Language instruction + Embodiment prompt
         ↓
  Qwen3.5-4B VLM Backbone
  (Visual encoding + Language understanding)
         ↓
  Token representations
         ↓
  1.15B DiT Flow-Matching Action Decoder
  (Few Euler steps)
         ↓
  Continuous action trajectory (joint angles, end-effector poses...)

3. Embodiment-Aware Prompt Conditioning

Đây là insight quan trọng nhất: thay vì dùng các per-platform output heads riêng biệt, Qwen-VLA dùng text prompts mô tả robot cụ thể để điều kiện hóa action generation.

Ví dụ:

"You are controlling a WidowX single-arm robot with 6 DOF. 
 Action space: [joint1, joint2, joint3, joint4, joint5, joint6, gripper]"

vs.

"You are controlling an ALOHA dual-arm robot. 
 Action space: [left_arm_6dof, left_gripper, right_arm_6dof, right_gripper]"

Chỉ cần thay prompt là model switch embodiment. 11 robot embodiments khác nhau dùng chung một bộ weights.

Dữ Liệu Pretraining: 74% Manipulation, 7.5% Navigation

Qwen-VLA được train trên dataset khổng lồ với composition như sau:

Đáng chú ý là 6% egocentric human data — model học từ video người làm việc (với MANO hand model + eigengrasps 10D PCA để extract hand trajectories), không cần robot data cho phần này.

Cũng quan trọng: per-dataset quantile normalization cho action scaling — mỗi dataset có action range khác nhau, normalization đảm bảo DiT decoder không bị bias về dataset nào.

4 Giai Đoạn Training: Từ Text Đến Real-World

Điểm độc đáo của Qwen-VLA là progressive training curriculum — không phải pretrain-finetune đơn giản mà là 4 giai đoạn có logic:

Stage I: Text-to-Action (T2A) Pretraining

Giai đoạn đầu, model chỉ nhận language và embodiment prompts, không có vision. Nhiệm vụ: học language-indexed action priors — tức là hiểu "pick up the cup" thì action trajectory sẽ trông như thế nào về mặt cấu trúc.

Kết quả từ paper: mixture tốt nhất là 20% synthetic + 80% real data cho SFT performance downstream.

Stage II: Continued Pretraining (CPT)

Giai đoạn hai mới đưa vision vào. Model học joint backbone + DiT training với visual input, trên heterogeneous data từ real, simulated, và synthetic sources.

Đây là giai đoạn model học cách ground ngôn ngữ vào không gian visual, một kỹ năng critical cho manipulation thực tế.

Stage III: Supervised Fine-Tuning (SFT)

SFT trên target task demonstrations. Với LIBERO chẳng hạn, đây là lúc model học các task cụ thể trong benchmark.

Key: balanced data mixtures across embodiments — không để một embodiment dominate.

Stage IV: Reinforcement Learning (RL)

Giai đoạn cuối dùng PPO/GAE optimization cho closed-loop task success. RL ở đây tập trung vào single-environment nhưng vẫn có mild cross-domain transfer benefits.

Cài Đặt và Setup

# Clone repo
git clone https://github.com/QwenLM/Qwen-VLA.git
cd Qwen-VLA

# Tạo conda environment (Python 3.10+ required)
conda create -n qwen-vla python=3.10
conda activate qwen-vla

# Install PyTorch với CUDA 12.1
pip install torch==2.3.0 torchvision==0.18.0 --index-url https://download.pytorch.org/whl/cu121

# Install transformers (cần 4.57.0+ cho Qwen3.5 architecture)
pip install transformers>=4.57.0

# Install các dependencies chính
pip install accelerate einops timm
pip install flash-attn --no-build-isolation  # Flash Attention 2 cho speed

# Install Qwen utilities
pip install qwen-vl-utils[decord]==0.0.8

Yêu cầu phần cứng:

• Training: ít nhất 4× A100 80GB (khuyến nghị 8× A100 hoặc H100)
• Inference: RTX 4090 (24GB) hoặc A10G (24GB) đủ dùng
• Disk: ~50GB cho weights + dataset

Download Model Weights

from huggingface_hub import snapshot_download

# Tải Qwen-VLA-Instruct (full model)
snapshot_download(
    repo_id="Qwen/Qwen-VLA-Instruct",
    local_dir="./checkpoints/qwen-vla-instruct"
)

# Hoặc dùng huggingface-cli
# huggingface-cli download Qwen/Qwen-VLA-Instruct

Chạy Inference trên LIBERO

Đây là ví dụ inference cơ bản với LIBERO environment:

import torch
from transformers import AutoProcessor, AutoModelForCausalLM

# Load model và processor
model_path = "./checkpoints/qwen-vla-instruct"
processor = AutoProcessor.from_pretrained(model_path, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_path,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True
)

# Embodiment prompt cho LIBERO (Franka Panda)
EMBODIMENT_PROMPT = """You are controlling a Franka Panda robot arm.
Action space: [x, y, z, roll, pitch, yaw, gripper] in end-effector space.
"""

def get_action(observation, task_instruction, images):
    """
    observation: dict với camera frames
    task_instruction: str, VD "Pick up the red cup and place it in the bowl"
    images: list of PIL Images từ cameras
    """
    # Format input
    messages = [
        {"role": "system", "content": EMBODIMENT_PROMPT},
        {
            "role": "user", 
            "content": [
                *[{"type": "image", "image": img} for img in images],
                {"type": "text", "text": task_instruction}
            ]
        }
    ]
    
    # Preprocess
    text = processor.apply_chat_template(
        messages, tokenize=False, add_generation_prompt=True
    )
    inputs = processor(
        text=[text], images=images, return_tensors="pt"
    ).to(model.device, torch.bfloat16)
    
    # Generate action
    with torch.no_grad():
        action = model.generate_action(**inputs)
    
    return action.cpu().numpy()

# Sử dụng trong LIBERO loop
from libero.libero import benchmark
import numpy as np

# Setup LIBERO environment
benchmark_dict = benchmark.get_benchmark_dict()
task_suite = benchmark_dict["libero_spatial"]()
task = task_suite.get_task(0)
env = task_suite.get_task_init_states(0)

# Inference loop
obs = env.reset()
for step in range(300):  # Max 300 steps
    # Lấy camera frames
    agentview_img = obs["agentview_image"]   # shape: (H, W, 3)
    wrist_img = obs["robot0_eye_in_hand_image"]
    
    images = [agentview_img, wrist_img]
    action = get_action(obs, task.language, images)
    
    obs, reward, done, info = env.step(action)
    if done:
        print(f"Task completed at step {step}!")
        break

Training trên Custom Dataset

Để fine-tune Qwen-VLA trên dữ liệu robot của bạn, cần format data theo chuẩn sau:

# Format dữ liệu training (LeRobot compatible)
import json
from pathlib import Path

def prepare_training_data(episodes: list, output_dir: str):
    """
    episodes: list of dict, mỗi dict là một episode
    {
        "observations": [...],  # list of frames
        "actions": [...],       # list of action vectors
        "task": "Pick up the blue block",
        "embodiment": "franka_panda"
    }
    """
    output_path = Path(output_dir)
    output_path.mkdir(parents=True, exist_ok=True)
    
    for i, ep in enumerate(episodes):
        ep_data = {
            "task_instruction": ep["task"],
            "embodiment_prompt": get_embodiment_prompt(ep["embodiment"]),
            "frames": ep["observations"],     # list of image paths
            "actions": ep["actions"],         # numpy arrays
            "action_dim": len(ep["actions"][0])
        }
        
        with open(output_path / f"episode_{i:05d}.json", "w") as f:
            json.dump(ep_data, f)

def get_embodiment_prompt(robot_name: str) -> str:
    prompts = {
        "franka_panda": "You are controlling a Franka Panda 7-DOF robot arm...",
        "widowx": "You are controlling a WidowX 6-DOF robot arm...",
        "aloha": "You are controlling an ALOHA dual-arm bimanual robot..."
    }
    return prompts.get(robot_name, "")

Launch Training

# SFT trên LIBERO với 4 GPU
torchrun --nproc_per_node=4 train.py \
    --model_name_or_path ./checkpoints/qwen-vla-instruct \
    --dataset_path ./data/libero_spatial \
    --output_dir ./checkpoints/qwen-vla-libero-ft \
    --embodiment franka_panda \
    --num_train_epochs 50 \
    --per_device_train_batch_size 4 \
    --gradient_accumulation_steps 4 \
    --learning_rate 2e-5 \
    --warmup_ratio 0.05 \
    --bf16 True \
    --save_strategy epoch \
    --save_total_limit 3 \
    --dataloader_num_workers 4

# RL fine-tuning sau SFT (cần LIBERO env setup)
python train_rl.py \
    --checkpoint ./checkpoints/qwen-vla-libero-ft \
    --env libero_spatial \
    --num_envs 8 \
    --rl_algo ppo \
    --total_timesteps 500000

Demo Qwen-VLA Thực Tế

Kiến trúc tổng quan của Qwen-VLA — một model duy nhất cho tất cả tasks và embodiments:

Nguồn: QwenLM/Qwen-VLA

Kết Quả: Benchmark Simulation

Qwen-VLA được train một lần trên tất cả embodiments và evaluated không có per-benchmark adaptation:

Model cũng handle navigation với R2R OSR 69.0% và RxR SR 59.6% — trong khi specialist navigation models thường không làm được manipulation.

Out-of-Distribution Generalization

DOMINO là zero-shot evaluation với moving objects — không có training data cho dynamic objects, model vẫn đạt 26.6%.

Kết Quả: Real-World ALOHA — Đánh Bại Specialist

Đây là phần ấn tượng nhất. Trên ALOHA bimanual platform với 6 task thực tế:

In-Domain Performance (% success):

OOD Performance — thay màu, vị trí, object instance:

Pretraining đưa OOD average từ 36.2% (không pretrain) lên 76.9% — gần gấp đôi. Trong khi π₀.₅ (một trong các specialist mạnh nhất hiện tại) chỉ đạt 41.5% OOD.

Tại Sao Pretraining Quan Trọng Đến Vậy?

Kết quả trên tiết lộ một pattern thú vị: không có pretraining, Qwen-VLA chỉ đạt 48.5% in-domain — kém hơn cả π₀.₅ chuyên biệt. Với pretraining: 83.6% in-domain, 76.9% OOD.

Lý do: large-scale embodied pretraining dạy model học transferable representations — cách nhận biết đồ vật, hiểu spatial relationships, và map ngôn ngữ sang không gian vật lý. Những kỹ năng này transfer tốt sang unseen conditions (màu sắc khác, vị trí khác, câu lệnh paraphrase).

Đây là argument mạnh nhất cho hướng generalist VLA: chuyên gia học ít data hơn nhưng fragile; generalist học nhiều hơn và robust hơn.

Liên Kết Bài Viết Trong Blog

Nếu bạn muốn đào sâu hơn về các khía cạnh kỹ thuật liên quan:

• Xem LabVLA — VLA dùng Qwen3-VL cho lab robot để thấy cách dùng Qwen3-VL backbone trong setup LeRobot thực tế.
• Đọc OpenEAI-VLA — Qwen3 Pretrained VLA Guide để hiểu cách pretrain VLA từ Qwen base.
• So sánh với TGRPO — Trajectory GRPO VLA fine-tune trên LIBERO — một cách tiếp cận RL khác để boost LIBERO score.
• Nền tảng: VLA Models — Series AI cho Robot Phần 5 cung cấp overview về toàn bộ landscape VLA.

Tổng Kết

Qwen-VLA là một trong những bước tiến thuyết phục nhất cho hướng generalist VLA: một bộ weights, 11 embodiments, vừa manipulation vừa navigation, vừa simulation vừa real-world. Con số 97.9% trên LIBERO sẽ không gây ấn tượng nếu đạt được bằng cách chuyên biệt hóa — điều gây ấn tượng là đạt được trong khi xử lý đồng thời hàng chục task và embodiment khác nhau.

Kết quả ALOHA OOD là argument mạnh nhất: 76.9% OOD vs 41.5% của π₀.₅ specialist. Pretraining scale tạo ra robustness mà specialist không có được — đây là lesson quan trọng cho bất kỳ ai đang xây dựng robot manipulation system.

GitHub: QwenLM/Qwen-VLA Paper: arXiv:2605.30280

Bài Viết Liên Quan

• LabVLA: Dùng Qwen3-VL + LeRobot để Train VLA cho Lab Robot
• TGRPO: Fine-tune VLA trên LIBERO với Trajectory GRPO
• OpenVLA — Deep Dive Kiến Trúc và Training