Train và Deploy trên OpenArm: Từ 50 episodes đến robot gắp hộp tự động

Ở bài trước, bạn đã thu thập 50 episodes gắp hộp carton trên OpenArm — đó là nhiên liệu. Bài này là động cơ: chúng ta sẽ train 3 policy khác nhau, so sánh kết quả, deploy lên robot thật, và cải thiện bằng Reinforcement Learning. Đây là bài hoàn chỉnh nhất trong series — từ lúc chạy lệnh train đến khi robot tự gắp hộp không cần con người can thiệp.

Mình sẽ trình bày 3 lựa chọn training từ đơn giản đến phức tạp: ACT (nhanh nhất, không cần pretrained model), SmolVLA (cân bằng giữa chất lượng và tốc độ), và Pi0-FAST (mạnh nhất nhưng nặng nhất). Bạn không cần chạy cả 3 — hãy đọc so sánh cuối bài để chọn phương án phù hợp.

Option 1: Train ACT — Nhanh nhất, đơn giản nhất

ACT (Action Chunking with Transformers) là policy architecture được thiết kế đặc biệt cho robot manipulation. Nó không cần pretrained model, không cần language instruction — chỉ cần dữ liệu teleoperation và một GPU tầm trung.

Tại sao bắt đầu với ACT?

ACT là lựa chọn "first experiment" hoàn hảo vì:

• Training nhanh: 1-2 giờ trên RTX 3090 (50K steps)
• Không cần pretrained weights: Model học hoàn toàn từ dữ liệu của bạn
• Stable training: Ít hyperparameter cần tune, hiếm khi diverge
• Proven baseline: Được dùng rộng rãi trong community, dễ so sánh kết quả

Chạy training

lerobot-train \
  --policy.type=act \
  --dataset.repo_id=username/openarm-box-grasp \
  --steps=50000 \
  --batch_size=32

Phân tích từng tham số:

• --policy.type=act: Sử dụng kiến trúc ACT — Transformer encoder-decoder với action chunking (dự đoán chuỗi actions thay vì từng action một)
• --dataset.repo_id: Dataset bạn đã thu thập ở bài trước. LeRobot tự download từ HuggingFace Hub nếu chưa có local
• --steps=50000: Số training steps. Với 50 episodes (~15K frames), 50K steps nghĩa là model thấy mỗi frame khoảng 100 lần — đủ để converge
• --batch_size=32: Số samples mỗi batch. 32 vừa vặn cho RTX 3090 (24GB VRAM). Nếu GPU nhỏ hơn, giảm xuống 16

Theo dõi training

LeRobot tự động log metrics lên Weights & Biases (nếu đã cài). Các metrics quan trọng cần theo dõi:

• train/loss: Phải giảm dần và ổn định. Nếu tăng đột ngột → learning rate quá cao
• train/action_mse: Mean Squared Error giữa predicted và ground truth actions. Càng thấp càng tốt
• eval/success_rate: Nếu bạn config evaluation (chạy policy trong sim), đây là metric quan trọng nhất

Sau 50K steps, model được lưu tại outputs/act/checkpoints/last/pretrained_model/.

Khi nào dùng ACT?

• Thí nghiệm đầu tiên: Xác nhận pipeline hoạt động (data → train → deploy)
• Task đơn giản: Một task cố định, không cần language control
• GPU hạn chế: RTX 3060/3070 vẫn chạy được (giảm batch_size)
• Quick iteration: Thay đổi data → retrain → test chỉ trong vài giờ

Option 2: Fine-tune SmolVLA — Cân bằng chất lượng và tốc độ

SmolVLA là VLA model 450M parameters của HuggingFace, được thiết kế để chạy trên consumer hardware. Điểm khác biệt lớn nhất so với ACT: SmolVLA đã được pretrain trên dữ liệu cộng đồng từ nhiều loại robot — nó mang theo "kinh nghiệm manipulation" sẵn có.

Tại sao SmolVLA là lựa chọn recommended?

Như đã phân tích trong bài về SmolVLA training:

• Cross-embodiment pretrained: Đã học từ SO-100, Koch, Franka data → biết "cách gắp đồ" nói chung
• Language-conditioned: Hiểu instruction "Grasp the carton box and lift it" → có thể dùng cho multi-task
• Data efficient: 50 episodes đủ để fine-tune (ACT cần nhiều hơn cho cùng performance)
• 450M parameters: Đủ nhỏ để train trên RTX 4090, đủ lớn để capture complex behaviors

