Pelican-VLA 0.5 trên LeRobot 3.0

Pelican-VLA 0.5 là một model Vision-Language-Action (VLA) mới từ WFM System Group, Beijing Innovation Center of Humanoid Robotics (X-Humanoid). Paper gốc có tiêu đề Pelican-VLA 0.5: Attending Before Acting Benefits Generalization, repo chính là Open-X-Humanoid/Pelican-VLA05, checkpoint pre-trained nằm ở X-Humanoid/Pelican-VLA05, còn checkpoint fine-tune RoboTwin nằm ở X-Humanoid/Pelican-VLA05-Robotwin.

Điểm làm Pelican-VLA 0.5 đáng đọc không phải chỉ là điểm benchmark cao hơn một chút. Ý tưởng quan trọng là Bottleneck Token, hay trong paper gọi là BotTokens: một nhóm token học được đặt giữa perception và action để ép action pathway không nhìn trực tiếp vào toàn bộ dense visual tokens. Thay vào đó, model phải nén thông tin liên quan đến vật thể, vùng tiếp xúc và trạng thái robot qua một interface nhỏ trước khi dự đoán action. Với beginner đang làm manipulation VLA trên LeRobot, đây là một bài học rất thực tế: robot không chỉ cần "nhìn thấy ảnh", mà còn cần biết nên chú ý vào vùng nào trước khi hành động.

Bài này đi theo hướng hands-on: hiểu paper, đọc kiến trúc, chuẩn bị dữ liệu LeRobot 3.0, cài inference package, kiểm tra checkpoint, chạy inference, visualize attention, và hiểu recipe training/fine-tuning theo paper. Nếu bạn đã làm qua bài hands-on OpenVLA với LeRobot, đây là bước tiếp theo tự nhiên cho nhóm muốn đánh giá policy hiện đại hơn trên data robot của mình.

Pelican-VLA 0.5 giải quyết vấn đề gì?

Các model VLA như OpenVLA, π0, π0.5, GR00T, SpatialVLA hay InternVLA đều cố nối ba miền: ảnh, ngôn ngữ và action liên tục của robot. Với một lệnh như "pick up the bottle", policy phải đọc nhiều camera, hiểu câu lệnh, biết bottle nào là mục tiêu, dự đoán vùng gripper nên tiếp cận, rồi xuất action chunk đủ mượt để robot không va chạm hoặc gắp hụt.

Vấn đề là nhiều VLA attention khá diffuse. Khi visualize action-to-image attention, attention không luôn nằm trên vật thể cần thao tác. Nó có thể trải lên robot arm, background, vật thể khác hoặc vùng ảnh không liên quan. Điều này không nhất thiết làm training loss xấu, vì model vẫn có thể fit trajectory trên dataset quen thuộc. Nhưng khi sang scene mới, object mới hoặc robot embodiment khác, diffuse attention làm policy dễ dựa vào shortcut thị giác thay vì target thật.

Pelican-VLA 0.5 đặt câu hỏi: nếu action pathway được ép phải đi qua một bottleneck nhỏ, model có học được representation "manipulation-centric" tự nhiên hơn không? Kết quả paper cho thấy có. Không cần object annotation, segmentation mask, attention supervision hay reasoning trace, pre-trained Pelican-VLA 0.5 đã tập trung attention lên object và contact region liên quan đến instruction trong zero-shot setting.

Kiến trúc: một token stream, bốn đoạn rõ ràng

Pelican-VLA 0.5 dùng một backbone Qwen3-VL 4B chung cho vision-language understanding, future-frame generation và action prediction. Thay vì tách thành nhiều expert lớn, model đưa mọi thứ vào một chuỗi token gồm bốn đoạn:

Điểm mấu chốt nằm ở attention geometry. Action suffix không được bypass BotTokens để đọc thẳng dense visual tokens. Nếu action token có thể attention trực tiếp vào mọi patch ảnh, bottleneck mất ý nghĩa. Paper dùng ba cơ chế để giữ bottleneck thật sự có tác dụng:

1. Curriculum bottleneck mask: trong training, route perception-to-action được kiểm soát dần để model học cách đi qua BotTokens.
2. Orthogonality regularizer: BotTokens được khuyến khích không collapse vào cùng một vector, giúp mỗi token mang thông tin khác nhau.
3. BotToken-gated generation: future-frame generation được gắn với BotTokens, làm nhóm token này không chỉ phục vụ action regression mà còn học representation về thay đổi tương lai.

Action head dùng flow matching. Thay vì output trực tiếp một vector action duy nhất, model dự đoán denoising velocity cho action chunk. Theo model card, checkpoint khoảng 5B parameters, action chunk size là 50, số bước denoising mặc định là 10, image resolution 224 x 224, state/action dim tối đa 32 và dtype mặc định là bfloat16.

