ResVLA (ICML 2026): Từ Noise đến Intent — Anchor VLA Policy với Residual Diffusion Bridge

Hãy thử tưởng tượng bạn muốn dạy robot nhặt một chiếc cốc. Bạn nói: "Cầm cái cốc màu đỏ ở góc trái bàn." Não người xử lý câu này trong vài mili-giây, rồi tay bạn thực hiện động tác — nhưng không phải bằng cách tính ngẫu nhiên từng micromovement từ đầu. Não đã biết ý định (nhặt cốc đỏ, đưa lên), rồi cơ bắp chỉ cần tinh chỉnh chi tiết vật lý.

Đây chính xác là vấn đề mà ResVLA (ICML 2026) giải quyết — và cách tiếp cận của nó đủ thanh lịch để thay đổi cách chúng ta thiết kế diffusion-based VLA.

Paper: From Noise to Intent: Anchoring Generative VLA Policies with Residual Bridges
GitHub: 4DVLab/ResVLA
Tác giả: Yiming Zhong, Yaoyu He, Zemin Yang, Pengfei Tian, Yifan Huang, Qingqiu Huang, Xinge Zhu, Yuexin Ma (ShanghaiTech University, Morphic Robotics, CUHK)

Hình 1: ResVLA chuyển paradigm từ "Generation-from-Noise" sang "Refinement-from-Intent". Thay vì bắt đầu từ Gaussian noise thuần túy, mô hình dự đoán intent toàn cục trước, rồi tinh chỉnh residual — nguồn: arXiv 2604.21391

1. Vấn Đề: "Generation-from-Noise" Đang Lãng Phí Gì?

Mọi diffusion-based VLA hiện tại — từ Diffusion Policy đến π₀ — đều hoạt động theo paradigm "Generation-from-Noise": bắt đầu từ Gaussian noise N(0, I) thuần túy, rồi dần dần denoising để ra action sequence.

Điều này có hai vấn đề nghiêm trọng:

Vấn đề 1: Representation Inefficiency (Lãng phí capacity mô hình)

Gaussian noise không mang bất kỳ thông tin nào về task. Vậy là mô hình phải dùng phần lớn capacity để "khám phá lại" ý định toàn cục — rằng đây là task nhặt đồ chứ không phải task đẩy, rằng target là cái cốc đỏ chứ không phải cái xanh, rằng quỹ đạo cần đi về phía trái bàn.

Đây là công việc lặp lại không cần thiết. VLM backbone đã hiểu câu lệnh ngôn ngữ và hình ảnh. Tại sao diffusion head lại phải "re-invent" toàn bộ điều đó từ noise?

Vấn đề 2: Loss Collapse (Hướng dẫn ngôn ngữ bị bỏ qua)

Khi source distribution N(0, I) độc lập hoàn toàn với điều kiện đầu vào c (language + image), gradient flow từ loss đến condition encoder trở nên yếu — gần như bằng không. Hiện tượng này ResVLA gọi là Loss Collapse (Theorem 3.3 trong paper): mutual information I(x₀; c) = 0 khi source là pure noise → gradient "short-circuit", không lan ngược đến language condition.

Hệ quả thực tế: mô hình học được action "trung bình" chung chung nhưng không bám vào language instruction cụ thể. Nếu bạn từng train VLA và thấy robot cứ thực hiện cùng một action bất kể bạn nói "nhặt lên" hay "đặt xuống" — đây chính xác là Loss Collapse.

2. Insight Cốt Lõi: Chuyển Động = Intent + Dynamics

ResVLA dựa trên một quan sát tưởng chừng đơn giản nhưng rất sâu sắc:

Chuyển động robot tự nhiên phân tách thành hai thành phần: ý định toàn cục (global intent) và động lực cục bộ (local dynamics).

