SLIM-0.5B: VLA gọn nhẹ trên LIBERO

SLIM-0.5B là một hướng rất đáng chú ý cho robot manipulation: thay vì đẩy mọi thứ vào một Vision-Language-Action model nhiều tỷ tham số, paper SLIM-0.5B: Learning Action-Grounded Predictive Latents for Robot Manipulation chọn một điểm cân bằng thực dụng hơn. Mô hình chỉ khoảng 0.47B tham số, dùng DINOv2 để mã hóa ảnh, T5-small để mã hóa instruction, rồi đưa observation latents và action tokens vào một backbone Mixture-of-Transformers nhỏ gọn. Phần quan trọng nhất không phải chỉ là giảm kích thước model, mà là cách SLIM học biểu diễn: latent của quan sát phải biết hành động nào đã gây ra thay đổi, và hành động phải giúp dự đoán trạng thái latent tương lai.

Nói ngắn gọn, SLIM đặt câu hỏi: trong robot manipulation, ta có thật sự cần một VLM khổng lồ suy luận mở ở mỗi control step không? Với các task như pick, place, wipe, stack hoặc thao tác vật thể trong LIBERO, robot cần hiểu instruction, nhìn đúng object, nhận biết gripper và dự đoán hệ quả của action chunk kế tiếp. Nhiều năng lực open-domain của VLM lớn không trực tiếp tham gia vào vòng điều khiển liên tục. SLIM vì vậy chuyển trọng tâm từ "language model thật lớn" sang "latent interaction policy biết dynamics".

Nếu bạn mới bắt đầu với VLA, nên đọc trước bài VLA Models trong robotics. Nếu muốn hiểu dataset và workflow LeRobot thực hành hơn, bài LeRobot hands-on sẽ giúp bạn chuẩn bị dữ liệu, action format và evaluation mindset trước khi chạy SLIM.

Nguồn gốc và tài nguyên chính thức

Paper SLIM-0.5B được công bố trên arXiv ngày 10/8/2026 bởi Jingkai Wang, Zihan Tang, Gu Zhang, Mingyu Cao, Jiapeng Chen, Jingjiao Zhao, Xiansheng Chen, Pengwei Wang, Lemao Liu và Dejing Dou. Tài nguyên chính thức gồm:

Repo chính thức đã có README, docs data, docs environment, scripts training, scripts evaluation và checkpoint release. Bài này không thay thế README của tác giả; mục tiêu là giải thích paper theo cách beginner có thể follow: ý tưởng, kiến trúc, dữ liệu LIBERO, cách cài, cách train, cách inference và cách đọc kết quả.

Vấn đề SLIM muốn giải quyết

Các VLA hiện đại thường đi theo hai hướng. Hướng thứ nhất là dùng backbone vision-language lớn, thêm action head hoặc action tokens, rồi để cùng một model xử lý ảnh, language và action generation. Cách này tận dụng được semantic priors mạnh, nhưng chi phí inference cao vì mỗi control step phải gọi một multimodal backbone lớn. Với robot thật, latency và VRAM không phải chi tiết phụ; chúng ảnh hưởng trực tiếp đến tần số replanning, số robot chạy đồng thời và khả năng deploy trên workstation hoặc edge GPU.

Hướng thứ hai là world model hoặc world-action model: model dự đoán ảnh, video hoặc trajectory tương lai để học dynamics. Ý tưởng này rất hợp robotics vì action nên được grounded trong hệ quả vật lý. Nhưng pixel-level prediction lại tốn capacity cho nhiều chi tiết không cần cho control, ví dụ texture nền, ánh sáng, vùng ảnh không liên quan hoặc thay đổi visual nhỏ không ảnh hưởng đến grasp. Nếu phải rollout future video ngay trong inference, control loop còn chậm hơn.

SLIM chọn hướng thứ ba: dự đoán tương lai trong latent space dùng cho policy, không dự đoán pixel. Model học bằng masked trajectory prediction:

Current observation + future observation -> reconstruct action chunk
Current observation + action chunk        -> predict future observation latent

