Chạy World Pilot cho VLA robot

World Pilot là một framework mới để steer Vision-Language-Action (VLA) model bằng World-Action Priors. Thay vì bắt VLA tự suy ra toàn bộ dynamics từ ảnh hiện tại và instruction, World Pilot lấy thêm hai tín hiệu từ World-Action Model (WAM): latent mô tả scene sẽ tiến hóa như thế nào và trajectory dự đoán robot có thể đi theo hướng nào. Hai tín hiệu này không thay thế policy chính; chúng đóng vai trò như "pilot" giúp action generator bớt mù về tương lai gần.

Bài này là hướng dẫn thực dụng để đọc paper và chạy repo public. Mục tiêu không phải chỉ tóm tắt abstract, mà giúp bạn hiểu: World Pilot giải quyết lỗi gì của VLA, kiến trúc Latent Steering và Action Steering hoạt động ra sao, cài môi trường nào, train thế nào, inference/evaluation ra sao, và nên đọc kết quả zero-shot OOD như thế nào. Nếu bạn mới bắt đầu với VLA, hãy xem World Pilot như một ví dụ rất rõ của xu hướng mới: không chỉ dùng VLM để hiểu scene, mà dùng world model để dự đoán scene sẽ thay đổi ra sao khi robot hành động.

Nguồn chính của bài:

• Paper: World Pilot: Steering Vision-Language-Action Models with World-Action Priors
• Project page: world-pilot.github.io
• GitHub: ZefuLin/WorldPilot
• Model weights: Chedan86/WorldPilot-LIBERO
• Precomputed cache: Chedan86/WorldPilot-LIBERO-precompute

Ý tưởng chính của World Pilot

VLA model hiện đại thường đi theo pipeline:

camera images + language instruction + proprioception
        |
        v
Vision-Language Model backbone
        |
        v
action head / diffusion head / flow-matching head
        |
        v
robot action chunk

Pipeline này mạnh về semantic grounding. Ví dụ robot hiểu "stack orange blocks", biết object nào là block màu cam, và biết instruction muốn stacking chứ không phải pushing. Nhưng semantic grounding từ image-text pretraining chủ yếu học từ ảnh tĩnh và caption tĩnh. Manipulation thật lại là quá trình liên tục, có contact, occlusion, object state transition, tolerance hình học và lỗi tích lũy.

Vấn đề xuất hiện rõ khi robot gặp zero-shot OOD shift:

World Pilot thêm WAM vào pipeline. WAM nhận cùng observation/instruction/proprioception, rồi output:

1. scene-evolution latent: latent mô tả tương lai gần của scene, chứa cue về object motion, contact outcome và state change.
2. anticipated action trajectory: trajectory thô, không phải action cuối cùng, mà là motion prior để action generator tham khảo.

Sơ đồ tối giản:

Inputs
  multiview images + instruction + proprioception
        |
        +----------------------------+
        |                            |
        v                            v
  VLM semantic path             World-Action Model
        |                       /              \
        |                      v                v
        |              scene-evolution      anticipated
        |                  latent           trajectory
        |                      |                |
        |                      v                v
        |              Latent Steering    Action Steering
        |                      |                |
        +----------------------+----------------+
                               |
                               v
                    flow-matching action head
                               |
                               v
                         executable action

Điểm quan trọng: World Pilot không dùng WAM để thay thế VLA. Nó vẫn giữ VLA làm policy chính, vẫn train theo expert action chunk, nhưng thêm world priors vào đúng vị trí trong decision chain.

Kiến trúc: hai đường steering bổ sung nhau

Paper chia World Pilot thành hai pathway: Latent Steering ở perception layer và Action Steering ở action-generation layer. Hai pathway này độc lập đủ để ablate riêng, nhưng khi dùng chung thì cho kết quả tốt nhất.

Latent Steering

Latent Steering trả lời câu hỏi: làm sao đưa dự đoán tương lai của world model vào hidden states của VLM mà không bị nhiễu bởi pixel-level artifact?

