VLASH: VLA Real-Time với Async Inference 11.8×

Vấn đề: Robot đứng im trong khi "não" đang nghĩ

Hãy tưởng tượng bạn đang chơi bóng bàn với một cây vợt bị lag 500ms. Bóng bay đến, bạn thấy, nhưng tay bạn phản ứng nửa giây sau. Kết quả? Bóng đã qua từ lâu.

Đây chính xác là vấn đề của hầu hết các VLA (Vision-Language-Action model) hiện tại khi chạy trên robot thực. Một mô hình như π₀.₅ cần từ 500–560ms để tính toán action — trong thời gian đó, robot phải đứng im hoặc tiếp tục thực thi action cũ. Khi inference xong, thế giới đã thay đổi, nhưng action được tính dựa trên frame ảnh cũ. Kết quả là robot phản ứng chậm, giật cục, và hoàn toàn không thể xử lý các tác vụ động như đánh bóng bàn hay đập whack-a-mole.

VLASH (MIT Han Lab, arXiv 2512.01031) giải quyết bài toán này bằng một ý tưởng elegantly simple: thay vì đợi và đoán từ frame cũ, hãy ước tính trước robot sẽ ở đâu lúc action được thực thi, rồi tính action dựa trên vị trí đó.

Kết quả: reaction latency giảm 11.8× trên H100, robot đánh được bóng bàn với tỷ lệ thành công 55% (trong khi các baseline đều 0%), mà không cần thay đổi kiến trúc model.

Paper gốc: VLASH — arXiv 2512.01031, MIT Han Lab, Tsinghua, UC Berkeley, NVIDIA, Caltech, UCSD

Tại sao Asynchronous Inference là con đường đúng?

Trước khi đi vào VLASH, hãy hiểu tại sao vấn đề này khó đến vậy.

Synchronous inference (cách thông thường):

t=0: Chụp frame → gửi vào model
t=0 → t+Δ: Robot ĐỨNG IM, chờ model tính
t=Δ: Nhận action → bắt đầu thực thi

Với Δ ≈ 500ms, robot mất nửa giây mỗi lần cần "nhìn" lại. Đây là lý do VLA truyền thống không thể xử lý tác vụ thời gian thực.

Naive asynchronous (cách đơn giản nhất):

t=0: Chụp frame → gửi vào model
t=0 → t+Δ: Robot TIẾP TỤC THỰC THI action cũ (không đứng im nữa)
t=Δ: Model tính xong → nhưng tính dựa trên state s₁ (t=0)
       Trong khi robot đã ở state s₃ (t=Δ) rồi!

Vấn đề: Misalignment — model tính action cho robot ở position A, nhưng robot thực ra đang ở position B. Kết quả là chuyển động giật cục, đứt đoạn, thậm chí nguy hiểm.

VLASH giải quyết cả hai: robot vẫn chạy liên tục (không đứng im), VÀ model tính action dựa trên state đúng — state mà robot sẽ ở vào lúc action bắt đầu thực thi.

Kiến trúc: Future-State-Aware Inference

Ý tưởng cốt lõi của VLASH rất trực quan:

"Tôi đã ra lệnh cho robot thực hiện action chunk [a₁, a₂, a₃, ...]. Vậy Δ giây nữa, robot sẽ ở đâu? Tôi có thể tính được — chỉ cần cộng các action đó vào state hiện tại."

Cụ thể:

Biết: state hiện tại s₁ (lúc t=0)
Biết: action chunk đang thực thi [a₁, a₂] (đã ra lệnh ở bước trước)
Ước tính: s₃ = s₁ + a₁ + a₂  ← state lúc t=Δ
Gửi vào model: (frame_t=0, s₃)
Model trả về: action chunk sẽ thực thi từ t=Δ trở đi → KHỚP với thực tế

Đây là future-state rollout: dùng action chunk đã biết để forward-simulate vị trí robot, rồi condition model trên vị trí đó thay vì vị trí hiện tại.

VLASH không yêu cầu thay đổi kiến trúc model. Với các VLA dùng text encoding cho state (như π₀.₅), bạn chỉ cần update state token trong prompt. Một lightweight state projection layer tùy chọn có thể cải thiện smoothness thêm, nhưng không bắt buộc.

Temporal-Offset Fine-tuning

Tuy nhiên, chỉ thay đổi inference thôi là chưa đủ — model phải được dạy để hiểu future states. VLASH thêm bước temporal-offset fine-tuning:

Trong quá trình training, thay vì chỉ dùng cặp (observation_t, state_t) → action_t, VLASH tạo ra thêm các cặp augmented:

(observation_t, state_{t+δ}) → action_{t+δ}

với δ là một random offset từ {0, 1, ..., Δ_max}.

Model học được: "Khi nhận state tương lai, tôi cần predict action tương lai tương ứng." Đây là bước training augmentation đơn giản nhưng quan trọng — không có bước này, model sẽ bị confused khi nhận state không khớp với observation.

Shared Observation Training — 3.26× Faster