Hai chiều này làm latent trở nên action-grounded. Nếu latent chỉ chứa semantic chung chung, nó có thể biết "đây là cái bát" nhưng không biết action nào đã làm bát dịch chuyển hoặc gripper sắp chạm object ra sao. Nếu latent được ép phải giải thích action và dự đoán transition, nó sẽ ưu tiên object, gripper, contact region và trạng thái liên quan đến task.

Kiến trúc SLIM-0.5B

SLIM tách rõ bốn phần:

Trong thiết lập LIBERO, model dùng hai camera: workspace view và wrist view. Ảnh được resize về 224x224. Action là vector 7D, action horizon là 8, tức policy dự đoán một action chunk gồm 8 bước. Inference dùng 4 flow-sampling steps để sinh action chunk. Đây là khác biệt quan trọng với nhiều diffusion policy hoặc VLA lớn cần nhiều sampling steps hơn.

Backbone MoT có hai stream chính: observation stream và action stream. Observation stream xử lý latent từ ảnh và các future slots. Action stream xử lý continuous action tokens, không discretize action thành từ vựng. Language embedding đóng vai trò condition cấp task, không phải nơi toàn bộ control computation bị dồn vào. Thiết kế này giúp SLIM giữ được language-conditioned manipulation nhưng không biến mỗi step thành một lần chạy VLM khổng lồ.

Điểm dễ nhầm là "predictive latent" không có nghĩa là khi deploy model phải dự đoán ảnh tương lai rồi mới hành động. Future latent được dùng chủ yếu trong Stage 1 để dạy representation. Sang Stage 2 và inference, policy chỉ cần current observation, proprioception, language embedding, learned future-slot embeddings và noised action chunk trong flow matching. Nói cách khác, model mang theo cấu trúc dự đoán đã học, nhưng không cần future observation thật và không cần render future video khi chạy robot.

Action-grounded predictive latents là gì?

Hãy tưởng tượng một trajectory ngắn trong LIBERO: robot nhìn thấy một mug, instruction là đặt mug vào vùng bên phải, gripper tiến đến mug, đóng gripper, rồi mug di chuyển. Một visual encoder thông thường có thể mã hóa nhiều thứ: màu bàn, texture nền, object khác, ánh sáng, camera pose. Nhưng policy cần biết các yếu tố có liên quan đến hành động: mug ở đâu, gripper đang ở đâu, có contact chưa, action nào làm mug đổi vị trí.

SLIM dùng hai objective bổ sung nhau:

IDM trả lời câu hỏi: "Nếu trạng thái latent thay đổi từ hiện tại sang tương lai, action nào giải thích thay đổi đó?" FDM trả lời câu hỏi ngược lại: "Nếu robot thực hiện action chunk này, phần latent tương lai nào nên thay đổi?" Khi train cùng nhau, hai objective buộc representation tập trung vào tương tác action-observation thay vì chỉ nhận dạng ảnh.

Paper dùng loss Stage 1:

L_stage1 = lambda_IDM * L_IDM + lambda_FDM * L_FDM

Trong recipe LIBERO canonical, tỷ lệ tốt nhất là IDM:FDM = 0.125:1, EMA target encoder bật với momentum 0.999, Stage 1 train 3 epochs. Sau đó Stage 2 bỏ EMA target, load checkpoint Stage 1 và train flow-matching policy 40 epochs.

Dữ liệu LIBERO cần chuẩn bị

Repo SLIM không dùng HDF5 gốc của LIBERO cho recipe chính. Tác giả dùng bản LeRobot v2.1 no-op-filtered từ collection IPEC-COMMUNITY. Có năm dataset:

Stage 1 dùng libero_all_90, tức bốn target suites cộng LIBERO-90. Stage 2 dùng libero_all, tức Object, Goal, Spatial và LIBERO-10, không dùng LIBERO-90. Dataset có video AV1 256x256 ở hai key observation.images.image và observation.images.wrist_image, action 7D, state 8D nhưng config canonical dùng 7 giá trị state đầu.