• Global intent (thấp tần, deterministic): quỹ đạo tổng thể — robot sẽ di chuyển về phía cốc, mở tay kẹp, hạ xuống, đóng lại. Đây là "what" và "where" của task. Thành phần này biến đổi chậm, có thể được dự đoán từ language + vision.
• Local dynamics (cao tần, stochastic): các microadjustment — chính xác bao nhiêu lực, góc xoắn bao nhiêu độ, tốc độ tinh chỉnh từng millisecond khi tiếp xúc với vật thể. Đây là "how exactly" ở cấp vật lý. Thành phần này biến đổi nhanh, phụ thuộc vào trạng thái môi trường tức thời.

Sự phân tách này không phải heuristic — đây là cách trajectory planning và reactive control vẫn được thiết kế tách biệt trong hệ thống robot classical. ResVLA làm điều tương tự nhưng trong một unified learning framework.

Vậy thay vì học cả hai từ noise, ResVLA đề xuất:

1. Dự đoán intent deterministically từ VLM features (Stage 1)
2. Tinh chỉnh residual — phần stochastic còn lại — từ intent đã anchor (Stage 2)

3. Phân Tích Phổ: DCT Tách Tần Số Cao và Thấp

Để thực hiện ý tưởng trên, ResVLA dùng Discrete Cosine Transform (DCT) — cùng công cụ mà JPEG dùng để nén ảnh (tách "hình dạng tổng thể" ra khỏi "chi tiết nhiễu").

Với action sequence x ∈ ℝ^(T×D) (T bước thời gian, D chiều action space):

x_S = DCT_S(x)    # Low-frequency components: Semantic subspace (global intent)  
x_E = DCT_E(x)    # High-frequency components: Execution subspace (local dynamics)

# Hai subspace bổ sung nhau và cộng lại thành action đầy đủ:
x = x_S + x_E

Tại sao DCT mà không phải wavelet hay PCA? Ba lý do thực tế:

1. Basis cố định, không cần học: DCT basis là orthogonal cosine functions, không có thêm parameters để optimize.
2. Energy compaction tốt: >80% variance của smooth trajectory nằm trong ~30% low-freq modes đầu tiên.
3. Computationally trivial: FFT-based DCT chỉ tốn O(N log N), không đáng kể so với forward pass của VLM.

4. Kiến Trúc ResVLA: Hai Giai Đoạn Cascading

ResVLA xây dựng trên Qwen3-VL-2B-Instruct làm backbone VLM (2B parameters — nhỏ hơn nhiều so với π₀ 3B hay GR00T N1 7B+), với hai module chính:

Stage 1: Intent Anchoring Module

Module này nhận VLM features từ Qwen3-VL và dự đoán deterministically thành phần thấp tần của action:

μ_prior(c) = IntentAnchorModule(VLM_features(image, language_instruction))

Sau đó ResVLA xây dựng condition-dependent source distribution (thay vì N(0, I) thuần túy):

p₀(x|c) = 𝒩(x; μ_prior(c), σ²_min · I)

Đây là điểm then chốt: thay vì bắt đầu diffusion từ pure noise, ta bắt đầu từ một Gaussian hẹp xung quanh dự đoán intent — rất gần với distribution của target action. σ_min rất nhỏ (ví dụ 0.001), nên variance quanh anchor là tối thiểu.

Stage 2: Residual Diffusion Bridge

Từ distribution đã anchor, Residual Diffusion Bridge học transport path từ source đã anchor → target action distribution, dùng Conditional Flow Matching (CFM):

# Velocity field với optimal transport path:
v_t(x_t) = x₁ - x₀
# x₁ = ground truth action
# x₀ ~ p₀(x|c) = 𝒩(μ_prior(c), σ²_min · I)

Velocity field bây giờ chỉ cần học residual nhỏ Δx = x_gt - x₀. Vì x₀ đã gần x₁ (nhờ anchor tốt), transport cost (kinetic energy) tối thiểu → path thẳng hơn → ít bước integration hơn → NFE=1 viable.

Đây là lý do tại sao ResVLA gọi module này là "Residual Diffusion Bridge" — nó "bắc cầu" ngắn từ intent đến action, không phải đi đường dài từ noise.

5. Hàm Loss: Bi-Level Optimization

Training objective gồm hai phần phối hợp:

# L_total = λ_sem × L_semantic + L_residual

# Phần 1: Intent Anchoring Loss
# Căn chỉnh dự đoán intent với low-freq ground truth
L_semantic = ||μ_prior(c) - x_S||²   # MSE on semantic subspace

# Phần 2: Residual Flow Matching Loss  
# Học velocity field để transport từ anchor đến target
L_residual = E_{t, x_t} ||v_θ(x_t, t, c) - (x_gt - x₀)||²

Hai loss hoạt động hợp tác:

• L_semantic tốt → anchor chính xác → khoảng cách x₀ đến x₁ nhỏ → L_residual dễ học hơn
• L_residual converge → mô hình hiểu rõ hơn execution space → feedback cải thiện intent prediction

Đây là sự khác biệt với các approach train hai stage riêng biệt (pre-train intent, fine-tune residual): ResVLA train end-to-end, hai loss ảnh hưởng lẫn nhau qua shared VLM backbone.

6. Inference: "Predict-Refine" Flow

Quá trình inference rất trực quan, gồm 2 bước:

# Bước 1: Predict intent (deterministic, không có stochasticity)
mu_prior = intent_anchoring_module(vl_features(image, language))

# Bước 2: Sample từ anchored distribution
x_0 = mu_prior + sigma_min * torch.randn_like(mu_prior)

# Bước 3: Tinh chỉnh residual via numerical integration (ODE)
# Euler method (NFE=1) — đủ vì residual nhỏ:
x_hat = x_0 + v_theta(x_0, t=0.0, condition=c)

# Hoặc dùng multi-step cho accuracy cao hơn:
# x_hat = ode_solve(v_theta, x_0, t_span=[0, 1], method='euler', n_steps=4)

NFE=1 viable: vì transport path từ anchor đến target rất ngắn và gần thẳng (do anchor đã gần target), một bước Euler duy nhất đã đạt >70% success rate — so với baseline cần NFE=4 để đạt tương đương. Điều này quyết định về latency trong real-time robot control.

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

Yêu cầu hệ thống

Python 3.10
PyTorch 2.6.0 + CUDA 12.4
FlashAttention (bắt buộc cho Qwen3-VL backend)
GPU training: ít nhất 1× A100 40GB
GPU eval: 1× RTX 3090 24GB hoặc tương đương

Clone và cài đặt

git clone https://github.com/4DVLab/ResVLA.git
cd ResVLA

# Tạo conda environment
conda create -n resvla python=3.10 -y
conda activate resvla

# Cài PyTorch với CUDA 12.4
pip install torch==2.6.0 torchvision==0.21.0 \
  --index-url https://download.pytorch.org/whl/cu124

# Cài project dependencies
pip install -r requirements.txt
pip install -e .

# Cài FlashAttention (compile từ source — mất ~10-15 phút)
pip install flash-attn --no-build-isolation

Tải VLM backbone

ResVLA dùng Qwen3-VL-2B-Instruct — mô hình vision-language 2B parameters:

python -c "
from huggingface_hub import snapshot_download
snapshot_download(
    'Qwen/Qwen3-VL-2B-Instruct',
    local_dir='./checkpoints/qwen3vl'
)
"

8. Chuẩn Bị Dữ Liệu

LIBERO (manipulation benchmark chuẩn)

LIBERO gồm 90 tasks đa dạng (LIBERO-90) với ~50K expert demonstrations, là benchmark thực tế nhất cho tabletop manipulation.

# Tự động tải và chuẩn bị LIBERO dataset
bash examples/LIBERO/data_preparation.sh

Script này tải raw LIBERO data và convert sang format LeRobot — cùng format mà LeRobot ecosystem sử dụng.

SimplerEnv / Open X-Embodiment

Để train và eval trên SimplerEnv (Google Robot và WidowX):

# Cấu trúc thư mục cần có:
playground/
└── Datasets/
    └── SimplerEnv/
        ├── bridge/    # Bridge dataset (LeRobot format)
        └── fractal/   # Fractal dataset (LeRobot format)