Một cách ngây thơ là decode future image từ WAM, sau đó đưa ảnh tương lai đó vào VLM như một image input nữa. Paper thử hướng này và thấy kém hơn latent injection. Lý do khá thực tế: future image chứa texture, ánh sáng, background, artifact generation và chi tiết không liên quan đến control. Trong khi đó, latent của WAM giữ cấu trúc dynamics compact hơn.

Luồng Latent Steering:

WAM future latent Z_w
        |
        v
dynamics encoder f_dyn
        |
        + temporal future embedding
        |
        v
future-scene tokens D_w
        |
        v
cross-attention: VLM hidden states attend to D_w
        |
        v
dynamics-aware VLM hidden states

Về mặt ý tưởng, mỗi token trong VLM hidden states có thể attend đến phần latent tương lai liên quan tới vùng không gian hoặc object mà token đó đang encode. Residual update giúp giữ nguyên cấu trúc token sequence của VLM, nên action head phía sau không cần đổi interface lớn.

Action Steering

Action Steering trả lời câu hỏi khác: nếu WAM đã dự đoán một trajectory thô, ta nên đưa nó vào action generator kiểu gì?

World Pilot không dùng trajectory thô làm output. Nó cũng không ép từng step của action head bám từng step của WAM. Thay vào đó, trajectory được resample theo action horizon K, rồi encode thành một prior token duy nhất. Token này được chèn như prefix vào flow-matching action generator.

WAM anticipated trajectory A_w
        |
        v
align to VLA horizon K
        |
        v
action encoder f_act
        |
        v
single trajectory prior token s_w
        |
        v
self-attention context for flow-matching action head

Thiết kế một token nghe đơn giản nhưng có ý nghĩa. Nếu dùng per-step tokens, policy dễ bị kéo quá chặt theo trajectory noisy của WAM. Nếu dùng WAM trajectory để initialize flow, output cuối vẫn phụ thuộc nhiều vào chất lượng WAM. Single-token form giữ WAM như guidance mềm: đủ để action head biết motion shape tổng quát, nhưng vẫn có quyền chỉnh lại theo VLA hidden states và expert action supervision.

Training objective

World Pilot train giống một VLA flow-matching policy có thêm conditioning. Mỗi sample gồm observation, instruction, optional proprioception và expert action chunk A*. WAM được giữ frozen. Gradient chỉ update VLA-side parameters:

• VLM backbone và adapter nếu config cho phép
• dynamics encoder cho latent prior
• Latent Steering cross-attention
• action encoder cho trajectory prior
• flow-matching action generator

Paper dùng clean-action parameterization. Tóm tắt bằng pseudo-code:

# observation: images, language, optional proprioception
# expert: clean action chunk A_star

with torch.no_grad():
    Z_w, A_w = wam(observation)          # frozen WAM

H = vlm_encode(observation)
H_bar = latent_steering(H, Z_w)

s_w = action_encoder(align_to_horizon(A_w, K))

eps = torch.randn_like(A_star)
tau = sample_flow_time()
X_tau = tau * A_star + (1 - tau) * eps

A_hat = action_head(
    noisy_action=X_tau,
    flow_time=tau,
    state_token=proprioception,
    prior_token=s_w,
    cross_attention_context=H_bar,
)

loss = weight(tau) * mse(A_hat, A_star)
loss.backward()

Điểm triển khai đáng chú ý là WAM forward có thể precompute/cache trong training để không phải chạy world model trong inner loop. Khi inference/evaluation, WAM chạy online ở mỗi decision step để tạo priors từ observation thật.

Cài đặt repo public

Repo WorldPilot hiện dùng nhiều môi trường riêng thay vì một Docker duy nhất. Đây là phần beginner dễ vấp nhất. Có bốn môi trường:

Các lệnh dưới đây là khung thực hành. Bạn nên đọc doc trong repo trước khi chạy full vì path checkpoint/dataset/GPU phải sửa theo máy.

