LeRobot v0.6: Reward Models và lerobot-eval CLI

Ngày 7 tháng 7 năm 2026, Hugging Face phát hành LeRobot v0.6.0 — bản cập nhật lớn nhất trong lịch sử dự án. Nếu các phiên bản trước tập trung vào thu thập dữ liệu và policy training, thì v0.6 lần này giải quyết bài toán khó nhất mà hầu hết dự án robotics đều vấp phải: làm sao biết robot đang học đúng hay sai, và làm sao tự động cải thiện liên tục?

Câu trả lời của LeRobot v0.6 gồm ba mảnh ghép quan trọng:

• Reward Models (Robometer + TOPReward) để tự động đánh giá chất lượng trajectory
• lerobot-eval CLI với 6 benchmark simulation mới để chuẩn hóa đánh giá policy
• lerobot-rollout + DAgger để thu thập correction data trên robot thật

Bài này sẽ hướng dẫn chi tiết cách dùng từng công cụ và nối chúng lại thành một vòng lặp RL hoàn chỉnh.

Vấn đề: Tại Sao Vòng Lặp RL Cho Robot Hay Bị Gãy?

Hãy tưởng tượng bạn đang dạy robot pick-and-place. Bạn thu thập 100 demonstration, train policy, chạy thử — robot có vẻ ổn ở bước 1, 2 nhưng fail ở bước 3. Bạn thu thập thêm dữ liệu, train lại, nhưng không biết liệu dữ liệu mới có thực sự tốt hơn hay không.

Đây là vòng lặp bị gãy của robotics:

Thu thập dữ liệu → Train → Chạy thử → Thấy fail → Thu thập thêm → Train lại → ...

Vấn đề nằm ở khâu đánh giá: bạn không có cách nào tự động biết:

1. Episode nào trong dataset chất lượng cao, episode nào tệ?
2. Policy mới tốt hơn policy cũ bao nhiêu phần trăm?
3. Khi nào nên can thiệp để collect correction data?

LeRobot v0.6 giải quyết đúng ba câu hỏi này.

Cài Đặt LeRobot v0.6

# Cài đặt cơ bản
pip install lerobot

# Cài thêm cho reward models (Robometer)
pip install "lerobot[robometer]"

# Hoặc nếu dùng uv từ source
uv sync --extra robometer --extra evaluation

LeRobot v0.6 đã tối ưu dependencies: giảm ~40% số package cần thiết cho base install. Các tính năng nặng (reward models, simulation benchmarks) được tách thành optional extras.

Robometer — Reward Model Đa Năng Được Train Trên 1 Triệu Trajectory

Ý Tưởng Cốt Lõi

Robometer là một reward model tổng quát (general-purpose reward model), nghĩa là bạn có thể dùng nó để đánh giá bất kỳ task manipulation nào mà không cần fine-tune. Nó học cách đọc video trajectory + mô tả task bằng ngôn ngữ, rồi cho điểm tiến độ và success.

Paper gốc: ROBOMETER: Scaling General-Purpose Robotic Reward Models via Trajectory Comparisons (RSS 2026)

Kiến Trúc

Robometer xây trên backbone Qwen3-VL-4B-Instruct — VLM 4 tỷ tham số hiểu cả video lẫn văn bản. Bên trên, team thêm 3 prediction heads:

Training objective: L = L_pref + L_prog + L_succ — học đồng thời 3 tasks để generalize tốt hơn.

Dataset training: 1 triệu robot trajectories thu thập từ nhiều nguồn khác nhau.

Cách Dùng Robometer

Cách 1: Load trực tiếp

from lerobot.rewards.robometer import RobometerConfig, RobometerRewardModel

cfg = RobometerConfig(
    pretrained_path="lerobot/Robometer-4B",
    device="cuda",
    reward_output="progress",  # hoặc "success"
)
reward_model = RobometerRewardModel.from_pretrained(cfg.pretrained_path, config=cfg)

Cách 2: Encode frames và tính reward

import numpy as np
from lerobot.rewards.robometer.modeling_robometer import ROBOMETER_FEATURE_PREFIX
from lerobot.rewards.robometer.processor_robometer import RobometerEncoderProcessorStep

# frames: np.ndarray, shape (T, H, W, C), dtype uint8
# task: str — mô tả nhiệm vụ bằng tiếng Anh
frames = np.zeros((8, 480, 640, 3), dtype=np.uint8)  # placeholder
task = "Pick up the red block and place it in the bin"

encoder = RobometerEncoderProcessorStep(
    base_model_id="Qwen/Qwen3-VL-4B-Instruct",
    use_multi_image=True,
    use_per_frame_progress_token=True,
    max_frames=8,
)

encoded = encoder.encode_samples([(frames, task)])
batch = {f"{ROBOMETER_FEATURE_PREFIX}{key}": value for key, value in encoded.items()}

