LingBot-VLA 2.0: Scale VLA lên 60.000 Giờ Dữ Liệu và Deploy Cross-Embodiment Mobile Manipulation

Paper: From Foundation to Application: Improving VLA Models in Practice — Robbyant (Ant Group), arXiv 2607.06403, tháng 7/2026
Code: github.com/Robbyant/lingbot-vla-v2 — Apache 2.0
Checkpoint: HuggingFace robbyant/lingbot-vla-v2

Vấn Đề: Khoảng Cách Giữa Lab và Thực Tế

Tưởng tượng bạn train một VLA model hoàn hảo trong lab, demo chạy mượt mà trên Franka 7DoF, kết quả benchmark ấn tượng. Rồi bạn mang nó ra robot thật ở dây chuyền sản xuất — và nó fail ngay lần đầu tiên. Đây là lab-to-real gap, bài toán cốt lõi mà cả ngành robotics đang vật lộn.

Ba nguyên nhân chính khiến VLA models fail khi deploy thực tế:

1. Action space quá hẹp — hầu hết models chỉ biết dual-arm 7DoF. Robot thật có mobile base, waist, dexterous hands.
2. Data không đủ đa dạng — train trên 1 loại robot, test trên loại khác → distribution shift nghiêm trọng.
3. Thiếu temporal reasoning — model chỉ "nhìn hiện tại → hành động", không dự đoán được hệ quả.

LingBot-VLA 2.0 từ Robbyant (nhánh AI của Ant Group, Trung Quốc) giải quyết cả ba điểm yếu này bằng một kiến trúc mới với 60.000 giờ dữ liệu thực tế và ba đổi mới kỹ thuật: MoE Action Expert, Dual-Query Distillation, và Unified 55D Action Space.

Tổng Quan: LingBot-VLA 2.0

Framework LingBot-VLA 2.0 — nguồn: repo Robbyant/lingbot-vla-v2

LingBot-VLA 2.0 là mô hình Vision-Language-Action (VLA) 6 tỷ tham số, open-source (Apache 2.0), được thiết kế để chạy cross-embodiment — một model duy nhất điều khiển được 20+ loại robot khác nhau, từ single-arm Franka đơn giản đến humanoid Unitree G1 với 32DoF.

Thông số kỹ thuật chính:

So với phiên bản 1.0 (tháng 1/2026), version 2.0 có ba nâng cấp cốt lõi:

• Data pipeline mới hoàn toàn — 60.000 giờ thay vì ~10.000 giờ, qua bộ lọc chất lượng nghiêm ngặt
• MoE action expert — sparse Mixture-of-Experts thay cho dense network
• Dual-Query Distillation — kỹ thuật mới giúp model "nhìn trước" tương lai

Phần 1: 60.000 Giờ Dữ Liệu — Pipeline Từ Raw Đến Clean

Con số 60.000 giờ nghe rất ấn tượng. Để dễ hình dung: π0.5 (Physical Intelligence) dùng ~10.000 giờ, GR00T N1.7 (NVIDIA) ~22.000 giờ. Vậy Robbyant có được từ đâu, và quan trọng hơn, chất lượng như thế nào?

Cấu trúc dataset

20 robot configs bao gồm:

• Single-arm: Franka Panda, Flexiv Rizon 4
• Dual-arm: AgileX Cobot Magic, ARX Lift2, UR7e
• Half-humanoid: AgiBot G1, Galbot G1, Astribot S1 (lên đến 25DoF)
• Full humanoid: Unitree G1, Fourier GR-2, AgiBot A2 (26-32DoF)

Pipeline xử lý dữ liệu

Đây là phần mà nhiều team bỏ qua — thu thập data thô chưa đủ, vấn đề mấu chốt là chất lượng dữ liệu.

Cho robot data — bốn bước lọc:

Bước 1: Jerk-based trajectory smoothness check
  → Tính jerk (đạo hàm bậc 3 của vị trí theo thời gian)
  → Tính Z-score của jerk trên toàn trajectory
  → Loại bỏ segments có jerk bất thường
    (robot bị giật đột ngột, slip khỏi object, hardware lag)