sudo apt-get update
sudo apt-get install -y \
  build-essential cmake git git-lfs curl wget ffmpeg \
  libgl1 libegl1-mesa-dev libgl1-mesa-dri libglib2.0-0 \
  libexpat1 libfontconfig1-dev libpython3-stdlib libmagickwand-dev

Tạo environment chính:

mamba create -n WorldPilot python=3.10 -y
mamba activate WorldPilot

git clone https://github.com/ZefuLin/WorldPilot.git
cd WorldPilot

pip install torch torchvision --index-url <your-pytorch-cuda-wheel-index>
pip install -r requirements.txt
pip install -e .

Cài VGGT nếu config LIBERO hiện tại yêu cầu:

git clone https://github.com/facebookresearch/vggt.git /path/to/vggt
pip install -e /path/to/vggt

Cài Cosmos Policy:

mamba create -n cosmos-policy python=3.10 -y
mamba activate cosmos-policy

git clone https://github.com/NVlabs/cosmos-policy.git
cd /path/to/cosmos-policy
pip install -e ".[cu128]"
pip install -r cosmos_policy/experiments/robot/libero/libero_requirements.txt
pip install websockets msgpack

Cài LIBERO-Plus để evaluation:

mamba create -n libero-plus python=3.8 -y
mamba activate libero-plus

git clone https://github.com/sylvestf/LIBERO-plus.git
cd /path/to/LIBERO-plus
pip install -r requirements.txt
pip install -r extra_requirements.txt
pip install -e .

cd /path/to/WorldPilot
pip install -r examples/LIBERO-plus/eval_files/libero_plus_requirements.txt

Sau đó tạo config local:

mkdir -p ~/.libero-plus
cat > ~/.libero-plus/config.yaml <<'EOF'
assets: /path/to/LIBERO-plus/libero/libero/assets
bddl_files: /path/to/LIBERO-plus/libero/libero/bddl_files
benchmark_root: /path/to/LIBERO-plus/libero/libero
datasets: /path/to/libero_plus_datasets
init_states: /path/to/LIBERO-plus/libero/libero/init_files
EOF

export LIBERO_CONFIG_PATH=~/.libero-plus
export MUJOCO_GL=egl
export PYOPENGL_PLATFORM=egl

Chuẩn bị checkpoint và cache

World Pilot public release phụ thuộc vài pretrained assets:

Nếu mục tiêu chỉ là evaluation, cách nhanh nhất là tải released checkpoint và precomputed cache. Nếu mục tiêu là training từ đầu trên LIBERO, bạn cần chuẩn bị examples/LIBERO/train_files/WorldPilot.yaml và cache directory.

Layout cache được docs gợi ý:

/path/to/cosmos_cache/
  libero_10_no_noops_1.0.0_lerobot/
  libero_goal_no_noops_1.0.0_lerobot/
  libero_object_no_noops_1.0.0_lerobot/
  libero_spatial_no_noops_1.0.0_lerobot/

Nếu không dùng cache published, chạy precompute:

cd /path/to/WorldPilot
# sửa biến trong cosmos_bridge/run_precompute.sh trước
bash cosmos_bridge/run_precompute.sh

Script này sẽ start Cosmos server theo dataset split và ghi cache vào output directory. Với beginner, cache published giúp rút ngắn đáng kể thời gian debug vì bạn có thể tập trung kiểm tra policy path trước.

Training World Pilot

Public training path trong repo gồm năm bước:

1. Chuẩn bị WorldPilot và cosmos-policy.
2. Chuẩn bị pretrained weights và cache artifacts.
3. Download hoặc precompute Cosmos cache.
4. Sửa YAML training và launch script.
5. Chạy training.

Các field tối thiểu cần sửa trong examples/LIBERO/train_files/WorldPilot.yaml:

run_root_dir: /path/to/runs
run_id: worldpilot_libero_debug

framework:
  vggt_path: /path/to/VGGT-1B
  qwenvl:
    base_vlm: /path/to/Qwen3-VL-4B-Instruct-Action

