SmolVLA: Train VLA 450M trên Consumer GPU

SmolVLA: VLA cho mọi người, không chỉ cho phòng lab

Nếu bạn đã đọc bài tổng quan LeRobot v0.5, bạn biết rằng VLA (Vision-Language-Action) models đang thay đổi cách chúng ta lập trình robot. Nhưng có một vấn đề lớn: hầu hết VLA models đòi hỏi GPU cấp data center — A100, H100 — để train và inference. Điều này giới hạn VLA cho các công ty lớn và phòng lab giàu tài nguyên.

SmolVLA thay đổi hoàn toàn bức tranh đó. Với chỉ 450M parameters, SmolVLA chạy được trên RTX 3060 — GPU phổ biến nhất trên thị trường. Bạn có thể fine-tune nó trên laptop gaming, deploy trên Jetson Orin, và đạt 78% real-world success rate trên manipulation tasks.

Trong bài này, chúng ta sẽ đi từng bước: từ hiểu kiến trúc, thu thập dữ liệu, fine-tune model, cho đến deploy trên robot thật.

SmolVLA là gì?

Tổng quan kiến trúc

SmolVLA là VLA model nhỏ gọn nhất hiện tại có khả năng hoạt động tốt trong thực tế. Kiến trúc gồm ba thành phần chính:

1. SigLIP Vision Encoder (~100M params)

Xử lý hình ảnh từ camera
Output: visual tokens đại diện cho scene
Điểm đặc biệt: chỉ dùng 64 tokens per frame (thay vì 1024 như các VLA khác) nhờ visual token reduction

2. SmolLM2 Language Decoder (~250M params)

Xử lý text instructions (ví dụ: "pick up the red cube")
Kết hợp visual tokens và language tokens
Output: latent representations cho action expert

3. Flow Matching Action Expert (~100M params)

Nhận latent representations từ language decoder
Sinh ra continuous robot actions qua iterative denoising
Output: action chunk (ví dụ: 10 actions, mỗi action gồm joint positions + gripper state)

Tổng: ~450M parameters — nhỏ hơn 10x so với OpenVLA (7B) và 6x so với Pi0 (3B).

Tại sao SmolVLA nhỏ mà vẫn tốt?

Bí quyết nằm ở ba kỹ thuật chính:

Layer Skipping: Thay vì truyền mọi visual token qua tất cả transformer layers, SmolVLA chỉ truyền qua một số layers được chọn. Điều này giảm computation mà không ảnh hưởng đáng kể đến accuracy.

Visual Token Reduction: Các VLA truyền thống encode mỗi frame thành 1024 tokens — rất tốn kém cho attention mechanism. SmolVLA nén xuống còn 64 tokens bằng learned pooling, giảm 16x computation trong attention layers.

Flow Matching thay Diffusion: Action expert dùng flow matching — phiên bản đơn giản và hiệu quả hơn của diffusion process, cần ít denoising steps hơn (5-10 steps thay vì 50-100).

So sánh với các VLA models khác

Model	Params	Min GPU	Real-world Success	Inference Speed
OpenVLA	7B	A100 80GB	~70%	~2 Hz
Pi0	3B	A100 40GB	~85%	~5 Hz
Pi0-FAST	3B	RTX 4090	~82%	~25 Hz
SmolVLA	450M	RTX 3060	78%	~15 Hz

SmolVLA hy sinh một ít accuracy (78% vs 85% của Pi0) để đổi lấy khả năng chạy trên hardware phổ thông — một tradeoff rất xứng đáng cho hầu hết ứng dụng.

Bước 1: Cài đặt LeRobot và SmolVLA dependencies

Yêu cầu hệ thống

Python 3.12+ (bắt buộc cho LeRobot v0.5)
CUDA 12.1+ (hoặc ROCm 6.0+ cho AMD GPU)
GPU: tối thiểu 6GB VRAM cho inference, 12GB+ cho training
RAM: 16GB+ (32GB khuyến nghị)