Bước 2: State replay validation
  → Phát lại sequence action lên physics simulator
  → So sánh resulting state trajectory với recorded trajectory
  → Loại bỏ nếu deviation vượt threshold
    (phát hiện: data recording bị lag, clock drift)

Bước 3: Video-state alignment verification
  → Sample ngẫu nhiên 5% data để human review
  → Kiểm tra video frame có khớp với robot state không
  → Đảm bảo không có timestamp mismatch

Bước 4: Minimum quality threshold
  → Giữ chỉ những clips có ≥ 20% valid frames
  → Loại bỏ clips quá ngắn hoặc quá nhiều artifacts

Cho egocentric human video — quy trình phức tạp hơn:

Human video không có joint angles hay end-effector positions. Để biến video thành robot training data, team dùng computer vision pipeline:

1. VLM pre-filtering
   → Dùng large language model để analyze video content
   → Giữ chỉ clips chứa manipulation sequences
   → Loại: ăn uống, đi bộ, viết lách, không liên quan

2. SLAM camera pose estimation
   → Tính trajectory của camera trong 3D world space
   → Xác định reference frame cho mọi frame video

3. MANO hand pose recovery
   → Fit MANO (hand mesh model) vào mỗi frame
   → Thu được 3D joint positions của ngón tay + cổ tay

4. World-frame trajectory lifting
   → Chuyển hand poses từ camera frame sang world frame
   → Ánh xạ sang robot action space tương ứng

5. Quality control cuối
   → Physiological constraint check (góc khớp trong giới hạn sinh lý)
   → Loại bỏ clips có tracking failure
   → Minimum 20% valid frame ratio

Kết quả: Human video trở thành "free robot data" không cần teleop, không cần robot thật. Đây là cách Robbyant scale data mà không cần thuê ngàn người teleop.

Phần 2: Unified 55D Action Space — Ngôn Ngữ Chung Cho 20 Robot

Thách thức khi dạy một model điều khiển 20 loại robot: mỗi robot có cấu trúc khác nhau. Franka: 7DoF joint. Unitree G1: 23DoF. AgileX Cobot Magic: 14DoF dual-arm. Làm sao train một model duy nhất cho tất cả?

Giải pháp: ánh xạ tất cả vào không gian 55 chiều chuẩn.

Thiết kế thông minh: Robot nào không có một component thì set các chiều đó = 0. Single-arm robot set left arm = 0. Robot không có mobile base set 3D mobility = 0. Model học được "khi nào cần activate chiều nào" từ data.

Hai lựa chọn action representation:

Ablation study chỉ ra rằng relative joint positions (delta từ state hiện tại) tốt hơn hẳn absolute positions (6DoF pose trong world frame):

Lý do: relative positions giảm dependency vào global calibration — robot không cần biết chính xác mình đang ở đâu trong không gian, chỉ cần biết cần di chuyển bao nhiêu.

Quan trọng về normalization — tại sao MeanStd tốt hơn MinMax:

Team dùng MeanStd normalization clip ở [-3σ, +3σ] thay vì min-max thông thường. Lý do kỹ thuật: khoảng 10% trajectories trong dataset chứa corrective motions — robot đang tự sửa lỗi, grip lại object, điều chỉnh sau khi slip. Những motion này có amplitude > 1.5σ so với bình thường. MinMax normalization compress những giá trị này về gần 0, làm mất thông tin quan trọng nhất cho robustness.

Phần 3: MoE Action Expert — Scale Thông Minh Hơn Dense Network

Thay vì một action decoder dense network đơn giản, LingBot-VLA 2.0 dùng token-level sparse Mixture-of-Experts cho action head.

Công thức MoE:

m_ℓ(u) = E_shared(u) + λ · Σⱼ g_j(u) · E_routed_j(u)

Trong đó:
- E_shared(u)    : shared expert — học universal control priors
                  (áp dụng cho mọi robot, mọi task)
- E_routed_j(u) : N routed experts — mỗi expert specialized
                  (một số chuyên về arm, số khác về mobile base...)
- g_j(u)        : routing weight dùng sigmoid (không phải softmax)
                  → mỗi token có thể activate NHIỀU expert cùng lúc
- λ              : scaling factor cho contribution của routed experts

Tại sao sigmoid routing thay vì softmax?