datasets:
  vla_data:
    data_root_dir: /path/to/libero_lerobot_data
    cosmos_cache_dir: /path/to/cosmos_cache

trainer:
  pretrained_checkpoint: /path/to/ABot-M0-Pretrain

Sau đó sửa top block của examples/LIBERO/train_files/run_libero_train.sh:

GPU_IDS=0,1,2,3
CONFIG_YAML=examples/LIBERO/train_files/WorldPilot.yaml

Chạy:

cd /path/to/WorldPilot
mamba activate WorldPilot
bash examples/LIBERO/train_files/run_libero_train.sh

Paper fine-tune World Pilot trên 8 RTX PRO 6000 GPUs và dùng WAM conditions dropout rate 0.3 để policy không over-rely vào priors. Nếu bạn chỉ có một GPU, đừng kỳ vọng reproduce full number. Hãy bắt đầu bằng short run để kiểm tra data loader, cache path, checkpoint loading và loss giảm hợp lý.

Checklist smoke test:

[ ] import WorldPilot package thành công
[ ] load Qwen3-VL action checkpoint
[ ] load ABot-M0 pretrain
[ ] đọc được LIBERO LeRobot dataset
[ ] đọc được cosmos_cache_dir
[ ] batch đầu tiên có images, language, proprioception, action
[ ] forward pass không NaN
[ ] loss giảm trong vài trăm step đầu

Inference và evaluation

Evaluation public target là WorldPilot trên Libero-Plus. Repo có hai entrypoint:

• examples/LIBERO-plus/eval_files/eval_libero_single.sh
• examples/LIBERO-plus/eval_files/eval_libero_batch.sh

Trước evaluation cần có:

Single-suite evaluation:

cd /path/to/WorldPilot
mamba activate libero-plus

# sửa required paths ở đầu file trước
bash examples/LIBERO-plus/eval_files/eval_libero_single.sh

Batch evaluation:

cd /path/to/WorldPilot
mamba activate libero-plus

# sửa checkpoint paths, Cosmos files, SUITES, GPUS, ports
bash examples/LIBERO-plus/eval_files/eval_libero_batch.sh

Public eval scripts vận hành theo mô hình server:

Cosmos server
  cosmos_bridge/run_cosmos_server.sh
        |
        v
policy server
  deployment/model_server/server_policy.py
        |
        v
LIBERO-Plus simulator workers
  socket requests -> policy actions

Khi debug inference, hãy tách lỗi theo ba lớp: Cosmos server có trả WAM priors không, policy server có load WorldPilot checkpoint không, và simulator worker có gửi observation đúng shape không. Đừng debug tất cả cùng lúc.

Kết quả paper

World Pilot được evaluate trên LIBERO, LIBERO-Plus, RoboCasa và real robot. Con số nổi bật nhất là 84.7% Total success rate trên LIBERO-Plus zero-shot OOD, cao hơn ABot-M0 baseline 80.5% và Cosmos Policy 79.7% trong bảng paper.

Một phần kết quả simulation:

Điểm thú vị là World Pilot không thắng mọi axis. Nó đặc biệt mạnh ở camera, light, background và noise. Trên camera perturbation, paper báo cáo 82.8%, cao hơn baseline gần nhất 13.2 điểm. Điều này phù hợp với intuition: video-pretrained WAM đã thấy nhiều camera poses, latent future-scene giúp policy đưa coverage này vào action decision.

Real robot setup gồm bốn task:

Mỗi task có 100 ID teleoperated demonstrations, fine-tune 10,000 steps, và 20 trials cho mỗi setting/method. World Pilot đạt cao nhất ở mọi setting. Ví dụ Stack Blocks ID là 70%, OOD color 55%, OOD height 50%; Fold Towel ID là 85%, OOD direction 75%, novel towel 70%; Fruit-to-Plate ID là 90%, novel fruit 75%, layout 70%; Container-Lid Alignment ID là 80%, novel object 70%, lid pose 65%.