# reward là tensor shape (batch_size,), giá trị trong [0, 1]
reward = reward_model.compute_reward(batch)
print(f"Task progress: {reward.item():.3f}")

Cách 3: Dùng reward factory (khuyến nghị)

from lerobot.rewards import make_reward_model, make_reward_model_config, make_reward_pre_post_processors

cfg = make_reward_model_config(
    "robometer",
    pretrained_path="lerobot/Robometer-4B",
    device="cuda",
    image_key="observation.images.top",  # key camera trong dataset
)
reward_model = make_reward_model(cfg)
preprocessor, postprocessor = make_reward_pre_post_processors(cfg)

Reward factory là cách tích hợp sạch nhất vào training loop của LeRobot — preprocessor tự động encode video, postprocessor xử lý output.

Ứng Dụng Thực Tế: Dataset Quality Inspection

Một trong những dùng Robometer hay nhất không phải là online RL, mà là lọc dataset. Sau khi collect 500 demonstrations, bạn có thể dùng Robometer để score từng episode và loại bỏ những episode có progress thấp hoặc không reach success — giữ lại top 80% để train policy tốt hơn.

TOPReward — Zero-Shot Reward Không Cần Training

Ý Tưởng Thiên Tài: VLM Như Một Reward Function

TOPReward (Token Probabilities as Hidden Zero-Shot Rewards) là một cách tiếp cận hoàn toàn khác: không train gì cả. Thay vào đó, nó hỏi một VLM off-the-shelf (Qwen3-VL) câu hỏi:

"Nhìn vào video trajectory này và task instruction, robot có hoàn thành task không? True hay False?"

Rồi đọc log-probability của token "True" trong output của VLM. Probability cao = robot đang làm tốt.

Paper: TOPReward: Token Probabilities as Hidden Zero-Shot Rewards for Robotics

from lerobot.rewards import make_reward_model_config, make_reward_model

cfg = make_reward_model_config(
    "topreward",
    vlm_id="Qwen/Qwen3-VL-7B-Instruct",  # VLM nền
    device="cuda",
    image_key="observation.images.top",
    task_key="task",
)
reward_model = make_reward_model(cfg)

Robometer vs TOPReward — Khi Nào Dùng Cái Nào?

Thực tế: Dùng Robometer cho vòng lặp training liên tục (cần tốc độ), TOPReward cho evaluation lần đầu trên task mới (không cần fine-tune).

lerobot-eval CLI — Chuẩn Hóa Benchmark Cho Manipulation VLA

Vấn Đề Cũ: Mỗi Paper Dùng Một Benchmark Riêng

Trước v0.6, mỗi paper VLA đánh giá trên một bộ benchmark khác nhau, với config khác nhau, metric khác nhau — so sánh giữa các model gần như không thể. LeRobot v0.6 giới thiệu lerobot-eval CLI để chuẩn hóa.

6 Benchmark Mới

Ngoài 6 benchmark mới, lerobot-eval cũng hỗ trợ LIBERO, Meta-World, và NVIDIA IsaacLab-Arena từ trước.

Cách Chạy lerobot-eval

Đánh giá SmolVLA trên RoboTwin:

lerobot-eval \
  --policy.path=lerobot/smolvla_robotwin \
  --env.type=robotwin \
  --env.task=beat_block_hammer \
  --eval.n_episodes=100 \
  --eval.batch_size=4

Đánh giá trên LIBERO-plus:

lerobot-eval \
  --policy.path=${HF_USER}/my_policy \
  --env.type=libero_plus \
  --env.task=KITCHEN_SCENE1_put_the_black_bowl_on_the_plate \
  --eval.n_episodes=50

Output metrics:

{
  "episode": {"pc_success": 0.82, "avg_sum_reward": 14.3},
  "task": {"pc_success": 0.79},
  "suite": {"pc_success": 0.76},
  "overall": {"pc_success": 0.74, "avg_max_reward": 0.91}
}

Metrics được aggregate theo thứ bậc: episode → task → suite → overall. pc_success là success rate chính, avg_sum_reward và avg_max_reward dùng để debug khi reward model được tích hợp.

lerobot-rollout + DAgger — Đóng Vòng Lặp Trên Robot Thật

Tại Sao DAgger Quan Trọng?

Behavioral Cloning thuần (train trên expert demos) bị distribution shift: robot chạy vào state mà trong training data chưa có → không biết xử lý. DAgger (Dataset Aggregation) giải quyết bằng cách để robot tự chạy, con người can thiệp khi cần, và thu thập correction data ngay tại state robot đang ở.

Các Deployment Strategy Trong lerobot-rollout

LeRobot v0.6 có 5 strategy:

Chạy DAgger Với SO-100 Robot

lerobot-rollout \
    --strategy.type=dagger \
    --policy.path=${HF_USER}/my_manipulation_policy \
    --robot.type=so100_follower \
    --robot.port=/dev/ttyACM0 \
    --teleop.type=so101_leader \
    --teleop.port=/dev/ttyACM1 \
    --dataset.repo_id=${HF_USER}/dagger_corrections \
    --dataset.single_task="Pick up the red block and place it in the blue bin"