Tại sao Bottleneck Token giúp robot chú ý đúng vật thể?

Hãy tưởng tượng camera trước có robot arm, bàn, chai, hộp, công tắc và nhiều vùng nền. Nếu action decoder được đọc toàn bộ image tokens, nó có thể dùng nhiều shortcut: vị trí arm quen thuộc, texture nền, vị trí thường gặp của object trong data, hoặc correlation giữa task và scene. Training loss vẫn giảm, nhưng representation không chắc đã generalize.

BotTokens tạo một "cửa hẹp" giữa perception và action. Vì cửa hẹp có fixed capacity, model phải học cách chọn thông tin có giá trị nhất cho hành động. Với manipulation, thông tin đó thường là:

Paper làm ablation khá rõ. Action loss một mình không tạo attention object-centric. Thêm future-frame generation loss cũng chưa đủ. Thêm contrastive language loss lên dense model cũng chưa đủ. Attention pattern chỉ bật lên rõ khi perception được route qua BotTokens. Nói cách khác, tác giả không chỉ nói "model tốt hơn"; họ cố tách data, loss và architecture để chỉ ra bottleneck chính là nguyên nhân quan trọng.

Chuẩn bị môi trường

Phần public của repo hiện tập trung vào inference và attention visualization. Tại thời điểm viết bài, pelican_vla0.5_infer/README.md ghi rõ inference release không kèm training scripts và dataset builders đầy đủ. Vì vậy bạn nên tách ba mục tiêu:

Máy khuyến nghị cho inference là GPU NVIDIA có hỗ trợ bfloat16, RAM đủ rộng và storage cho checkpoint. Vì model khoảng 5B parameters, bạn nên dùng A100/L40S/RTX 6000 Ada nếu muốn chạy thoải mái. RTX 4090 24GB có thể dùng để thử inference/fine-tune nhỏ với batch size thấp, nhưng cần theo dõi VRAM kỹ.

conda create -n pelicanvla python=3.10 -y
conda activate pelicanvla

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
pip install huggingface_hub safetensors accelerate

Tải checkpoint:

huggingface-cli download X-Humanoid/Pelican-VLA05 --local-dir ./pretrained_model
huggingface-cli download X-Humanoid/Pelican-VLA05-Robotwin --local-dir ./robotwin_model

Cài inference package từ release:

cd Pelican-VLA05/pelican_vla0.5_infer
pip install -r requirements.txt
# hoặc nếu muốn import như package local:
pip install -e .

Bạn cần thêm Qwen3-VL-4B-Instruct và Cosmos Tokenizer. Theo README, QWEN3_VL_PATH trỏ đến backbone Qwen3-VL. Cosmos tokenizer có thể tự tải lần đầu, hoặc bạn set đường dẫn offline:

export QWEN3_VL_PATH=/path/to/Qwen3-VL-4B-Instruct
export COSMOS_TOKENIZER_PATH=/path/to/Cosmos-0.1-Tokenizer-CI8x8

Chạy smoke test không cần robot:

python pelicanvla05_infer.py --model_path /path/to/pretrained_model --action_dim 7

Nếu bước này fail, đừng vội debug dataset. Hãy kiểm tra trước CUDA, version transformers, đường dẫn checkpoint, config.json, stats.json, và tên file safetensors.

Chuẩn bị dataset LeRobot 3.0

Pelican-VLA attention visualizer đọc được data của bạn nếu được đóng gói theo LeRobotDataset v3.0. Đây là format dataset, không nhất thiết là version package Python. Một thư mục dataset v3 thường có:

my_dataset/
├── meta/
│   ├── info.json
│   └── episodes/chunk-000/*.parquet
├── data/chunk-000/file-000.parquet
└── videos/
    ├── observation.images.front/chunk-000/file-000.mp4
    └── observation.images.wrist/chunk-000/file-000.mp4

Trong meta/info.json, bạn cần kiểm tra codebase_version, fps, features, các video key, state columns và action columns. Với Pelican-VLA, lỗi thường gặp không nằm ở model mà nằm ở mapping: camera name trong dataset không khớp camera_map, state vector sai dim, gripper dùng absolute nhưng bạn normalize như delta, hoặc action dim bị pad sai.

Một checklist tối thiểu:

Ví dụ đọc metadata:

import json
from pathlib import Path

root = Path("/abs/path/to/my_dataset")
info = json.loads((root / "meta/info.json").read_text())
print(info["codebase_version"])
print(info["fps"])
print([k for k, v in info["features"].items() if v.get("dtype") == "video"])
print(info["features"].keys())

Nếu bạn đang chuyển từ dataset cũ, hãy ôn lại pipeline OpenVLA với LeRobot: record, normalize và split train/val trước khi đưa vào model lớn.

Inference: chạy action chunk từ ảnh, state và instruction

Inference API public khá trực tiếp. Bạn load stats, tạo PelicanVLA05Inference, truyền ảnh nhiều camera, state hiện tại và instruction. Ví dụ dưới đây giữ cấu trúc từ README gốc, nhưng đổi comment để beginner dễ kiểm:

import numpy as np
from pelicanvla05_infer import PelicanVLA05Inference, load_stats_json

state_stats, action_stats = load_stats_json(
    "/path/to/pretrained_model/stats.json",
    state_keys=[
        "observation.state.arm.position",
        "observation.state.effector.position",
    ],
    action_keys=[
        "action.arm.position",
        "action.effector.position",
    ],
    robot_type="ur_5e_singleArm",
)

engine = PelicanVLA05Inference(
    model_path="/path/to/pretrained_model",
    camera_map={
        "front": "image0",
        "wrist": "image1",
        "side": "image2",
    },
    state_stats=state_stats,
    action_stats=action_stats,
    action_dim=7,
    delta_mask=[True, True, True, True, True, True, False],
)

action_chunk = engine.infer(
    images={
        "front": front_rgb,
        "wrist": wrist_rgb,
        "side": side_rgb,
    },
    state=[j1, j2, j3, j4, j5, j6, gripper],
    task="pick up the cup",
)

engine.reset()

action_chunk có shape (chunk_size, action_dim). Với default model card, chunk size là 50. Trong robot loop thật, bạn thường không execute cả 50 bước một cách mù quáng. Cách an toàn hơn là receding-horizon control: lấy vài action đầu, quan sát lại camera/state, gọi policy lại, rồi tiếp tục. Khi scene thay đổi nhanh hoặc gripper sắp contact, horizon ngắn giúp giảm lỗi tích lũy.

Attention visualization trên LeRobot 3.0

Phần hay nhất của release là attention_vis. Tool này dump action-to-image attention thành .npz theo camera, sau đó render overlay PNG hoặc montage để bạn xem model đang chú ý vào đâu.

Cài visualizer:

cd Pelican-VLA05/attention_vis
python -m venv .venv
. .venv/bin/activate
pip install -e '.[data]'

Tạo .env:

ATTNVIS_PELICANVLA_SRC=/path/to/Pelican-VLA05/pelican_vla0.5_infer
ATTNVIS_PELICANVLA_CKPT=/path/to/pretrained_model
QWEN3_VL_PATH=/path/to/Qwen3-VL-4B-Instruct
COSMOS_TOKENIZER_PATH=/path/to/Cosmos-0.1-Tokenizer-CI8x8
ATTNVIS_ROBOTWIN_ROOT=/path/to/RoboTwin2_0_processed/robotwin

Preflight và dump:

set -a && source .env && set +a
export PYTHONPATH=$PWD/src

python -m attnvis preflight robotwin:adjust_bottle:0
python -m attnvis run --scenes robotwin:adjust_bottle:0 --nframes 3 --exp case_study
python -m attnvis fig montage --root outputs/dense/case_study

Với dataset của bạn, hãy register embodiment theo hướng dẫn trong attention_vis/README.md: thêm camera key, state columns, instruction source và path dataset. Mục tiêu không phải làm hình đẹp, mà là kiểm chứng câu hỏi kỹ thuật: khi instruction nói "bottle", attention có nằm trên bottle/contact region không, hay vẫn lan lên robot arm và background?

Training và fine-tuning: đọc đúng trạng thái release

Paper nói Pelican-VLA 0.5 được pre-train trên khoảng 2,400 giờ heterogeneous manipulation data. RoboTwin không được dùng trong pre-training. Sau đó model được fine-tune trên RoboTwin 2.0 để đánh giá clean/randomized. README repo cũng ghi kế hoạch release training code, nhưng inference README hiện nhấn mạnh rằng training scripts và dataset builders không nằm trong inference-focused package.

Vì vậy, nếu bạn muốn train theo đúng paper, hãy hiểu recipe trước:

Một training run thực tế trên dataset riêng nên đi từ nhỏ đến lớn:

1. Chạy inference checkpoint pre-trained trên vài episode để xác nhận camera/state/action mapping.
2. Chạy attention_vis để xem model có chú ý đúng object không.
3. Fine-tune action head hoặc LoRA nhỏ trước, chưa vội full fine-tune 5B parameters.
4. Đóng băng backbone trong smoke run đầu để phát hiện lỗi stats và action convention.
5. Mở dần BotTokens/action layers nếu validation rollout vẫn gắp hụt dù attention đúng.

Pseudo command dưới đây minh họa các tham số bạn nên tìm trong training release chính thức. Đừng xem đây là entrypoint đã tồn tại trong repo public hiện tại:

python train_pelicanvla05.py \
  --pretrained_model ./pretrained_model \
  --dataset_root /data/my_lerobot_v3 \
  --dataset_format lerobot_v3 \
  --state_keys observation.state.arm.position observation.state.effector.position \
  --action_keys action.arm.position action.effector.position \
  --camera_keys observation.images.front observation.images.wrist observation.images.side \
  --action_dim 7 \
  --chunk_size 50 \
  --precision bf16 \
  --loss_action flow_matching \
  --enable_bottleneck_tokens true \
  --enable_future_generation true \
  --output_dir runs/pelican_my_robot

Nếu training code chính thức khác tên script, phần quan trọng vẫn là mapping. Một VLA lớn rất dễ "train được" nhưng không deploy được nếu bạn đảo camera, normalize gripper sai, hoặc để instruction không thống nhất giữa train và inference.

Kết quả: mạnh ở attention, vẫn còn gap ở action

Trên RoboTwin 2.0, checkpoint fine-tune đạt 91.4% trên Clean và 91.0% trên Randomized, average 91.2%. Trong bảng repo, kết quả này cao hơn các baseline open-source như π0, π0.5, X-VLA, StarVLA-OFT, ABot-M0, LingBot-VLA, Qwen-VLA, JoyAI-RA và Hy-VLA.

Điểm cần đọc cẩn thận: Pelican-VLA 0.5 không tự nhận là model zero-shot manipulation hoàn chỉnh. Paper gọi đây là intermediate model. Nó đã học được attention-level generalization, tức là biết nên nhìn vào đâu, nhưng vẫn còn representation-to-action gap: nhìn đúng object không đồng nghĩa với grasp ổn định, timing contact chính xác hoặc placement mượt trên embodiment mới.

Phân tích checkpoint trong paper cho thấy target-object IoU tăng từ 0.054 ở 50k step lên 0.124 ở 500k step, với Spearman rho 0.76 và p = 0.01. Attention lên manipulator vẫn cao và ổn định quanh 0.35. Điều này hợp lý: robot cần biết trạng thái arm/gripper, nhưng xu hướng học đáng giá là attention dịch dần sang object theo instruction.

Sau fine-tuning, attention map trước và sau adaptation vẫn rất giống nhau. Paper đo attention similarity sau fine-tune khoảng 0.928. Cách diễn giải thực dụng là: fine-tuning chủ yếu không tạo grounding từ đầu; nó biến grounding đã có thành action đáng tin hơn.

Khi nào nên thử Pelican-VLA 0.5?

Bạn nên thử Pelican-VLA 0.5 nếu nhóm của bạn có một trong các mục tiêu sau:

Bạn chưa nên dùng nó như controller production nếu task đòi hỏi safety cao, contact force chính xác hoặc chứng nhận công nghiệp. Model card cũng nói rõ đây là research model. Với robot thật, hãy bắt đầu bằng replay offline, sau đó chạy tốc độ thấp, workspace giới hạn, emergency stop vật lý và guardrail ở tầng controller.

Debug checklist cho beginner

Khi chạy không ra kết quả, hãy debug theo thứ tự này:

Nếu bạn đang so sánh với model khác, hãy đặt Pelican-VLA 0.5 cạnh OpenVLA và InternVLA-A1.5. Sự khác nhau đáng chú ý là Pelican-VLA 0.5 đặt trọng tâm vào route perception-to-action qua bottleneck, còn InternVLA-A1.5 tập trung vào latent foresight được supervise bởi video model.

Kết luận

Pelican-VLA 0.5 là một bài học kiến trúc rất đáng chú ý cho VLA manipulation: trước khi robot hành động tốt, policy phải học cách chú ý đúng vùng. Bottleneck Token không phải trick trang trí; ablation trong paper cho thấy nó là cơ chế chính làm attention trở nên manipulation-centric. Với LeRobot 3.0, phần public hiện hữu nhất để dùng ngay là inference và attention visualization. Phần training đầy đủ cần theo dõi release chính thức, nhưng recipe paper đã đủ rõ để bạn chuẩn bị dataset, mapping state/action/camera và kế hoạch fine-tune an toàn.

Bài viết liên quan

• Hands-on: Fine-tune OpenVLA với LeRobot
• OpenVLA Deep Dive
• Fine-tune InternVLA-A1.5 với LeRobot