Softmax routing (top-K selection) buộc mỗi token phải chọn K expert "duy nhất" — các expert khác bị ignore hoàn toàn. Sigmoid routing cho phép mỗi token nhận contribution từ nhiều expert theo mức độ khác nhau. Với cross-embodiment robot control, một action token thường cần blend kiến thức từ nhiều loại robot — sigmoid phù hợp hơn.

Load balancing không cần auxiliary loss:

Vấn đề kinh điển của MoE: nếu không có ràng buộc, model sẽ collapse vào một vài expert "yêu thích" và ignore phần còn lại. Cách truyền thống là thêm auxiliary load balancing loss vào total loss — nhưng điều này tạo trade-off với primary task loss.

LingBot-VLA 2.0 dùng routing correction biases (lấy ý tưởng từ DeepSeek-V3): tự động điều chỉnh bias của các gate routing để cân bằng load mà không cần explicit loss term.

Kết quả: MoE đạt lower training loss và lower validation error so với dense counterpart dưới cùng compute budget.

Phần 4: Dual-Query Distillation — Dạy Robot "Nhìn Trước"

Đây là đổi mới kỹ thuật thú vị nhất của LingBot-VLA 2.0. Ý tưởng cốt lõi: thay vì chỉ "quan sát hiện tại → hành động", model được train để đồng thời hiểu geometry của scene và dynamics tương lai.

Cơ chế hai learnable queries:

Q_t (Current Query):
  → Appended vào visual + text tokens
  → Supervised bởi LingBot-Depth teacher model
  → Loss: ||Proj_depth(Q_t) - D_t||₁
  → Học: 3D geometry của scene hiện tại (depth map)
  → Ý nghĩa: robot biết chính xác vật thể cách mình bao xa

Q_{t+T} (Future Query):
  → Appended sau Q_t
  → Supervised bởi DINO-Video teacher model
  → Loss: ||Proj_video(Q_t) - Z_t||_F²  (Frobenius norm)
  → Học: visual representation của scene sau T timesteps
  → Ý nghĩa: robot "hình dung" scene sẽ trông như thế nào sau action

DINO-Video là gì?

Robbyant tự xây dựng DINO-Video — một video representation model:

• Base: Extend DINOv3 (image foundation model) với temporal attention
• Temporal attention: Causal attention (chỉ attend tới past frames, không nhìn future)
• Position encoding: 3D-RoPE (Rotary Position Embedding) cho spatial + temporal dimensions
• Training data: 5 triệu video clips
• Output: Feature vector Z_t đại diện cho visual state tại thời điểm t+T

Tại sao cần cả depth và video teacher?

Hai teacher cung cấp hai loại thông tin bổ sung cho nhau:

• LingBot-Depth (depth teacher): cho biết where things are — spatial understanding, crucial cho grasping và placing
• DINO-Video (video teacher): cho biết how things will change — temporal understanding, crucial cho long-horizon planning

Kết quả thực tế: model phát triển được anticipatory behavior — có thể điều chỉnh trajectory trước khi lỗi xảy ra, thay vì chờ bị stuck rồi mới sửa.

Cài Đặt Môi Trường

Requirements

# Clone repo
git clone https://github.com/Robbyant/lingbot-vla-v2
cd lingbot-vla-v2

# Yêu cầu hệ thống:
# - Python 3.12
# - PyTorch 2.8.0
# - Flash-attn 2.8.3
# - CUDA 12.x
# - RAM: ≥ 64GB (khuyến nghị)
# - GPU VRAM: ≥ 24GB cho inference, ≥ 80GB×8 cho training

# Tạo conda environment tự động
bash tools/create_train_env.sh
conda activate lingbot-vla-v2

Download model weights

# Checkpoint chính (6B params)
huggingface-cli download robbyant/lingbot-vla-v2-6b \
    --local-dir ./checkpoints/lingbot-vla-v2-6b

# Vision-language backbone (bắt buộc)
huggingface-cli download Qwen/Qwen3-VL-4B-Instruct \
    --local-dir ./checkpoints/Qwen3-VL-4B-Instruct

# Depth encoder (cho Dual-Query Distillation)
huggingface-cli download robbyant/MoGe-2-vitb-normal \
    --local-dir ./checkpoints/MoGe-2-vitb-normal