Quan trọng hơn raw score là độ tụt ID sang OOD. World Pilot thường tụt trong khoảng 10-20 điểm tuyệt đối, trong khi các baseline tụt 25-50 điểm. Với manipulation cần tolerance như closing lid, khác biệt này rất có ý nghĩa vì failure thường đến từ pose/contact sai một chút, không phải không hiểu instruction.

Ablation: vì sao thiết kế này đáng chú ý?

Paper có bốn ablation đáng đọc.

Mỗi pathway đều có ích

Điều này cho thấy scene-evolution prior và trajectory prior không trùng lặp hoàn toàn. Latent Steering giúp perception hiểu tương lai của scene, còn Action Steering giúp action head có motion hint.

World prior có ích ngay cả trước action fine-tuning

Khi thay Cosmos Policy bằng Cosmos-Predict chỉ sinh future latent, Latent Steering vẫn cải thiện ABot-M0 trên LIBERO-Plus, RoboCasa và RoboTwin2.0 clean. Nghĩa là video-pretrained world model đã chứa dynamics prior đủ hữu ích, dù action post-training giúp sharpen thêm.

Latent tốt hơn decoded future image

Future latent ở 1, 3, 5 denoising steps đều quanh 84.5-84.7%. Decoded future image chỉ đạt 83.5%. Đây là một bài học tốt cho robot learning: ảnh tương lai nhìn đẹp chưa chắc là representation tốt nhất cho control. Latent có thể ít "người xem được" hơn nhưng sạch hơn cho policy.

Single trajectory token tốt hơn per-step forcing

Action prior form tốt nhất là single encoded token 84.7%. Per-step encoded tokens đạt 83.6%, flow initialization 84.1%, raw trajectory 83.0%. Kết quả này ủng hộ cách dùng WAM như soft guidance, không dùng nó như oracle trajectory cứng.

Khi nào nên dùng World Pilot?

World Pilot đáng thử nếu bạn đang có:

• VLA backbone đã chạy được, nhất là flow-matching hoặc diffusion action head.
• Dataset manipulation có language/action chunk rõ ràng.
• Vấn đề zero-shot OOD ở camera, appearance, geometry hoặc pose.
• GPU đủ để chạy thêm WAM online hoặc precompute WAM cache.
• Benchmark kiểu LIBERO/LIBERO-Plus trước khi đưa lên robot thật.

World Pilot chưa phải lời giải cho mọi robot. Paper cũng nêu rõ limitation: policy vẫn phụ thuộc coverage của WAM; nếu test scene nằm ngoài video pretraining distribution, priors sẽ yếu. Mỗi decision step cần thêm WAM forward pass, nên high-frequency reactive control có thể gặp latency. Ngoài ra, VLA và WAM hiện được nối modular qua action loss, chưa co-train sâu để prior-policy tự thích nghi lẫn nhau.

Lộ trình thử trên lab nhỏ

Nếu bạn ở lab robotics hoặc startup nhỏ, đừng bắt đầu bằng "reproduce 84.7%". Hãy đi theo lộ trình này:

1. Chạy released checkpoint trên một LIBERO-Plus suite nhỏ.
2. Kiểm tra logs để thấy Cosmos server, policy server và simulator giao tiếp ổn.
3. Fine-tune short run từ ABot-M0 pretrain với published cache.
4. So sánh baseline ABot-M0 và World Pilot trên 1-2 OOD axes.
5. Chỉ sau đó mới nghĩ tới real robot hoặc custom dataset.

Với custom robot, phần khó nhất không phải code steering mà là chuẩn hóa data: camera sync, proprioception, action chunk, gripper state, language label, reset condition và evaluation protocol. World Pilot giúp policy có dynamics priors, nhưng không sửa được dataset bẩn.

Bài viết liên quan

• Tổng quan VLA model cho robot
• LeRobot hands-on cho robot learning
• RISE: world model và VLA RL imagination