Cài đặt môi trường training

Môi trường training được báo cáo dùng Python 3.12.9 và CUDA 12.4. Nếu chỉ đọc code hoặc tải checkpoint, máy thường vẫn đủ. Nếu train theo recipe paper, hãy chuẩn bị một node nhiều GPU, lý tưởng là 8 GPU H100 80GB như paper. Với GPU nhỏ hơn, bạn phải giảm batch size, dùng gradient accumulation hoặc xem đây là reproduction gần đúng.

git clone https://github.com/kzz1031/SLIM.git
cd SLIM
python3.12 -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade pip
python -m pip install -r requirements.txt
python -m pip install -e .

Sau đó đặt các path chính:

export LIBERO_DATA_ROOT=/path/to/lerobot/libero
export TORCH_HOME=/path/to/torch-cache
export DINOV2_MODEL_DIR=/path/to/dinov2-vitb14
export T5_MODEL_DIR=/path/to/t5-small
export SLIM_CACHE_DIR=/path/to/cache
export SLIM_LANGUAGE_CACHE=/path/to/language_embeddings

DINOv2 cần đúng checkpoint DINOv2-B/14 từ PyTorch Hub source chính thức, không thay bằng facebook/dinov2-base trên Hugging Face vì state dict không khớp architecture repo dùng. T5-small nên tải snapshot đầy đủ, gồm tokenizer, config và model.safetensors. Nếu bạn muốn train ổn định, hãy chạy smoke test load DINOv2 và T5 trước khi tải dataset lớn.

Tải dữ liệu và cache language

Tải năm dataset LIBERO bằng Hugging Face CLI:

python -m pip install huggingface_hub
mkdir -p "$LIBERO_DATA_ROOT"
for repo in \
  IPEC-COMMUNITY/libero_object_no_noops_1.0.0_lerobot \
  IPEC-COMMUNITY/libero_goal_no_noops_1.0.0_lerobot \
  IPEC-COMMUNITY/libero_spatial_no_noops_1.0.0_lerobot \
  IPEC-COMMUNITY/libero_10_no_noops_1.0.0_lerobot \
  IPEC-COMMUNITY/libero_90_no_noops_lerobot
do
  hf download "$repo" \
    --repo-type dataset \
    --local-dir "$LIBERO_DATA_ROOT/${repo#*/}"
done

Language có thể encode online, nhưng cache T5 embeddings giúp training lặp lại nhanh hơn:

python scripts/precompute_language_embeddings.py \
  --data-root "$LIBERO_DATA_ROOT" \
  --data-mix libero_all \
  --output-dir "$SLIM_LANGUAGE_CACHE"

Nếu gặp lỗi video decode, kiểm tra backend torchvision_av. Recipe chính đọc video gốc trực tiếp; frame-backed JPEG chỉ nên dùng cho ablation hoặc debug input pipeline.

Training Stage 1: masked trajectory prediction

Stage 1 là phần tạo nên "linh hồn" của SLIM. Mục tiêu chưa phải policy cuối cùng, mà là học latent interaction giữa current observation, future observation và action chunk. Lệnh helper mặc định dùng 8 GPU:

export WANDB_MODE=offline
bash scripts/train_stage1_8gpu.sh

Lệnh tương đương:

torchrun --standalone --nproc-per-node=8 \
  -m slim.training.stage1 \
  --config configs/libero/stage1_idm0125_fdm1_h8.yaml

Các thông số quan trọng:

Nếu chỉ có ít GPU, bạn không nên kỳ vọng số báo cáo y hệt paper. Điều vẫn đáng học là pipeline: kiểm tra dataset, check shape của action/state, train Stage 1 đến checkpoint, rồi dùng checkpoint đó để khởi tạo Stage 2.

Training Stage 2: flow-matching policy

Stage 2 biến representation đã học thành deployable policy. Model không nhận future observation thật nữa. Nó condition trên current observation latent, proprioception, language embedding và learned future-slot embeddings, rồi học velocity field cho flow matching.

