Isaac Teleop + GR00T N1.7 + LeRobot v0.6: Pipeline Thu Thập, Fine-tune và Deploy

Ngày 6 tháng 7 năm 2026, NVIDIA và Hugging Face đồng thời công bố một điều mà cộng đồng robotics chờ đợi từ lâu: vòng lặp robot học hoàn chỉnh khép kín trong một hệ sinh thái duy nhất. Isaac Teleop để thu thập dữ liệu, LeRobot v0.6 để huấn luyện, GR00T N1.7 để suy luận — tất cả kết nối liền mạch, không cần chuyển đổi format thủ công, không cần viết glue code phức tạp.

Đây là bài hướng dẫn thực hành đầy đủ cho pipeline đó.

Bức tranh toàn cảnh: Tại sao tháng 7/2026 quan trọng?

Trước khi đi vào từng bước, hãy dừng lại hiểu tại sao đây là bước ngoặt thực sự.

Vấn đề cũ: Để huấn luyện một manipulation policy, bạn phải:

1. Thu thập dữ liệu teleop bằng một tool (UMI, ACT teleop, custom ROS2 node)
2. Chuyển đổi sang format HDF5 hoặc RLDS
3. Viết data loader riêng cho framework training
4. Train model
5. Viết inference node riêng
6. Deploy lên robot — thường phải rewrite từ đầu

Mỗi bước là một dự án nhỏ. Một nhóm thường mất 2–4 tuần chỉ để dựng pipeline, chưa kể thực sự train model.

Giải pháp mới: Isaac Teleop xuất thẳng sang LeRobot dataset format. LeRobot v0.6 đọc dataset đó, train GR00T N1.7, và lerobot-rollout deploy policy lên cùng con robot. Format đầu vào và đầu ra đồng nhất. Đây là "closed loop" mà tiêu đề LeRobot v0.6 muốn nói: "Imagine, Evaluate, Improve" — bạn có thể iterate nhanh vì không phải rebuild pipeline mỗi lần.

Thu thập dữ liệu bằng Isaac Teleop xuất thẳng sang LeRobot dataset — nguồn: NVIDIA/HuggingFace blog

GR00T N1.7 tóm tắt nhanh

Nếu bạn chưa đọc bài phân tích kiến trúc chi tiết, hãy xem GR00T N1.7 và EgoScale: Fine-tune từ Zero đến Deploy. Ở đây chỉ tóm tắt những gì cần biết để chạy pipeline:

Kiến trúc Action Cascade (3B parameters):

• System 2 — VLM: Cosmos-Reason2-2B (dựa trên Qwen3-VL) nhận ảnh từ camera và language instruction, sinh ra high-level action tokens. Đây là tầng "tư duy" — phân tích task, lập kế hoạch đa bước.
• System 1 — Diffusion Transformer: 32-layer DiT nhận action tokens từ VLM cộng với robot state hiện tại, denoising thành motor commands cụ thể. Đây là tầng "phản xạ" — chạy nhanh, điều khiển chi tiết.

Pre-training EgoScale: 20.854 giờ video egocentric của người (góc nhìn thứ nhất từ camera đội đầu + camera cổ tay), cover 20+ loại task từ nhà máy, y tế, bán lẻ đến môi trường gia đình. Đây là lý do N1.7 khởi đầu tốt hơn hẳn các VLA từ đầu — nó đã "thấy" tay người thao tác đồ vật hàng chục nghìn giờ.

Kết quả LIBERO: 96.5% trung bình trên 4 task suite (tăng từ 87% ở N1.5).

Model có sẵn trên HuggingFace: nvidia/GR00T-N1.7-3B và nvidia/GR00T-H-N1.7 (phiên bản humanoid full-body).

Bước 0: Yêu cầu phần cứng và phần mềm

Phần cứng tối thiểu để train:

• GPU: RTX 4090 (24GB VRAM) cho single-GPU training với batch size nhỏ
• GPU khuyến nghị: A100 40GB hoặc H100 80GB
• RAM: 64GB+
• Disk: 100GB+ cho dataset và checkpoints
• Robot arm: SO-101 follower + SO-101 leader (setup leader-follower) hoặc SO-100

Phần mềm:

• Ubuntu 22.04 hoặc 24.04 (Linux bắt buộc — CUDA không support Windows cho training)
• Python 3.12
• CUDA 12.x
• uv (package manager — nhanh hơn pip nhiều)
• ffmpeg (xử lý video trong dataset)

Bước 1: Cài đặt môi trường

LeRobot v0.6 dùng uv thay vì pip để quản lý dependencies. Lợi thế: virtual environment isolation, fast install, không conflict.

# Cài uv (nếu chưa có)
curl -LsSf https://astral.sh/uv/install.sh | sh
source ~/.bashrc  # hoặc restart terminal