Chạy fine-tune

lerobot-train \
  --policy.path=lerobot/smolvla_base \
  --dataset.repo_id=username/openarm-box-grasp \
  --batch_size=64 \
  --steps=20000 \
  --output_dir=outputs/openarm_smolvla \
  --policy.device=cuda

Phân tích:

• --policy.path=lerobot/smolvla_base: Load pretrained SmolVLA từ HuggingFace Hub. Đây là điểm khác ACT — bạn bắt đầu từ model đã biết manipulation, không phải từ random weights
• --steps=20000: Ít hơn ACT (50K) vì pretrained model cần ít fine-tuning hơn. Quá nhiều steps → overfit
• --batch_size=64: SmolVLA architecture cho phép batch lớn hơn nhờ efficient design. Nếu OOM, giảm về 32
• --policy.device=cuda: Chỉ định GPU. Nếu có nhiều GPU: cuda:0, cuda:1...

Thời gian training ước tính

Mẹo fine-tuning SmolVLA

Learning rate: Dùng learning rate thấp hơn so với training from scratch. LeRobot default cho fine-tune thường là 1e-5 — nếu model chưa converge, thử 3e-5. Nếu loss dao động mạnh, giảm xuống 5e-6.

Frozen backbone: Nếu GPU hạn chế, bạn có thể freeze vision encoder và chỉ train action head:

lerobot-train \
  --policy.path=lerobot/smolvla_base \
  --dataset.repo_id=username/openarm-box-grasp \
  --policy.freeze_vision_encoder=true \
  --steps=10000

Cách này nhanh hơn 3-4x nhưng performance thấp hơn ~5-10%.

Option 3: Fine-tune Pi0-FAST — Mạnh nhất, nặng nhất

Pi0-FAST (Physical Intelligence + Flow-matching Action Sequence Tokenizer) là state-of-the-art VLA model. Nó kết hợp vision-language model mạnh mẽ với FAST tokenizer — biến continuous actions thành discrete tokens để tận dụng sức mạnh của language model cho action prediction.

Khi nào cần Pi0-FAST?

• Task phức tạp cần fine-grained control
• Cần language instruction flexible (không chỉ 1 task cố định)
• Có GPU mạnh (A100 trở lên)
• Đã thử SmolVLA và muốn push performance cao hơn

Chạy fine-tune

lerobot-train \
  --policy.type=pi0_fast \
  --policy.pretrained_path=lerobot/pi0_fast_base \
  --dataset.repo_id=username/openarm-box-grasp \
  --policy.dtype=bfloat16 \
  --policy.gradient_checkpointing=true \
  --steps=50000

Các tham số đặc biệt:

• --policy.dtype=bfloat16: Mixed precision training — giảm VRAM ~50% với performance loss không đáng kể
• --policy.gradient_checkpointing=true: Trade compute cho memory — chậm hơn ~30% nhưng dùng ít VRAM hơn đáng kể. Bắt buộc trên RTX 4090

FAST tokenizer cho OpenArm

Pi0-FAST cần biết action space cụ thể của robot để build tokenizer. Đối với OpenArm 6-DOF, bạn cần đảm bảo tokenizer config phù hợp:

# Kiểm tra action space
from lerobot.common.datasets.lerobot_dataset import LeRobotDataset
ds = LeRobotDataset("username/openarm-box-grasp")
print(f"Action dim: {ds[0]['action'].shape}")  # Phải là (6,) cho 6-DOF
print(f"State dim: {ds[0]['state'].shape}")    # Phải là (6,)

FAST tokenizer tự động discretize continuous actions thành tokens dựa trên action range trong dataset. Điều này minh bạch với user — bạn không cần config thủ công.

Cảnh báo: Pi0-FAST training rất tốn VRAM. Trên RTX 4090 với gradient checkpointing + bfloat16, batch_size tối đa khoảng 8-16. Nếu OOM, giảm batch_size hoặc chuyển sang SmolVLA.

Deploy trên robot thật — Khoảnh khắc sự thật

Đây là bước thú vị nhất — xem model bạn vừa train tự điều khiển robot gắp hộp carton mà không cần bạn cầm leader arm.

Chạy policy evaluation

LeRobot sử dụng cùng script lerobot-record nhưng thêm flag --policy.path để chạy trong autonomous mode:

lerobot-record \
  --robot.type=openarm_follower \
  --robot.port=can0 \
  --robot.side=right \
  --robot.id=my_follower \
  --robot.cameras="{ top: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}}" \
  --dataset.single_task="Grasp the carton box and lift it" \
  --dataset.repo_id=username/openarm-box-eval \
  --dataset.num_episodes=10 \
  --policy.path=outputs/openarm_smolvla/checkpoints/last/pretrained_model

Lúc này:

• Robot tự quyết định actions dựa trên camera input và learned policy
• Bạn đứng cạnh với tay trên nút E-stop (emergency stop) phòng trường hợp robot di chuyển bất thường
• Mỗi episode được record vào dataset mới (openarm-box-eval) để phân tích sau

Đánh giá kết quả

Chạy 10 episodes evaluation và ghi lại:

Success rate mong đợi (với 50 episodes training data):

Nếu success rate < 50%, có vấn đề với data hoặc calibration. Quay lại kiểm tra bài thu thập dữ liệu.

Cải thiện bằng HIL-SERL — RL trực tiếp trên robot thật

Nếu policy đã đạt 70-80% nhưng bạn muốn push lên 90%+, HIL-SERL (Human-in-the-Loop Sample Efficient RL) là con đường hiệu quả nhất. Thay vì thu thập thêm demonstrations (tốn thời gian), bạn để robot tự cải thiện bằng RL với sự hỗ trợ của con người.

Bước 1: Train reward classifier

Reward classifier là mạng neural nhỏ dự đoán "task này thành công hay thất bại?" từ hình ảnh camera. Nó được train từ evaluation data bạn vừa thu thập:

# Pseudo-code: train reward classifier
# Dùng 10 eval episodes đã labeled (success/fail)
# Input: camera frame cuối episode
# Output: probability of success (0.0 - 1.0)

HIL-SERL sử dụng reward classifier này thay vì binary reward từ simulator — vì chúng ta đang train trên robot thật, không có simulator để query "task đã hoàn thành chưa?"

Bước 2: Actor-Learner SAC loop

SAC (Soft Actor-Critic) là thuật toán RL phù hợp nhất cho robot thật vì:

• Sample efficient: Cần ít interactions hơn PPO/GRPO
• Off-policy: Có thể reuse data từ các episodes trước
• Stable: Ít bị diverge trong continuous action spaces

Quy trình HIL-SERL:

1. Robot thực hiện task (actor)
2. Reward classifier đánh giá kết quả
3. SAC cập nhật policy (learner)
4. Con người can thiệp khi robot sắp va chạm hoặc đi sai hướng
5. Lặp lại 100-200 episodes

Bước 3: Human interventions

Đây là phần "Human-in-the-Loop" — bạn ngồi cạnh robot với gamepad/keyboard:

• Nhấn nút can thiệp khi robot sắp gây nguy hiểm
• Override control bằng leader arm để sửa quỹ đạo
• Resume autonomous khi robot đã ở vị trí an toàn

Mỗi intervention trở thành data point có giá trị cao — nó cho model biết chính xác "ở state này, hành vi đang làm là sai, đây là hành vi đúng."

Chi tiết về HIL-SERL đã được phân tích sâu trong bài viết chuyên đề. Đọc bài đó để hiểu actor-learner architecture, reward classifier training, và safety guidelines.

Cải thiện bằng SimpleVLA-RL (nếu có simulation)

Nếu bạn là advanced user và muốn tận dụng approach của SimpleVLA-RL — train RL hoàn toàn trong simulation rồi transfer sang robot thật — OpenArm cũng có con đường này.

OpenArm trong Isaac Lab

OpenArm có repository hỗ trợ NVIDIA Isaac Lab (openarm_isaac_lab). Điều này cho phép:

1. SFT trong sim: Dùng 50 episodes thật để train baseline policy, rồi generate thêm dữ liệu trong sim
2. RL trong sim: Áp dụng GRPO/PPO để cải thiện policy bằng reward từ simulator
3. Sim-to-real: Transfer policy sang OpenArm thật

Pipeline hoàn chỉnh: SFT (real data) → RL (sim data) → Deploy (real robot)

Đây là con đường mạnh nhất nhưng phức tạp nhất. Bạn cần:

• Mô hình URDF/MJCF chính xác của OpenArm
• Domain randomization (texture, lighting, physics) để giảm sim-to-real gap
• Reward function phù hợp cho task gắp hộp