bash scripts/train_stage2_8gpu.sh \
  checkpoints/stage1/<run>/checkpoints/epoch_3_pytorch_model.pt

Lệnh tương đương:

torchrun --standalone --nproc-per-node=8 \
  -m slim.training.stage2 \
  --config configs/libero/stage2_policy_h8_40ep.yaml \
  --init-checkpoint checkpoints/stage1/<run>/checkpoints/epoch_3_pytorch_model.pt

Stage 2 canonical train 40 epochs, dùng Stage 1 checkpoint làm initialization, action horizon 8, global batch size 128 và 4 repeated flow sampling steps ở inference. Nếu training bị dừng giữa chừng, repo có --resume-state và --auto-resume; ưu tiên resume state đầy đủ thay vì chỉ load weight vì distributed data position, optimizer và scheduler đều ảnh hưởng reproduction.

Inference và evaluation trên LIBERO

Nếu bạn không muốn train từ đầu, tải checkpoint public:

python -m pip install --upgrade huggingface_hub
export SLIM_RELEASE_ROOT="$PWD/checkpoints/releases"

hf download kzzwang/SLIM-LIBERO \
  --local-dir "$SLIM_RELEASE_ROOT/SLIM-LIBERO"

export SLIM_LIBERO_CHECKPOINT="$SLIM_RELEASE_ROOT/SLIM-LIBERO/checkpoints/epoch_40_pytorch_model.pt"

Để chạy evaluation chuẩn, SLIM cần tách môi trường training khỏi môi trường simulator. Standard LIBERO và LIBERO-Plus đều expose package tên libero, nên không cài chung trong một virtualenv. Repo khuyến nghị:

Sau khi cấu hình SLIM_TRAIN_PYTHON, SLIM_LIBERO_PYTHON, SLIM_PLUS_PYTHON, SLIM_LIBERO_HOME, SLIM_PLUS_HOME và LIBERO_PLUS_CLASSIFICATION, chạy:

bash scripts/evaluate_all_8gpu.sh \
  "$SLIM_LIBERO_CHECKPOINT" \
  outputs/slim_libero_release \
  12000

Launcher chạy standard LIBERO trước rồi đến LIBERO-Plus, dùng tám policy servers liên tiếp bắt đầu từ port 12000. Output chính nằm ở:

outputs/slim_libero_release/
  libero/summary.txt
  libero_plus/summary.txt

Để debug một suite nhỏ, có thể start policy server:

python -m slim.serving.server \
  --checkpoint "$SLIM_LIBERO_CHECKPOINT" \
  --port 10093 \
  --bf16

Rồi chạy client LIBERO:

TORCH_FORCE_NO_WEIGHTS_ONLY_LOAD=1 \
python -m slim.evaluation.libero.evaluate \
  --checkpoint "$SLIM_LIBERO_CHECKPOINT" \
  --host 127.0.0.1 \
  --port 10093 \
  --task_suite_name libero_10 \
  --num_trials_per_task 50 \
  --action_chunk_size 8 \
  --send-state

Kết quả chính

Trên LIBERO gốc, SLIM đạt 97.5% overall success, tương đương 1,950/2,000 rollouts trong reproducibility record. Trên LIBERO-Plus, checkpoint train từ LIBERO gốc được test zero-shot trên 10,030 perturbation cases và đạt 77.45%, tức 7,768/10,030. Các perturbation gồm camera, robot initial state, language, lighting, background, sensor noise và object layout.

Bảng rút gọn từ paper:

Kết quả này nên đọc cẩn thận. SLIM không vượt mọi baseline ở mọi cột; VLA-JEPA cao hơn một chút trên LIBERO-Plus overall. Nhưng SLIM đạt mức cạnh tranh với model nhỏ hơn nhiều, không cần additional embodied policy/world pretraining, và được thiết kế để inference thấp latency hơn. Trên CALVIN ABC to D, SLIM đạt 4.556/5 average sequence length, cho thấy latent interaction policy không chỉ khớp với task ngắn trong LIBERO mà còn có năng lực composition dài hơn.