# Tải bridge dataset:
python -c "
from huggingface_hub import snapshot_download
snapshot_download('lerobot/bridge_v2', local_dir='playground/Datasets/SimplerEnv/bridge')
"

# Tải fractal dataset:
python -c "
from huggingface_hub import snapshot_download
snapshot_download('lerobot/fractal20220817_data', local_dir='playground/Datasets/SimplerEnv/fractal')
"

9. Training

Training trên LIBERO

# Chạy training script (điều chỉnh GPU và batch size cho hardware)
bash examples/LIBERO/train_files/run_libero_train_resVLA.sh

Các tham số quan trọng nhất bên trong script:

CUDA_VISIBLE_DEVICES=0,1,2,3 \
torchrun --nproc_per_node=4 \
  train_resVLA.py \
  --model_name_or_path ./checkpoints/qwen3vl \
  --dataset_path playground/Datasets/LIBERO/libero_90 \
  --batch_size 16 \
  --learning_rate 1e-4 \
  --num_epochs 20 \
  --lambda_sem 1.0 \         # Trọng số cho L_semantic
  --dct_low_freq_ratio 0.3 \ # 30% modes đầu = semantic subspace
  --sigma_min 0.001 \        # Variance của anchored distribution
  --output_dir ./outputs/libero

Tham số cần hiểu rõ:

• --dct_low_freq_ratio 0.3: 30% low-freq modes đầu tiên được coi là semantic subspace (nơi L_semantic optimize). Paper thử nghiệm nhiều giá trị, 0.3 cho kết quả tốt nhất trên LIBERO.
• --lambda_sem 1.0: cân bằng giữa L_semantic và L_residual. Tăng → anchor chính xác hơn nhưng residual tinh tế hơn khó học.
• --sigma_min 0.001: variance của anchored distribution. Nhỏ → anchor chặt hơn, nhưng nếu intent prediction sai thì không có "safety net".

Training trên SimplerEnv / OXE

bash examples/SimplerEnv/train_files/run_oxe_train_ResVLA.sh

Thời gian ước tính (4× A100 40GB):

• LIBERO-90: ~12–15 giờ
• SimplerEnv/OXE: ~24–36 giờ

10. Dùng Pretrained Checkpoints (Không Cần Train Lại)

Nếu muốn thử nghiệm nhanh hoặc eval baseline, dùng checkpoints đã public:

# LIBERO checkpoint (Qwen3-VL-2B backbone, train trên LIBERO-90)
python -c "
from huggingface_hub import snapshot_download
snapshot_download(
    'GaussionZhong/resvla_libero_all_2B',
    local_dir='./checkpoints/libero'
)
"

# SimplerEnv checkpoint (train trên Bridge + Fractal)
python -c "
from huggingface_hub import snapshot_download
snapshot_download(
    'GaussionZhong/resvla_simpler_env_2B',
    local_dir='./checkpoints/simpler'
)
"

11. Evaluation và Inference

Chạy eval trên LIBERO

ResVLA dùng kiến trúc client-server: policy server chạy mô hình, simulator client gọi API để lấy action.

# Terminal 1: Khởi động ResVLA policy server
python resVLA/policy_server.py \
  --checkpoint ./checkpoints/libero \
  --host 0.0.0.0 \
  --port 8000

# Terminal 2: Chạy LIBERO simulator và gọi policy
cd examples/LIBERO
python eval_libero.py \
  --server_url http://localhost:8000 \
  --num_episodes 50    # Số episode per task

Chi tiết đầy đủ: xem examples/LIBERO/README.md.

LIBERO-Plus (Robustness Test)

LIBERO-Plus là bộ eval mở rộng với 3 loại perturbation để test robustness thực sự:

1. Language variation: thay đổi cách diễn đạt lệnh (synonym, restructure câu)
2. Robot embodiment: đổi robot arm khác — test cross-embodiment transfer
3. Layout changes: thay đổi vị trí vật thể so với demo

# Xem hướng dẫn chi tiết:
cat examples/LIBERO-plus/README.md