Lời khuyên: Nếu bạn mới bắt đầu, đừng đi con đường sim trước. Hãy bắt đầu với ACT/SmolVLA → deploy → HIL-SERL. Sim-to-real pipeline chỉ nên thử khi bạn đã master pipeline cơ bản.

Bảng so sánh toàn diện: ACT vs SmolVLA vs Pi0-FAST

Đây là bảng tổng hợp giúp bạn chọn đúng policy cho tình huống của mình:

Đọc bảng này thế nào?

• Inference speed quan trọng hơn bạn nghĩ. ACT ở 50Hz phản ứng gần real-time, SmolVLA ở 15Hz vẫn OK cho hầu hết task, Pi0-FAST ở 5Hz có thể gây jittery nếu task cần reaction nhanh
• Multi-task: Nếu bạn muốn một model gắp hộp VÀ đặt hộp VÀ xếp hộp — ACT cần 3 model riêng, SmolVLA/Pi0-FAST chỉ cần 1 model với language instructions khác nhau
• Expected success là con số ước tính từ community benchmarks, không phải đảm bảo — phụ thuộc nhiều vào chất lượng dữ liệu

Workflow iteration hoàn chỉnh

Đây là quy trình mình khuyến nghị, từ bước đầu đến khi robot hoạt động ổn định:

Giai đoạn 1: Baseline nhanh (ngày 1)

1. Thu thập 50 episodes (bài trước)
2. Train ACT — 1-2 giờ
3. Deploy → đánh giá success rate
4. Nếu > 50% → pipeline hoạt động, dữ liệu OK

Giai đoạn 2: Nâng cấp policy (ngày 2-3)

5. Nếu ACT baseline tốt → train SmolVLA fine-tune — 4-12 giờ
6. Deploy SmolVLA → so sánh với ACT
7. Nếu SmolVLA > ACT 10%+ → dùng SmolVLA làm chính

Giai đoạn 3: Thu thập thêm dữ liệu (ngày 4-5)

8. Nếu cần → thu thập thêm 50-100 episodes
9. Đa dạng hóa: thêm nhiều kích cỡ hộp, vị trí, ánh sáng khác nhau
10. Retrain SmolVLA với dataset lớn hơn

Giai đoạn 4: RL improvement (ngày 6-7)

11. Nếu muốn push > 85% → dùng HIL-SERL
12. 100-200 RL episodes với human intervention
13. Đánh giá lại success rate

Giai đoạn 5: Advanced (tuần 2+)

14. Nếu cần language control → thử Pi0-FAST
15. Nếu muốn sim-to-real → setup Isaac Lab environment
16. Scale lên multi-task: thêm "stack boxes," "sort by size"...

Tóm tắt: Pipeline hoàn chỉnh từ unboxing đến autonomous grasping

Qua 2 bài viết (phần 7 và 8), chúng ta đã đi qua toàn bộ pipeline:

1. Hardware setup: CAN bus, camera, calibration
2. Data collection: 50 episodes teleoperation với LeRobot
3. Training: ACT (baseline) → SmolVLA (recommended) → Pi0-FAST (advanced)
4. Deployment: Chạy policy trên robot thật, đánh giá success rate
5. RL improvement: HIL-SERL cho 10-15% improvement thêm

Pipeline này không chỉ áp dụng cho gắp hộp carton. Bạn có thể dùng cùng quy trình cho bất kỳ manipulation task nào: xếp đồ, rót nước, lắp ráp,... Thay đổi duy nhất là task description và training data.

Đây chính là sức mạnh của approach end-to-end learning: bạn không cần viết code điều khiển phức tạp cho từng task — chỉ cần demo cho robot xem → train → deploy. Và với OpenArm + LeRobot, pipeline này accessible cho bất kỳ ai có $3,500 và một GPU.

Nếu bạn mới bắt đầu với series này, hãy đọc SimpleVLA-RL (1): Tổng quan để hiểu bức tranh toàn cảnh. Và nếu muốn hiểu sâu hơn về quá trình training RL cho VLA, bài viết đó giải thích chi tiết thuật toán GRPO và tại sao nó hiệu quả.

Bài viết liên quan

• SimpleVLA-RL (7): Collect Data cho OpenArm — Hướng dẫn thu thập 50 episodes gắp hộp carton
• SmolVLA Training với LeRobot — Fine-tune SmolVLA 450M chi tiết
• HIL-SERL: RL trên robot thật — Cải thiện policy bằng human-in-the-loop RL