# Cài ffmpeg
sudo apt update && sudo apt install -y ffmpeg

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

# Tạo virtual environment Python 3.12
uv venv --python 3.12
source .venv/bin/activate

# Cài LeRobot với các extras cần thiết
# groot: GR00T model support
# training: training dependencies
# feetech: SO-101 servo driver
# viz: visualization tools
uv pip install -e ".[groot,training,feetech,viz]"

Lưu ý: Extra feetech chỉ cần nếu bạn dùng SO-101. Nếu dùng robot khác (WidowX, Panda), thay bằng extra tương ứng. Chạy uv pip install -e ".[groot,training,viz]" cho setup không hardware cụ thể.

Verify cài đặt:

python -c "import lerobot; import gr00t; print('OK')"

Bước 2: Setup Isaac Teleop cho thu thập dữ liệu

Isaac Teleop là framework teleoperation của NVIDIA, hỗ trợ nhiều input device:

• SO-101 Leader arm (khuyến nghị): Leader-follower — tay bạn điều khiển leader arm, follower arm thực hiện, data chất lượng cao nhất vì khớp với robot kinematics
• SpaceMouse (3Dconnexion Compact/Wireless): 6-DoF control, dễ setup hơn nhưng data thường không mượt bằng leader-follower
• XR Controller (Meta Quest, Vision Pro): Immersive, tốt cho whole-body humanoid

Setup SO-101 Leader-Follower (khuyến nghị cho manipulation)

# Cài Isaac Teleop (chạy trên cùng virtualenv LeRobot)
uv pip install isaac-teleop

# Xác định serial port của robot
ls /dev/ttyUSB*  # thường là /dev/ttyUSB0 hoặc /dev/ttyUSB1

# Calibration (1 lần duy nhất khi setup lần đầu)
uv run python -m lerobot.scripts.control_robot calibrate \
  --robot.type=so101_follower \
  --robot.port=/dev/ttyUSB0 \
  --robot.id=my_so101

# Test kết nối
uv run python -m lerobot.scripts.control_robot teleoperate \
  --robot.type=so101_follower \
  --robot.port=/dev/ttyUSB0

Bước 3: Thu thập dữ liệu demonstration

Đây là bước quan trọng nhất về chất lượng. Rule of thumb: 50–100 demonstrations cho một task đơn giản (pick-and-place), 100–200 cho task phức tạp (stack, insert, fold).

Tips thu thập data chất lượng:

• Mỗi demonstration nên dài 3–10 giây
• Vary starting positions của object (đừng để vật luôn ở đúng một chỗ)
• Thực hiện chậm, dứt khoát — dữ liệu noisy do vội vàng sẽ làm policy học sai
• Ghi lại cả failure recovery nếu có thể

# Định nghĩa biến
export ROBOT_PORT=/dev/ttyUSB0
export DATASET="your-hf-username/pick-place-demo-50"

# Thu thập 50 demonstrations (thay --dataset.num_episodes nếu cần nhiều hơn)
uv run python examples.isaac_teleop_to_so101.record \
  --robot.type=so101_follower \
  --robot.port=$ROBOT_PORT \
  --dataset.repo_id=$DATASET \
  --dataset.num_episodes=50 \
  --dataset.push_to_hub=true

Flag --dataset.push_to_hub=true tự động upload lên HuggingFace Hub sau khi thu thập xong. Nếu muốn giữ local:

# Giữ local, không push
uv run python examples.isaac_teleop_to_so101.record \
  --robot.type=so101_follower \
  --robot.port=$ROBOT_PORT \
  --dataset.repo_id=$DATASET \
  --dataset.push_to_hub=false \
  --dataset.root=data/

Dataset sẽ có cấu trúc LeRobot chuẩn:

data/
  your-hf-username/pick-place-demo-50/
    meta/
      info.json          # metadata: fps, robot embodiment, camera names
      tasks.jsonl        # language labels cho mỗi episode
    data/
      chunk-000/
        episode_000000.parquet
        episode_000001.parquet
        ...
    videos/
      chunk-000/
        observation.images.top/
          episode_000000.mp4
          ...

Xem trước dataset:

uv run python -m lerobot.scripts.visualize_dataset \
  --repo-id $DATASET \
  --episode-index 0

Vòng lặp thu thập → train → deploy khép kín trong LeRobot v0.6 — nguồn: NVIDIA/HuggingFace blog

Bước 4: Fine-tune GR00T N1.7 với LeRobot v0.6

LeRobot v0.6 tích hợp GR00T N1.7 thông qua policy type groot. Command fine-tuning đơn giản hơn nhiều so với workflow cũ của Isaac-GR00T repo trực tiếp:

export DATASET="your-hf-username/pick-place-demo-50"
export OUTPUT_DIR="outputs/groot-n17-pick-place"

uv run lerobot-train \
  --dataset.repo_id=$DATASET \
  --policy.type=groot \
  --policy.base_model_path=nvidia/GR00T-N1.7-3B \
  --steps=20000 \
  --batch_size=64 \
  --output_dir=$OUTPUT_DIR

Giải thích các tham số quan trọng:

Theo dõi training với Weights & Biases:

# Trước khi train, login W&B
wandb login

# Thêm flag vào lệnh train
uv run lerobot-train \
  --dataset.repo_id=$DATASET \
  --policy.type=groot \
  --policy.base_model_path=nvidia/GR00T-N1.7-3B \
  --steps=20000 \
  --batch_size=64 \
  --output_dir=$OUTPUT_DIR \
  --wandb.enable=true \
  --wandb.project=groot-manipulation

Training time ước tính:

• RTX 4090: ~4–6 giờ cho 20k steps với batch 32
• A100 40GB: ~1.5–2 giờ với batch 64
• H100 80GB: ~45 phút với batch 128

Checkpoint tốt nhất được lưu tại $OUTPUT_DIR/checkpoints/last/ và được chọn tự động dựa trên validation loss.

Nếu dùng Isaac-GR00T repo trực tiếp (alternative)

Nếu bạn cần nhiều control hơn (custom embodiment config, multi-GPU với FSDP, TensorRT export), dùng repo gốc:

git clone https://github.com/NVIDIA/Isaac-GR00T.git
cd Isaac-GR00T

# Setup
curl -LsSf https://astral.sh/uv/install.sh | sh
conda create -n gr00t python=3.10 -y && conda activate gr00t
uv pip install -e .

# Fine-tune
CUDA_VISIBLE_DEVICES=0 uv run python gr00t/experiment/launch_finetune.py \
  --base-model-path nvidia/GR00T-N1.7-3B \
  --dataset-path /path/to/dataset \
  --embodiment-tag SO101_LEROBOT \
  --modality-config-path configs/modality_config/so101_lerobot.json \
  --num-gpus 1 \
  --output-dir outputs/gr00t-so101 \
  --max-steps 20000 \
  --global-batch-size 64

Embodiment tags có sẵn: UNITREE_G1, LIBERO_PANDA, OXE_WIDOWX, SO101_LEROBOT, và nhiều hơn. Nếu robot bạn chưa có sẵn, xem hướng dẫn tại getting_started/finetune_new_embodiment.md trong repo.

Bước 5: Inference và Deploy

Sau khi train xong, deploy policy lên robot thực tế với lerobot-rollout:

export MODEL_ID="outputs/groot-n17-pick-place/checkpoints/last"

uv run lerobot-rollout \
  --policy.path=$MODEL_ID \
  --policy.base_model_path=nvidia/GR00T-N1.7-3B \
  --robot.type=so101_follower \
  --robot.port=/dev/ttyUSB0

Script này:

1. Load policy checkpoint
2. Khởi động camera streams
3. Chạy inference loop: camera frame → GR00T N1.7 → motor commands
4. Gửi commands xuống robot ở 50Hz

Tăng tốc inference với TensorRT (nếu deploy Jetson Orin hoặc GPU edge):

# Export sang TensorRT engine (chỉ cần làm 1 lần)
uv run python -m gr00t.export.tensorrt \
  --model-path $MODEL_ID \
  --output-path outputs/groot-tensorrt.engine \
  --batch-size 1

# Rollout với TensorRT
uv run lerobot-rollout \
  --policy.path=$MODEL_ID \
  --policy.backend=tensorrt \
  --policy.engine_path=outputs/groot-tensorrt.engine \
  --robot.type=so101_follower

TensorRT giảm latency inference từ ~80ms xuống ~20ms, quan trọng cho contact-rich tasks cần phản hồi nhanh.

Policy GR00T N1.7 đã fine-tune chạy autonomous trên robot — nguồn: NVIDIA/HuggingFace blog

Bước 6: Evaluate và Iterate

LeRobot v0.6 có sẵn evaluation tools để đo success rate:

# Chạy 20 episodes evaluation
uv run python -m lerobot.scripts.eval \
  --policy.path=$MODEL_ID \
  --policy.base_model_path=nvidia/GR00T-N1.7-3B \
  --robot.type=so101_follower \
  --eval.n_episodes=20 \
  --eval.max_steps=300

Kết quả in ra: success rate, average episode length, và failure mode breakdown (timeout vs. drop vs. wrong target).

Vòng lặp cải thiện:

1. Nếu success rate < 60%: thu thập thêm data, chú ý diversity (varied object positions)
2. Nếu 60–80%: tăng steps (30k → 50k), hoặc tăng data augmentation
3. Nếu > 80% nhưng fail ở specific case: thu thập targeted demos cho failure case đó
4. Nếu generalize kém (chỉ OK với vật đã thấy): thêm camera view thứ hai (wrist cam)

Benchmark và kết quả thực tế

Các con số NVIDIA công bố với GR00T N1.7:

LeRobot integration được parity-tested với Isaac-GR00T repo gốc — cùng input, cùng output, cùng benchmark score.

Scaling law đầu tiên cho robot manipulation:
Từ 1.000 giờ lên 20.000 giờ video egocentric, task completion rate tăng gấp đôi một cách dự đoán được. Đây là lần đầu tiên robotics có scaling law tương tự như LLM — nhiều data = tốt hơn một cách consistent.

GR00T N1.7 bimanual dexterous manipulation

Với humanoid arm đầy đủ (22 DoF), GR00T N1.7 hỗ trợ finger-level control cho các task tiếp xúc phức tạp:

GR00T N1.7 thực hiện bimanual task với kiểm soát ngón tay chi tiết — nguồn: NVIDIA blog GR00T N1.7

Embodiment được test với: Unitree G1, Bimanual YAM, AGIBot Genie 1. Với nvidia/GR00T-H-N1.7 (H = humanoid whole-body), bạn có thể fine-tune cho full-body control luôn.

Khi nào dùng pipeline này, khi nào không?

Phù hợp:

• Robot arm manipulation: pick-and-place, sorting, assembly đơn giản
• Dataset nhỏ đến vừa (50–500 demos)
• Muốn iterate nhanh, không muốn viết code infrastructure
• Đã có hoặc sắp mua SO-101 (ecosystem support tốt nhất)
• Cần commercial license (GR00T N1.7 fully open commercial)

Cân nhắc kỹ:

• Task cần sample efficiency cực cao (< 10 demos): xem ACT hoặc ACoT-VLA — diffusion-based VLA như GR00T cần nhiều data hơn
• Loco-manipulation full-body humanoid với bipedal: cần GR00T-Sonic hoặc WBC stack thêm
• Latency < 10ms: GR00T DiT inference ngay cả với TensorRT vẫn khoảng 15–20ms
• Inference trên CPU only: không khả thi — cần ít nhất GPU mobile (Jetson Orin NX 16GB)

Tips từ người đã chạy pipeline này

1. Calibrate kỹ trước khi record: Một lần calibration sai = toàn bộ 100 demos nhiễu. Dành 15 phút kiểm tra calibration với teleoperate mode trước.

2. Push dataset lên Hub ngay: --dataset.push_to_hub=true vừa backup, vừa cho phép cộng sự khác access. Dataset trên Hub cũng được LeRobot cache tự động, tránh re-download.

3. Chạy visualize_dataset sau mỗi 10 demos: Bắt lỗi sớm (gripper không đóng đủ, camera angle sai) trước khi thu thập 100 demos mà phải làm lại.

4. Dùng --steps=5000 để sanity check trước: Train 5k steps trước để verify dataset load được, loss giảm, rồi mới train full. Tiết kiệm 4–6 giờ nếu có lỗi dataset.

5. Wrist camera là game changer: Nếu có thể, gắn thêm camera ở cổ tay. Policy học được tốt hơn nhiều vì thấy điểm tiếp xúc chính xác. Isaac Teleop hỗ trợ multi-camera natively.

Để hiểu sâu hơn về cách LeRobot dataset format hoạt động và cách train các model nhỏ hơn như G0-Tiny, xem G0-Tiny và LeRobot: Fine-tune Policy cho Robot Arm.

Kết luận

July 2026 đánh dấu thời điểm pipeline robot manipulation VLA lần đầu tiên thực sự accessible: cài đặt trong 10 phút, thu thập data trong một buổi chiều, fine-tune qua đêm, rollout hôm sau. Không cần PhD về robotics, không cần viết CUDA kernel hay custom data pipeline.

GR00T N1.7 + LeRobot v0.6 không phải là pipeline hoàn hảo cho mọi use case — nhưng nó là điểm khởi đầu tốt nhất hiện tại cho ai muốn build manipulation capability trên robot thực tế.

Bước tiếp theo: thử với robot của bạn, report failure modes, contribute dataset lên Hub. NVIDIA đang train GR00T N2.0 — và community data sẽ là một phần của nó.

Bài viết liên quan

• GR00T N1.7 và EgoScale: Kiến Trúc và Fine-tune Chuyên Sâu
• LeRobot Hands-on: Thực Hành VLA trên Robot Arm từ A đến Z
• G0-Tiny và LeRobot: Fine-tune Manipulation Policy cho Robot Arm Nhỏ