Workflow thực tế:

1. Policy tự chạy pick-and-place
2. Bạn nhìn thấy robot sắp fail (sai góc gripper)
3. Nhấn phím can thiệp → arm leader được drive về vị trí follower (jerk-free handover)
4. Bạn điều khiển correction bằng leader arm
5. Nhả phím → policy tiếp tục
6. Frame correction được tag với flag intervention=True
7. Sau session, fine-tune policy trên correction data

Điểm hay là handover không bị giật — arm được drive về vị trí hiện tại của robot trước khi bạn cầm lấy.

FSDP Training — Thoát Khỏi Giới Hạn Một GPU

Khi model VLA lớn vượt quá VRAM một GPU, FSDP (Fully Sharded Data Parallel) chia parameters, gradients, và optimizer state ra nhiều GPU. LeRobot v0.6 tích hợp FSDP qua Hugging Face Accelerate:

# Train với 4 GPU
accelerate launch --num_processes 4 \
  lerobot-train \
  --policy.type=smolvla \
  --policy.dtype=bfloat16 \
  --dataset.repo_id=${HF_USER}/my_dataset \
  --policy.repo_id=${HF_USER}/my_large_policy

Checkpoint FSDP tự động được gather lại thành model.safetensors duy nhất — load như policy thường. Bạn thậm chí có thể resume run FSDP trên số GPU khác.

HF Jobs — Cloud Training 1 Flag

lerobot-train \
  --dataset.repo_id=${HF_USER}/so101_pick_place \
  --policy.type=act \
  --policy.repo_id=${HF_USER}/act_pick_place \
  --job.target=a10g-small  # hoặc: t4-small, h100-large, 8xh200

LeRobot tự động:

1. Push dataset lên Hub (nếu chưa có)
2. Submit job lên HF compute cluster
3. Stream logs về terminal của bạn
4. Push trained policy lên Hub khi xong

Không cần setup SSH, không cần config Docker — chỉ 1 flag --job.target.

World Models Trong LeRobot v0.6

Ngoài reward models và eval, v0.6 còn ship 3 world model policies mới:

VLA-JEPA

lerobot-train \
  --policy.path=lerobot/VLA-JEPA-Pretrain \
  --dataset.repo_id=${HF_USER}/my_dataset \
  --policy.repo_id=${HF_USER}/vlajepa_finetuned

Ý tưởng: JEPA world model dự đoán upcoming frames từ actions của model. Trick quan trọng — world model biến mất ở inference time, không tốn thêm compute.

FastWAM

Ghép một video-generation expert ~5B params với compact action expert. Ở inference, bỏ qua phần "dreaming" và denoises action chunks trực tiếp. Checkpoint: lerobot/fastwam_base.

Pipeline RL Hoàn Chỉnh Với LeRobot v0.6

Nối tất cả lại, đây là vòng lặp RL tự động:

1. Collect demos (lerobot-record)
        ↓
2. Score dataset với Robometer → lọc low-quality episodes
        ↓
3. Train policy (lerobot-train, FSDP nếu cần)
        ↓
4. Eval trên simulation (lerobot-eval, LIBERO-plus / RoboTwin)
        ↓
5. Deploy trên robot thật (lerobot-rollout, strategy=episodic)
        ↓
6. DAgger: collect corrections khi policy fail
        ↓
7. Fine-tune trên correction data → quay lại bước 3

LeRobot v0.6 còn ship LeLab — giao diện web để visualize dataset, track training metrics, và quản lý pipeline mà không cần CLI cho từng bước.

Tổng Kết

LeRobot v0.6 là bước ngoặt từ "toolkit thu thập dữ liệu" sang "platform RL hoàn chỉnh cho manipulation robot". Ba đóng góp cốt lõi:

• Robometer: Reward model đa năng train trên 1M trajectories, plug-and-play với bất kỳ LeRobot dataset nào
• TOPReward: Zero-shot reward từ log-prob VLM, không cần training, chạy trên task chưa thấy
• lerobot-eval + DAgger: Chuẩn hóa benchmark simulation + đóng vòng lặp correction trên robot thật

Kết hợp 3 mảnh này lại, bạn lần đầu tiên có thể tự động biết policy đang tệ ở đâu, thu thập đúng data cần thiết, và cải thiện liên tục — mà không cần can thiệp thủ công sau mỗi training run.

Tài nguyên:

• LeRobot v0.6.0 blog post
• ROBOMETER paper
• TOPReward paper
• Robometer checkpoint

Bài Viết Liên Quan

• LeRobot Ecosystem Guide: Toàn Bộ Stack Từ Data Đến Deploy
• ProcVLM: Dense Reward VLA-RL Tự Động Cho Manipulation
• Multitask DiT Policy Trong LeRobot v0.5