Fine-tuning Với Dữ Liệu Của Bạn

LingBot-VLA 2.0 sử dụng LeRobot v2.1/v3.0 format — cùng format với phần lớn VLA framework hiện đại, dễ integrate.

Bước 1: Chuẩn bị dataset

# Dataset cần ở định dạng LeRobot
# Xem hướng dẫn convert tại: https://github.com/huggingface/lerobot

# Cấu trúc thư mục:
# data/
#   my_robot_dataset/
#     meta/
#       info.json          # dataset metadata
#       episodes.jsonl     # episode list
#     videos/              # camera recordings
#     data/                # robot states + actions

Bước 2: Định nghĩa robot config

# configs/robots/my_robot.yaml
# Ánh xạ features từ robot của bạn sang 55D unified space

robot_name: "my_franka_robot"
embodiment_type: "single_arm"  # single_arm | dual_arm | half_humanoid | humanoid

# Mapping các dimension
feature_mapping:
  # Arm joints (7DoF left arm, right arm = 0)
  left_arm_joints:
    source_keys: ["observation.state.joint_positions"]  # key trong dataset
    target_indices: [0, 1, 2, 3, 4, 5, 6]             # indices trong 55D vector
    representation: "relative"                          # relative | absolute
  
  # Gripper
  left_gripper:
    source_keys: ["observation.state.gripper_pos"]
    target_indices: [28]                                # index 28 = left gripper
    representation: "absolute"
  
  # Các chiều không dùng → tự động = 0
  # right_arm, waist, head, mobile_base đều được mask

# Normalization
normalization:
  type: "meanstd"
  clip_ratio: 3.0  # clip ở ±3σ

Bước 3: Tính normalization statistics

python scripts/compute_norm_stats.py \
    --dataset-path ./data/my_robot_dataset \
    --robot-config configs/robots/my_robot.yaml \
    --output-path ./data/my_robot_dataset/norm_stats.json

Bước 4: Fine-tune

# Single GPU (chậm, chỉ cho thử nghiệm)
python tasks/vla/train.py \
    --config configs/train/lingbot_vla_v2_finetune.yaml \
    --dataset-path ./data/my_robot_dataset \
    --checkpoint ./checkpoints/lingbot-vla-v2-6b \
    --output-dir ./outputs/my_finetune \
    --num-gpus 1 \
    --batch-size 4

# Multi-GPU (production)
torchrun --nproc_per_node=8 tasks/vla/train.py \
    --config configs/train/lingbot_vla_v2_finetune.yaml \
    --dataset-path ./data/my_robot_dataset \
    --checkpoint ./checkpoints/lingbot-vla-v2-6b \
    --output-dir ./outputs/my_finetune

Config quan trọng trong training:

# configs/train/lingbot_vla_v2_finetune.yaml
training:
  # Sequence-wise auxiliary loss — cải thiện stability đáng kể
  sequence_wise_auxiliary_loss: true
  
  # MoE routing regularization
  z_loss_weight: 0.001
  
  # Optional: Muon optimizer (experimental, có thể unstable)
  muon_optimizer: false
  
  # Learning rate schedule
  lr: 2e-5
  warmup_steps: 100
  
  # Diffusion denoising steps
  num_inference_steps: 10  # 10 cho production, 20 cho higher accuracy

Inference Trên Robot Thật

from deploy.lingbot_vla_v2_policy import LingBotVLA2Policy
import numpy as np

# Load model
policy = LingBotVLA2Policy(
    checkpoint_path="./checkpoints/lingbot-vla-v2-6b",
    robot_config="configs/robots/my_robot.yaml",
    device="cuda:0"
)

# Control loop
def run_policy_loop(robot, camera):
    instruction = "Pick up the red cup and place it on the tray"
    
    while not task_complete:
        # Thu thập observation
        observation = {
            "image": camera.get_frame(),          # numpy (H, W, 3)
            "instruction": instruction,            # ngôn ngữ tự nhiên
            "robot_state": robot.get_state()       # joint positions + gripper
        }
        
        # Inference (~130ms trên RTX 4090D)
        action_55d = policy.get_action(observation)
        
        # Map từ 55D về actual robot commands
        robot_commands = policy.decode_action(action_55d)
        robot.execute(robot_commands)