Cài đặt

# Tạo virtual environment
python3.12 -m venv smolvla-env
source smolvla-env/bin/activate

# Clone LeRobot
git clone https://github.com/huggingface/lerobot.git
cd lerobot

# Cài đặt với SmolVLA extras
pip install -e ".[smolvla]"

# Verify installation
python -c "from lerobot.policies import SmolVLAPolicy; print('SmolVLA OK')"

Gói [smolvla] sẽ cài thêm transformers>=5.0, accelerate, và các dependencies cần thiết cho SigLIP và SmolLM2.

Kiểm tra GPU

python -c "
import torch
print(f'CUDA available: {torch.cuda.is_available()}')
print(f'GPU: {torch.cuda.get_device_name(0)}')
print(f'VRAM: {torch.cuda.get_device_properties(0).total_mem / 1e9:.1f} GB')
"

Bước 2: Thu thập dataset

Tại sao dữ liệu quan trọng hơn model?

Một kinh nghiệm quan trọng từ cộng đồng LeRobot: data quality > model size. SmolVLA 450M params với 100 episodes chất lượng cao sẽ outperform OpenVLA 7B với 50 episodes chất lượng thấp.

Điều này có nghĩa là bạn nên dành 60-70% thời gian cho data collection và chỉ 30-40% cho training/tuning.

Thu thập dữ liệu với LeRobot

Nếu bạn có robot thật (SO-100, SO-101, hoặc tương thích), dùng lerobot-record:

# Record 50 episodes cho task pick-and-place
lerobot-record \
  --robot.type=so100 \
  --repo_id=YOUR_USERNAME/pick_place_cube \
  --num_episodes=50 \
  --fps=30

Nếu bạn muốn hiểu rõ hơn về quy trình thu thập dữ liệu, tham khảo bài về teleop và data collection trong series này.

Tips thu thập dữ liệu chất lượng

Đa dạng vị trí khởi đầu: Đặt object ở nhiều vị trí khác nhau. Nếu bạn chỉ đặt cube ở giữa bàn, robot sẽ chỉ biết pick từ giữa bàn.

Tốt: 50 episodes, 10 vị trí cube khác nhau, 5 episodes mỗi vị trí
Xấu: 50 episodes, cube luôn ở cùng 1 chỗ

Đa dạng tốc độ: Teleop với tốc độ tự nhiên, đừng quá nhanh hay quá chậm. Tránh pause giữa chừng — nếu bạn pause, robot sẽ học rằng "đứng yên" là hành vi hợp lệ.

Kiểm tra frame rate: Đảm bảo record ở 30 FPS ổn định. FPS không ổn định sẽ tạo ra temporal inconsistency trong training.

Số lượng tối thiểu:

Task đơn giản (pick-and-place 1 object): 50 episodes
Task phức tạp (stacking, sorting): 100-200 episodes
Task với nhiều variations: 10 episodes per variation (ví dụ: 5 loại object x 10 episodes = 50)

Dùng dataset có sẵn

Nếu chưa có robot, bạn có thể fine-tune trên datasets có sẵn:

# Dùng dataset reference của SmolVLA
lerobot-train \
  --policy.path=lerobot/smolvla_base \
  --dataset.repo_id=lerobot/svla_so100_pickplace \
  --training.batch_size=64 \
  --training.steps=20000

Dataset lerobot/svla_so100_pickplace chứa ~200 episodes pick-and-place trên SO-100, đã format sẵn cho SmolVLA.

Bước 3: Fine-tune SmolVLA từ pretrained

Tại sao fine-tune thay vì train from scratch?

SmolVLA base model (lerobot/smolvla_base) đã được pretrain trên hàng nghìn hours of robot data, bao gồm:

Bridge V2 dataset
DROID dataset
Open-X Embodiment data
Và nhiều datasets khác

Pretrained model đã học được general manipulation skills: cách approach objects, khi nào nên đóng gripper, cách di chuyển smoothly. Fine-tuning chỉ cần dạy nó task cụ thể và embodiment cụ thể của bạn.