# Chạy eval với perturbation:
python eval_libero_plus.py \
  --server_url http://localhost:8000 \
  --perturbation_type language  # language | embodiment | layout

12. Kết Quả Benchmark

LIBERO (Standard Benchmark — Table 2)

ResVLA đạt 96.3% — sát với OpenVLA-OFT nhưng không cần pretrain trên large-scale data. Đây là điểm đáng chú ý: ResVLA train từ đầu trên LIBERO-90, trong khi nhiều baseline dùng Internet-scale pretrained weights.

LIBERO-Plus (Robustness — Đây mới là điểm quan trọng nhất)

Con số đáng chú ý nhất: embodiment perturbation. π₀ sụp đổ xuống 6.0% khi đổi robot arm — robot không thể "chuyển kiến thức" sang embodiment mới. ResVLA giữ 59.9% — gần 10× tốt hơn. Lý do: intent anchor giúp mô hình "hiểu" task ở cấp semantic, không gắn chặt vào kinematics cụ thể của robot.

SimplerEnv (Cross-Embodiment, Real Dataset)

Real-World ALOHA (Bimanual Robot)

Multi-stage task: pick → handover → place (3 stages liên tiếp)

13. Góc Nhìn Chuyên Gia: Tại Sao ResVLA Quan Trọng Hơn Con Số Cho Thấy?

Một kỹ sư robotics senior nhìn vào ResVLA sẽ thấy ngay 3 điểm mà beginner dễ bỏ qua:

1. Đây không phải "diffusion nhanh hơn" — đây là thay đổi inductive bias

NFE=1 inference là hệ quả, không phải mục tiêu chính. Điểm cốt lõi là ResVLA đặt mô hình vào đúng vùng không gian action trước, rồi tinh chỉnh sau. Sự thay đổi này ảnh hưởng đến tất cả — generalization, convergence, robustness — không chỉ tốc độ.

2. Loss Collapse giải thích một bug quan trọng trong VLA training

Nếu từng train VLA và thấy mô hình không bám language instruction, bạn thường đổ lỗi cho data quality hoặc learning rate. ResVLA chỉ ra nguyên nhân kiến trúc sâu hơn: khi source N(0, I) độc lập với condition, gradient flow bị cắt đứt. Đây là lý do bạn không thể fix chỉ bằng data — cần thay đổi source distribution.

3. DCT là lựa chọn "đủ tốt, không cần phức tạp"

Người mới thường nghĩ cần học-based decomposition (auto-encoder, PCA động) để tách intent và dynamics. DCT chứng minh rằng không cần — fixed basis đơn giản hoạt động tốt vì robot trajectories vốn smooth và low-frequency energy dominant. Đây là bài học quan trọng: complexity không luôn cần thiết.

Xem thêm về cách VLA được ứng dụng trong series VLA LeRobot để hiểu ecosystem rộng hơn.

14. Kết Luận

ResVLA đưa ra câu trả lời thanh lịch cho câu hỏi: "Tại sao bắt diffusion học từ noise thuần túy khi VLM đã hiểu task?"

Residual Diffusion Bridge không chỉ tăng accuracy trên benchmark — nó cải thiện robustness (quan trọng hơn cho deployment thực tế), convergence speed (train nhanh hơn với cùng data), và inference efficiency (NFE=1 viable).

Paradigm Refinement-from-Intent có tiềm năng lan rộng ra ngoài tabletop manipulation. Câu hỏi thú vị cho tương lai: liệu cùng approach có hoạt động cho whole-body humanoid control — nơi khoảng cách giữa semantic intent (bước lên cầu thang) và local dynamics (mỗi khớp điều chỉnh thế nào) còn lớn hơn nhiều?

Bài Viết Liên Quan

• Diffusion Policy: Nền Tảng Manipulation Hiện Đại
• VLA Models: Từ Ngôn Ngữ đến Hành Động Robot
• LeRobot VLA Framework: Hướng Dẫn Toàn Diện
• Whole-Body VLA và WBC Mới Nhất 2026