Paper cũng báo cáo real-world evaluation trên năm task vật lý với các điều kiện nominal, distractor, lighting và background. SLIM đạt average real-world progress 67.8, policy latency 77.3 ms và policy-server GPU memory 2.01 GiB trong thiết lập tác giả đo. Những con số này làm rõ thông điệp thực dụng của paper: policy nhỏ hơn không chỉ đẹp trên benchmark, mà còn dễ đặt vào hệ thống robot hơn.

Vì sao Stage 1 quan trọng?

Ablation của paper cho thấy nếu bỏ Stage 1 và train policy trực tiếp, robustness giảm đáng kể. EMA target encoder cũng rất quan trọng: trong báo cáo, bật EMA nâng LIBERO-Plus từ 66.82% lên 77.45% và CALVIN từ 4.382 lên 4.556. Điều này hợp lý vì FDM đang dự đoán future latent; nếu target encoder dao động quá mạnh, model học một mục tiêu không ổn định.

Attention analysis cũng đáng chú ý. Tác giả chiếu action-to-observation attention về image plane và so sánh với policy không có Stage 1. SLIM bám tốt hơn vào object đang thao tác, gripper và contact region theo từng giai đoạn của manipulation. Đây là bằng chứng định tính rằng latent không chỉ là embedding thị giác chung; nó thực sự gắn với hành động.

Checklist cho người mới chạy thử

Nếu bạn mới bắt đầu, đừng cố reproduction toàn bộ ngay ngày đầu. Đi theo thứ tự này sẽ ít lỗi hơn:

1. Clone repo SLIM và tạo training environment Python 3.12.9.
2. Tải DINOv2-B/14 đúng source PyTorch Hub và T5-small snapshot đầy đủ.
3. Chạy smoke test load DINOv2 và T5 local-only.
4. Tải một phần dataset LIBERO để kiểm tra schema, video decode và action shape.
5. Tải checkpoint kzzwang/SLIM-LIBERO trước khi train từ đầu.
6. Tạo riêng environment Standard LIBERO và LIBERO-Plus, không cài chung.
7. Chạy một suite nhỏ như libero_10 với 50 trials/task để debug.
8. Sau khi evaluation ổn, mới chạy evaluate_all_8gpu.sh.
9. Nếu muốn train, chạy Stage 1 trước, kiểm tra checkpoint, rồi Stage 2.
10. Ghi lại config hash, seed, batch size, GPU topology và output summary để so sánh.

Lỗi phổ biến nhất là trộn môi trường simulator, dùng sai bản DINOv2, thiếu tokenizer T5, dataset LeRobot không đúng version hoặc thay đổi action/state format mà không cập nhật config. Với LIBERO, chỉ cần sai một path BDDL, assets hoặc init states là evaluation có thể fail trước khi policy được gọi.

Khi nào nên dùng SLIM?

SLIM phù hợp nếu bạn quan tâm đến manipulation policy hiệu quả, có dữ liệu demonstration dạng LeRobot, muốn đánh giá trên LIBERO/LIBERO-Plus/CALVIN, hoặc cần một baseline compact để so với VLA lớn. Nó cũng là case study tốt cho hướng latent world modeling without test-time video generation: dùng tín hiệu dự đoán tương lai để train representation, nhưng giữ inference đơn giản.

SLIM chưa trả lời hết mọi câu hỏi. Paper tập trung vào một scale model 0.47B, nên chưa rõ scaling lên nhiều embodiment, dữ liệu robot rộng hơn hoặc task humanoid toàn thân sẽ như thế nào. Với deploy công nghiệp, bạn vẫn phải xử lý safety, latency toàn hệ thống, sensor sync, recovery policy và domain gap robot thật. Nhưng với người học VLA manipulation, SLIM là một bài rất đáng đọc vì nó nối được ba mảnh thường tách rời: self-supervised latent prediction, flow-matching action generation và benchmark robustness trên LIBERO.

Bài viết liên quan

• VLA Models trong robotics
• LeRobot hands-on
• Chạy Embodied-R1.5-VLA trên LIBERO