# Thực thi
run_policy_loop(my_robot, my_camera)

Latency breakdown thực tế:

• Visual encoding (Qwen3-VL): ~40ms
• MoE action expert (10 denoising steps): ~70ms
• Overhead: ~20ms
• Tổng: ~130ms → 7-8Hz control loop

Với robot yêu cầu faster control (>10Hz), có thể giảm xuống 5 denoising steps (~70ms) với accuracy giảm nhẹ.

Kết Quả Benchmark

GM-100 — Bimanual Manipulation (Shanghai Jiao Tong University)

GM-100 là benchmark 9 task đánh giá generalist dual-arm manipulation, gồm các task như: lấy chìa khóa, sắp xếp đồ chơi, gói bánh, etc.

Format: Task Progress (%) / Success Rate (%)

Kết quả nổi bật: Task "Retrieve Keychain" đạt 100%/100% trên AgileX — hoàn hảo. Task "Pick Out Toy Bones" (yêu cầu fine manipulation): 87.5%/70%.

Long-Horizon Mobile Manipulation

Đây là điểm mạnh nhất của LingBot-VLA 2.0 — những task đòi hỏi robot di chuyển + thao tác vật thể qua nhiều bước.

So Sánh Với Các VLA Khác

Ưu điểm rõ ràng: breadth (bao phủ nhiều embodiment nhất) + data scale (6× so với π0.5). Nhược điểm: cần GPU mạnh, training cost cao.

Những Pitfall Cần Tránh Khi Deploy

1. Robot config mapping sai là lỗi nguy hiểm nhất

Nếu ánh xạ features từ robot vào 55D space không chính xác, model sẽ ra action kỳ lạ mà không có error message. Luôn verify bằng cách log raw 55D output và kiểm tra chiều nào đang active.

2. Normalization statistics phải tính trên dataset của bạn

Không dùng norm stats từ pretrain checkpoint cho fine-tuned model. Sau fine-tuning trên data mới, action distribution thay đổi — cần recompute.

3. GPU memory management

6B params + activations + optimizer states: cần ít nhất 80GB VRAM để train đầy đủ. Với 24GB (RTX 4090), chỉ có thể chạy inference hoặc LoRA fine-tuning với gradient checkpointing.

4. Mobile base sync latency

Khi robot có mobile base: action vector 3D mobility (index 52-54) ra lệnh cho base, còn arm joints ra lệnh cho cánh tay — phải sync chính xác. Mismatch > 50ms gây coordination issues rõ rệt, đặc biệt khi vừa di chuyển vừa thao tác.

5. Diffusion steps trade-off

5 steps  → ~70ms  → 7-10% accuracy drop (OK cho fast tasks)
10 steps → ~130ms → Baseline accuracy (recommended)
20 steps → ~250ms → ~2-3% accuracy gain (diminishing returns)

Kết Luận

LingBot-VLA 2.0 đặt ra tiêu chuẩn mới về data scale và embodiment coverage trong VLA ecosystem năm 2026. Ba đổi mới kỹ thuật chính — Unified 55D Action Space, MoE Action Expert, và Dual-Query Distillation — giải quyết trực tiếp những bottleneck của VLA deployment thực tế.

Điểm đáng chú ý nhất không phải benchmark số, mà là triết lý thiết kế: thay vì optimize cho một robot/task cụ thể, team Robbyant đầu tư vào infrastructure (data pipeline, unified action space) để scale tự nhiên. Đây là cách build một foundation model thực sự, không phải một task-specific policy.

Với Apache 2.0 license, 6B checkpoint public, và codebase sạch trên LeRobot format — đây là model đáng thử nghiệm cho mọi team đang nghiên cứu cross-embodiment VLA hoặc mobile manipulation.

Paper: arXiv 2607.06403 — From Foundation to Application
Code: github.com/Robbyant/lingbot-vla-v2
Checkpoint: HuggingFace robbyant/lingbot-vla-v2-6b

Bài Viết Liên Quan

• LingBot-VA: Causal World Model cho Robot Manipulation
• VLA Mobile Manipulation với LeRobot — Hướng Dẫn Thực Hành
• HEX-VLA: Cross-Embodiment Humanoid Whole-Body Control