Một vấn đề thực tế: nếu mỗi offset δ cần một forward pass riêng, chi phí training tăng Δ_max lần. VLASH giải quyết bằng block-sparse attention masking:

Một sequence = [shared_observation | branch_δ=0 | branch_δ=1 | ... | branch_δ=max]

Tất cả các branch CÙNG attend vào một observation duy nhất (không cần encode lại), nhưng KHÔNG attend vào nhau (mỗi branch độc lập predict action của mình). Kết quả: 3.26× training speedup per step so với train tuần tự từng offset.

Action Quantization: Thêm 1.5–2× Speedup

Ngoài giải quyết misalignment, VLASH còn cung cấp action quantization để làm robot chạy nhanh hơn về mặt vật lý.

Ý tưởng: thay vì thực thi từng action nhỏ (ví dụ: 24 actions/chunk, mỗi action di chuyển 1mm), gom q actions liên tiếp thành một macro-action (di chuyển q×1mm trong cùng thời gian):

Fine-grained: a₀, a₁, a₂, a₃, a₄, a₅ (6 actions riêng lẻ)
Macro (q=2):  â₀=(a₀+a₁), â₁=(a₂+a₃), â₂=(a₄+a₅) (3 macro-actions)

Robot thực thi nhanh gấp q lần. Kết hợp với VLASH's asynchronous inference, bạn có thể đẩy throughput lên cao hơn nhiều so với synchronous baseline.

Thực nghiệm cho thấy q=2 đạt 2× speedup với minimal accuracy loss cho task pick & place. Với task phức tạp hơn như stacking, q=1.5 là điểm balance tốt.

Cài Đặt

Yêu cầu: Python 3.10, CUDA GPU (RTX 4090+ khuyến nghị).

# Tạo conda environment
conda create -n "vlash" python=3.10
conda activate vlash

# Cài ffmpeg (bắt buộc cho video processing)
conda install ffmpeg=7.1.1 -c conda-forge

# Clone repo và cài VLASH
git clone https://github.com/mit-han-lab/vlash.git
cd vlash
pip install -e .

# Cài PyTorch stack
pip install -U torch torchvision torchcodec

VLASH tương thích với LeRobot datasets v2.1 và v3.0, nên nếu bạn đã có dataset LeRobot từ trước, có thể dùng ngay.

Chuẩn Bị Dataset và Model

VLASH hỗ trợ fine-tuning các VLA sau:

• π₀.₅ (phi-0.5) — model chính được paper test
• π₀ (phi-zero)
• SmolVLA — VLA nhỏ gọn, phù hợp GPU nhỏ hơn
• GR00T N1.6 — NVIDIA's foundation model

Để fine-tune với temporal-offset augmentation, bạn cần dataset ở format LeRobot. Cách thu thập data không thay đổi — VLASH augment data trong quá trình training, không phải preprocessing.

Ví dụ cấu trúc config examples/train/pi05/async.yaml:

model:
  name: pi05
  checkpoint: lerobot/pi05  # hoặc checkpoint local

training:
  max_offset: 4          # Δ_max — số bước offset tối đa
  shared_obs: true       # Dùng shared observation encoding
  batch_size: 16

dataset:
  path: path/to/your/lerobot_dataset
  episodes: null         # null = dùng tất cả episodes

Training

# Training VLASH với π₀.₅
vlash train examples/train/pi05/async.yaml

# Theo dõi training với wandb
vlash train examples/train/pi05/async.yaml --wandb.project=vlash-pi05

Training sử dụng LoRA để fine-tune hiệu quả. Shared observation encoding giúp training không bị chậm đáng kể so với training standard VLA.

Một điểm quan trọng: không cần data mới. Bạn dùng đúng dataset robot demos hiện có; VLASH tự động tạo offset samples từ action chunks đã có trong data.

Inference

# Inference cơ bản (asynchronous, không action quantization)
vlash run examples/inference/async.yaml

# Với action quantization (2× speedup vật lý)
vlash run examples/inference/async.yaml --action_quant_ratio=2

VLASH trên RTX 5090 đạt >30Hz inference frequency cho π₀.₅ — đủ cho các tác vụ thời gian thực.

Cấu hình inference examples/inference/async.yaml:

model:
  checkpoint: path/to/vlash_checkpoint  # VLASH-finetuned model

inference:
  async_mode: true
  action_quant_ratio: 1.0    # 1.0 = không quantize, 2.0 = 2× speedup

robot:
  type: so101                # hoặc galaxea_r1, unitree_g1, ...
  control_freq: 30           # Hz

Kết Quả Thực Nghiệm

Reaction Latency (quan trọng nhất)

Tại sao có con số này? Về mặt lý thuyết:

• Synchronous latency = D + 2L (D = execution duration, L = inference latency)
• Async VLASH latency = 2L (chỉ còn inference overhead, loại bỏ execution wait)

Với D >> L (robot execution chậm hơn nhiều so với inference), speedup rất lớn.

LIBERO Simulation Benchmarks

VLASH không chỉ nhanh hơn mà còn chính xác hơn so với naive async:

(SmolVLA trên LIBERO benchmark, average success rate)

Tác Vụ Động — Điểm Nổi Bật Nhất

Đây là kết quả ấn tượng nhất của VLASH — các tác vụ mà VLA truyền thống hoàn toàn không làm được:

Ping-pong (single-return hit rate):

• Synchronous: 0%
• Naive Async: 0%
• RTC (baseline): 0%
• VLASH: 55% ✅

Whack-a-mole (average score trong 30 giây):

• Synchronous: 3.2
• Naive Async: 8.6
• RTC: 11.0
• VLASH: 28.8 ✅

Action Quantization Results (Real Robot)

Với 2× speedup mà chỉ mất 2% accuracy — đây là trade-off rất tốt trong thực tế.

So Sánh với Các Baseline Khác

RTC (Real-Time Chunking, được dùng trong Pi0-FAST trên G1) dùng inpainting trong inference để fill partial chunks — approach này tốt nhưng thêm overhead. VLASH không cần inpainting, chỉ cần update state token.

A2C2 cần thay đổi kiến trúc model — không thể plug-and-play với checkpoint sẵn có. VLASH không yêu cầu điều này.

Khi Nào Nên Dùng VLASH?

Nên dùng khi:

• Robot cần phản ứng với thay đổi môi trường trong <100ms (tác vụ động)
• Bạn đã có checkpoint π₀.₅, GR00T, hoặc SmolVLA và muốn deploy real-time
• GPU của bạn chưa đủ mạnh để đạt 30Hz với synchronous inference
• Tác vụ có temporal sensitivity cao: catching, sorting conveyor belt, human-robot interaction

Cân nhắc thêm khi:

• Tác vụ hoàn toàn static (đặt đồ vật, không có vật chuyển động) — gain thấp hơn
• Robot state không thể estimate từ action forward (ví dụ: joint slip, grasping uncertainty) — cần mechanism bổ sung để update state estimate

Kết Hợp VLASH với Pipeline Hiện Tại

Nếu bạn đang dùng Pi0-FAST với Unitree G1 hoặc các framework LeRobot khác, VLASH có thể được integrate trực tiếp vì cùng dùng LeRobot dataset format.

Workflow điển hình:

1. Thu thập demos với LeRobot teleoperation (không đổi)
2. Push dataset lên HuggingFace Hub (không đổi)
3. Fine-tune với vlash train ... (thêm bước này)
4. Deploy với vlash run ... (thay thế lerobot inference)

Bạn không cần thu thập data mới hay thay đổi robot setup. VLASH augment data trong training và thay đổi inference loop — phần còn lại giữ nguyên.

Pitfalls Cần Tránh

1. Δ_max quá nhỏ: Nếu max_offset trong config nhỏ hơn inference delay thực tế trên hardware của bạn, model sẽ không được train cho delay range đó → accuracy drop. Đo inference latency thực tế trước, set max_offset >= delay_steps.

2. State rollout không chính xác cho grasping tasks: Khi robot đang cầm vật, joint state forward từ action không tính đến contact forces. State estimate có thể drift. Bài toán này vẫn còn open — paper suggest dùng force/torque feedback nếu có.

3. Action quantization ratio quá cao: q=3+ có thể làm mất fine-grained control cần thiết cho manipulation chính xác. Bắt đầu với q=1.5 hoặc q=2, tăng dần và evaluate.

4. Thiếu ffmpeg đúng version: VLASH cần ffmpeg 7.1.1 cụ thể (qua conda-forge) vì torchcodec dependency. Đừng dùng ffmpeg từ apt-get — version mismatch gây lỗi khó debug.

Kết Luận

VLASH là một trong những breakthrough thực tiễn nhất trong VLA deployment năm 2025. Không phải vì kiến trúc mới hay dataset khổng lồ — mà vì nó giải quyết một bottleneck cơ bản: VLA không thể real-time vì nó bị dạy predict từ present, nhưng action lại thực thi ở future.

Bằng cách bridge gap đó với future-state rollout + temporal-offset fine-tuning, VLASH biến π₀.₅ từ một model cần 500ms buffer thành real-time controller chạy 30Hz+. Và quan trọng hơn, nó cho phép VLA làm những việc trước đây là impossible: đánh bóng bàn, đập whack-a-mole, và phản ứng với human motion trong vài chục millisecond.

Code Apache 2.0, hỗ trợ LeRobot format, compatible với π₀.₅/GR00T/SmolVLA — nếu bạn đang build robot manipulation system, VLASH xứng đáng là layer đầu tiên bạn thêm vào inference pipeline.

Tài nguyên:

• GitHub: mit-han-lab/vlash
• Paper: arXiv 2512.01031
• Project page: z-lab.ai/projects/vlash

Bài Viết Liên Quan

• VLA Models: RT-2 → Octo → OpenVLA → π₀ — toàn bộ lịch sử evolution
• LeRobot v0.5: Pi0-FAST + G1 Whole-Body Control — deploy VLA real-time trên humanoid
• DREAM-Chunk: Reactive Action Chunking bằng Latent World Model