Điều này giảm số episodes cần thiết từ hàng nghìn xuống 50-100 và thời gian training từ nhiều ngày xuống vài giờ.

Lệnh fine-tune cơ bản

lerobot-train \
  --policy.path=lerobot/smolvla_base \
  --dataset.repo_id=YOUR_USERNAME/pick_place_cube \
  --training.batch_size=64 \
  --training.steps=20000 \
  --training.lr=1e-5 \
  --training.save_freq=5000

Giải thích tham số

--policy.path: Path đến pretrained model trên Hugging Face Hub
--dataset.repo_id: Dataset của bạn (hoặc dataset public)
--training.batch_size: Số samples per batch. Giảm nếu hết VRAM:
- A100 80GB: batch_size=128
- RTX 4090 24GB: batch_size=64
- RTX 3090 24GB: batch_size=32
- RTX 3060 12GB: batch_size=16
--training.steps: Tổng số training steps. 20000 là điểm khởi đầu tốt cho 50-100 episodes
--training.lr: Learning rate. 1e-5 là safe default cho fine-tuning
--training.save_freq: Lưu checkpoint sau mỗi N steps

Thời gian training ước tính

GPU	Batch Size	20k Steps	50k Steps
A100 80GB	128	~2 giờ	~5 giờ
RTX 4090	64	~4 giờ	~10 giờ
RTX 3090	32	~6 giờ	~15 giờ
RTX 3060	16	~10 giờ	~25 giờ

Google Colab

Nếu bạn không có GPU mạnh, SmolVLA có thể train trên Google Colab Pro (A100):

# Trong Colab notebook
!pip install lerobot[smolvla]

# Login Hugging Face
from huggingface_hub import login
login()

# Train
!lerobot-train \
  --policy.path=lerobot/smolvla_base \
  --dataset.repo_id=lerobot/svla_so100_pickplace \
  --training.batch_size=64 \
  --training.steps=20000 \
  --training.output_dir=/content/outputs

Monitoring training

LeRobot v0.5 log training metrics lên Weights & Biases (nếu đã cài):

pip install wandb
wandb login

lerobot-train \
  --policy.path=lerobot/smolvla_base \
  --dataset.repo_id=YOUR_USERNAME/pick_place_cube \
  --training.batch_size=64 \
  --training.steps=20000 \
  --training.wandb.enable=true \
  --training.wandb.project=smolvla-finetune

Theo dõi action_loss — nó nên giảm dần và stabilize. Nếu loss plateau sớm (trước 10k steps), có thể bạn cần thêm data hoặc tăng learning rate.

Bước 4: Evaluate trên robot thật

Deploy policy

Sau khi training xong, bạn có thể deploy model trực tiếp:

# Chạy policy trên robot thật
lerobot-record \
  --robot.type=so100 \
  --policy.path=outputs/train/smolvla/checkpoints/last/pretrained_model \
  --repo_id=YOUR_USERNAME/eval_results \
  --num_episodes=10

Lệnh này sẽ:

Load trained model
Chạy inference loop: camera → model → robot actions
Record kết quả vào dataset (để review sau)

Evaluate trên simulation

Nếu muốn test trước khi deploy trên robot thật:

lerobot-eval \
  --policy.path=outputs/train/smolvla/checkpoints/last/pretrained_model \
  --env.type=libero \
  --env.task=libero_object \
  --eval.num_episodes=50

Metrics quan trọng

Success rate: Tỷ lệ hoàn thành task (mục tiêu >70%)
Completion time: Thời gian trung bình hoàn thành (mục tiêu <15 giây cho pick-and-place)
Smoothness: Trajectory không bị giật, không có sudden movements

Tính năng nâng cao

Async Inference: 30% nhanh hơn

SmolVLA hỗ trợ asynchronous inference — trong khi robot đang thực thi actions từ chunk hiện tại, model chạy inference cho chunk tiếp theo ở background:

lerobot-train \
  --policy.path=lerobot/smolvla_base \
  --policy.async_inference=true \
  --dataset.repo_id=YOUR_USERNAME/pick_place_cube

Kết quả: 30% reduction in latency, throughput tăng gấp 2 lần. Đặc biệt hữu ích trên hardware chậm hơn (RTX 3060, Jetson Orin).

Visual Token Reduction chi tiết

Mặc định SmolVLA dùng 64 visual tokens per frame. Bạn có thể điều chỉnh:

# Ít tokens hơn = nhanh hơn, nhưng mất chi tiết
lerobot-train \
  --policy.path=lerobot/smolvla_base \
  --policy.num_visual_tokens=32 \
  --dataset.repo_id=YOUR_USERNAME/dataset

# Nhiều tokens hơn = chậm hơn, nhưng chi tiết hơn (cho tasks cần precision)
lerobot-train \
  --policy.path=lerobot/smolvla_base \
  --policy.num_visual_tokens=128 \
  --dataset.repo_id=YOUR_USERNAME/dataset

Quy tắc: Dùng 64 tokens cho hầu hết tasks. Tăng lên 128 nếu task đòi hỏi fine-grained spatial reasoning (ví dụ: inserting a peg into a hole).

Multi-camera support

SmolVLA hỗ trợ nhiều camera:

lerobot-train \
  --policy.path=lerobot/smolvla_base \
  --policy.camera_names=["top","wrist"] \
  --dataset.repo_id=YOUR_USERNAME/dataset

Tips: Wrist camera giúp cải thiện đáng kể grasping accuracy. Nếu bạn chỉ có 1 camera, ưu tiên wrist camera hơn top-down camera.

Troubleshooting thường gặp

CUDA Out of Memory

torch.cuda.OutOfMemoryError: CUDA out of memory

Giải pháp: Giảm batch_size. Nếu batch_size=8 vẫn OOM, thử:

lerobot-train \
  --policy.path=lerobot/smolvla_base \
  --training.batch_size=4 \
  --training.gradient_accumulation_steps=8 \
  --dataset.repo_id=YOUR_USERNAME/dataset

gradient_accumulation_steps=8 với batch_size=4 cho effective batch size = 32 mà không tốn thêm VRAM.

Loss không giảm

Nếu loss plateau ngay từ đầu:

Kiểm tra dataset: Đảm bảo format đúng (lerobot-check-dataset --repo_id=YOUR/dataset)
Tăng learning rate: Thử lr=5e-5 thay vì 1e-5
Kiểm tra task description: SmolVLA dùng language conditioning — task description phải rõ ràng và consistent

Robot actions bị giật

Nếu robot di chuyển giật khi inference:

Bật action smoothing: --policy.temporal_smoothing=true
Tăng chunk_size: --policy.chunk_size=20 (mặc định 10)
Kiểm tra FPS: inference phải chạy ở >=10 Hz

Kết luận

SmolVLA là bước đột phá trong việc democratize robot AI. Lần đầu tiên, bạn có thể train một VLA model có khả năng hoạt động trong thực tế mà không cần GPU data center. Pipeline hoàn chỉnh — từ collect data, fine-tune, đến deploy — đều chạy được trên hardware mà bất kỳ sinh viên hay hobbyist nào cũng có thể sở hữu.

Tuy nhiên, hãy nhớ: data quality là yếu tố quyết định. Dành thời gian thu thập dữ liệu đa dạng, consistent, và đủ số lượng sẽ đem lại kết quả tốt hơn rất nhiều so với việc chỉ tập trung vào hyperparameter tuning.

Nếu bạn muốn hiểu sâu hơn về nền tảng lý thuyết, đọc bài PSi0: Tổng quan kiến trúc và Diffusion Policy chi tiết. Nếu bạn sẵn sàng cho một model mạnh hơn, bài tiếp theo sẽ hướng dẫn Pi0-FAST — VLA autoregressive 5x nhanh hơn.