Từ Hugging Face Hub đến phần cứng robot với Strands Agents và LeRobot

Hướng dẫn chi tiết về việc tích hợp LeRobot trong Strands Robots - một vòng lặp tác nhân (agent loop), từ tập dữ liệu trên Hub đến robot vật lý, với các tập dữ liệu mô phỏng-sang-thực tế (sim-to-real) có cùng định dạng lưu trữ và các chính sách (policies) mà bạn có thể thay đổi chỉ bằng một chuỗi ký tự.

Nếu bạn có một robot, một thư mục dữ liệu trình diễn trên Hugging Face Hub và một nhiệm vụ mới muốn robot học, hiện nay bạn sẽ cần đến năm công cụ riêng biệt: một để ghi lại các bản trình diễn mới, một để huấn luyện, một để thử nghiệm trong mô phỏng, mã tùy chỉnh để triển khai trên phần cứng và một công cụ khác để điều phối khi bạn có nhiều hơn một robot. Các mảnh ghép này hoạt động độc lập và không giao tiếp với nhau.

Strands Robots là một SDK mã nguồn mở từ AWS (Apache 2.0) cung cấp các trừu tượng hóa robot, mô phỏng và ngăn xếp LeRobot dưới dạng các AgentTools mà bạn có thể kết hợp thành một tác nhân Strands duy nhất. Sự tích hợp này được thiết kế tinh gọn: các tập lệnh của chính LeRobot sẽ xử lý việc ghi hình phần cứng và hiệu chuẩn, còn Strands AgentTools sẽ đảm nhận những phần mà một tác nhân thực sự điều phối. Công cụ mô phỏng ghi lại LeRobotDatasets theo cùng định dạng mà LeRobot ghi trên phần cứng. GR00T và LerobotLocal cung cấp suy luận chính sách thông qua một giao diện chung, và các checkpoint MolmoAct2 chạy thông qua đường dẫn LerobotLocal. Một mạng lưới ngang hàng (peer mesh) giúp mở rộng tác nhân đến các robot từ xa. Định dạng tập dữ liệu được giữ nguyên chính xác như cách LeRobot ghi; vòng lặp tác nhân chính là chất keo kết nối mọi thứ.

Bài viết này sẽ dẫn dắt bạn qua năm bước trong một tác nhân duy nhất: xây dựng tác nhân dựa trên LeRobot AgentTools, ghi lại một bản trình diễn dưới dạng LeRobotDataset trong mô phỏng, chạy một chính sách trên cùng robot đó, triển khai cùng mã tác nhân lên robot vật lý SO-101 chỉ với một thay đổi nhỏ về đối số, và phát sóng các lệnh trên một đội robot thông qua mạng lưới Zenoh. Cuối cùng, bạn có thể nhân bản ứng dụng mẫu từ GitHub và chạy trên máy tính xách tay ở chế độ mô phỏng mà không cần phần cứng, GPU hay thông tin đăng nhập Hugging Face cho đường dẫn mặc định. Bạn có thể tìm thấy mã nguồn đi kèm tại examples/lerobot/hub_to_hardware.py và hub_to_hardware.ipynb.

Bạn sẽ xây dựng điều gì

SDK Strands Robots cung cấp ngăn xếp LeRobot dưới dạng các AgentTools để bạn kết hợp thành một tác nhân Strands. Tác nhân ví dụ trong bài viết này thực hiện bốn việc: ghi lại các bản trình diễn mới trong mô phỏng, đẩy kết quả lên Hub dưới dạng LeRobotDataset, chạy một chính sách trong mô phỏng với cùng định dạng đó, và triển khai cùng mã tác nhân lên robot vật lý chỉ bằng cách thay đổi một đối số từ khóa. Khi có nhiều robot, tác nhân có thể điều phối toàn bộ đội thông qua mạng lưới ngang hàng tích hợp sẵn. Đối với việc ghi hình và hiệu chuẩn phần cứng, các CLI của LeRobot (lerobot-record, lerobot-calibrate) sẽ xử lý việc thiết lập ban đầu; tác nhân sẽ tiếp quản từ đó.

Hình 1. Robot(“so100”) mặc định là mô phỏng dựa trên MuJoCo; mode=“real” sẽ trả về một robot phần cứng được điều khiển bởi LeRobot. Cả hai chế độ đều chia sẻ cùng một DatasetRecorder và các nhà cung cấp chính sách, vì vậy tập dữ liệu thu thập trong mô phỏng và trên phần cứng đều sử dụng cùng một định dạng LeRobotDataset trên đĩa.

Hai lựa chọn thiết kế giúp điều này vận hành: Thứ nhất, Robot("so100") mặc định trả về một bản mô phỏng (không cần phần cứng, không rủi ro), và mode="real" trả về một robot phần cứng được điều khiển bởi LeRobot. Mã tác nhân là giống hệt nhau trong cả hai chế độ. Thứ hai, DatasetRecorder ghi LeRobotDataset được dùng chung giữa đường dẫn mô phỏng và việc ghi hình phần cứng của LeRobot, nên một tập dữ liệu thu thập trong MuJoCo và một tập dữ liệu từ robot vật lý SO-101 sẽ có cùng định dạng.

Toàn bộ quy trình trong năm dòng Python:

from strands_robots import Robot
from strands import Agent

arm = Robot("so100") # mode="sim" (mặc định - an toàn, không cần phần cứng)
agent = Agent(tools=[arm])
agent("Pick up the red cube")

Dưới đây là chi tiết những gì thực sự xảy ra bên trong lệnh gọi đó, từng bước một.

Điều kiện tiên quyết

Đường dẫn mô phỏng mặc định (Tối thiểu)

• Python 3.12+, trên Linux hoặc macOS (hỗ trợ Apple Silicon cho backend MuJoCo).
• Một nhà cung cấp mô hình tương thích với Strands để tác nhân suy luận. Amazon Bedrock với thông tin xác thực AWS, Anthropic API, OpenAI, hoặc Ollama chạy cục bộ.
• Cài đặt Strands Robots với các tùy chọn bổ sung: uv pip install "strands-robots[sim-mujoco,lerobot,mesh]"

Triển khai phần cứng, chính sách thực và đẩy lên Hub (Nâng cao)

• Tài khoản Hugging Face và token có quyền ghi để đẩy tập dữ liệu và kéo các checkpoint chính sách từ Hub.
• Đối với đường dẫn phần cứng: một cặp robot SO-101 (follower và leader), hoặc bất kỳ robot nào được LeRobot hỗ trợ. Cả hai thiết bị cần có tệp hiệu chuẩn trong ~/.cache/huggingface/lerobot/calibration/.
• Đối với suy luận GR00T cục bộ: GPU NVIDIA với ít nhất 16 GB VRAM và đã cài đặt Docker.

Bước 1 - Thiết lập ví dụ

Cài đặt Strands Robots và lấy các tệp ví dụ:

uv pip install "strands-robots[sim-mujoco,lerobot,mesh]"
git clone https://github.com/strands-labs/robots.git
cd robots

Xuất token Hugging Face nếu bạn muốn tác nhân đẩy tập dữ liệu hoặc kéo chính sách từ Hub. Điều này là tùy chọn cho đường dẫn mô phỏng mặc định; ví dụ này chạy hoàn toàn với chính sách Mock và ghi tập dữ liệu vào bộ nhớ đệm cục bộ mà không cần truy cập Hub.

export HF_TOKEN=hf_...

Ví dụ có thể chạy được nằm tại examples/lerobot/hub_to_hardware.py (tệp Python) và hub_to_hardware.ipynb (notebook). Notebook là điểm khởi đầu khuyến nghị: hãy mở nó trong JupyterLab và chạy các ô từ trên xuống dưới ở chế độ mô phỏng.

Bước 2 - Ghi lại các bản trình diễn và đẩy lên Hub

Công cụ mô phỏng ghi lại các LeRobotDatasets theo cùng định dạng mà LeRobot ghi trên phần cứng. Không yêu cầu phần cứng. Hành động start_recording của công cụ Simulation ghi thông qua cùng một lớp DatasetRecorder: cùng sơ đồ parquet cho trạng thái khớp và hành động, cùng bố cục MP4 cho mỗi camera. Câu lệnh cho tác nhân gần như tương tự:

from strands import Agent
from strands_robots import Robot

robot = Robot("so100")  # mode="sim" mặc định
agent = Agent(tools=[robot])

agent(
    "Record a demonstration of 'pick the red cube and place it in the box' "
    "using the Mock policy provider at FPS 30. Write the dataset to "
    "my_user/cube_picking_sim and push to the Hub when done."
)

Hình 2. Cảnh ghi hình trong mô phỏng MuJoCo: cánh tay SO-100 vươn tới khối lập phương màu đỏ trên mặt phẳng, được ghi lại thành một LeRobotDataset. Không cần phần cứng, không cần GPU, không cần thông tin Hugging Face cho đường dẫn mặc định này.

Chính sách Mock (giả lập) được sử dụng có chủ đích: nó tạo ra các hành động khớp giả định để quy trình chạy từ đầu đến cuối mà không cần checkpoint đã huấn luyện. Robot sẽ di chuyển ngẫu nhiên thay vì thực hiện việc gắp, nhưng bản ghi vẫn đầy đủ về cấu trúc (trạng thái khớp hợp lệ, khung hình camera hợp lệ, một tập phim LeRobotDataset đúng định dạng), mặc dù bản thân bản trình diễn không hữu ích để huấn luyện. Bước 3 bên dưới sẽ thay thế bằng GR00T hoặc LerobotLocal để có hành vi gắp thực tế. Để thấy việc gắp khối lập phương thực sự ở bước này, hãy chạy --policy lerobot_local --checkpoint allenai/MolmoAct2-SO100_101.

Minh chứng là những gì xảy ra tiếp theo. Trình tải dữ liệu của chính LeRobot đọc dữ liệu ghi từ mô phỏng mà không cần mã đặc thù của Strands:

from lerobot.datasets.lerobot_dataset import LeRobotDataset

dataset = LeRobotDataset("my_user/cube_picking_sim")
print(dataset.features)
# {'observation.state': Sequence(...),
#  'observation.images.front': VideoFrame(...),
#  'action': Sequence(...),
#  'episode_index': Value(...), 'frame_index': Value(...), ...}

Từ điển features này giống hệt về hình dạng với bất kỳ tập dữ liệu LeRobot nào trên Hub: cùng tên cột, cùng bố cục parquet+MP4, cùng đường dẫn trình tải. Các tập lệnh huấn luyện tiêu thụ dữ liệu ghi từ phần cứng cũng sẽ tiêu thụ dữ liệu ghi từ mô phỏng mà không cần sửa đổi.

Một tập phim từ LeRobotDataset đã ghi, được phát lại từ tệp MP4 của mỗi camera mà trình ghi đã tạo ra, chính là video trên đĩa mà tập lệnh huấn luyện sẽ đọc.

Ghi hình trên phần cứng

Để ghi lại các bản trình diễn trên SO-101 vật lý thay vì mô phỏng, hãy sử dụng trực tiếp CLI ghi của LeRobot. Tích hợp của Strands không bao bọc lệnh đó dưới dạng AgentTool vì LeRobot đã thực hiện việc này một cách hiệu quả:

lerobot-calibrate --robot.type=so101_follower --robot.id=my_follower
lerobot-calibrate --robot.type=so101_leader   --robot.id=my_leader

lerobot-record \
  --robot.type=so101_follower --robot.id=my_follower \
  --teleop.type=so101_leader  --teleop.id=my_leader \
  --dataset.repo_id=my_user/cube_picking \
  --dataset.single_task='Pick up the red cube and place it in the box' \
  --dataset.num_episodes=25 \
  --dataset.push_to_hub=true

Tập dữ liệu đẩy lên Hub từ lệnh này có cùng định dạng với bản ghi mô phỏng. Để tinh chỉnh chính sách trên đó, hãy chạy CLI huấn luyện của LeRobot (lerobot-train). Từ Bước 3 trở đi, tác nhân có thể sử dụng checkpoint gốc hoặc checkpoint đã tinh chỉnh một cách linh hoạt.

Bước 3 - Chạy một chính sách trong mô phỏng

Khi đã có tập dữ liệu trên Hub, bước tiếp theo là chạy một chính sách. Ví dụ này sử dụng factory Robot() ở chế độ mô phỏng mặc định, sau đó gắn gr00t_inference để tác nhân có thể quản lý container suy luận:

from strands import Agent
from strands_robots import Robot, gr00t_inference

robot = Robot("so100")  # mode="sim" mặc định
agent = Agent(tools=[robot, gr00t_inference])

agent(
    "Start GR00T inference on port 5555 with the cube-picking checkpoint "
    "from my_user/cube-picker. Then ask the robot to pick up the red cube."
)

Ở bên dưới, tác nhân chạy gr00t_inference(action="lifecycle", lifecycle="full", ...) để kéo hình ảnh container GR00T, tải checkpoint từ Hub và khởi động dịch vụ suy luận. Sau đó, nó chạy hành động run_policy trên robot mô phỏng với policy_provider="groot", truyền host và port của dịch vụ GR00T trong từ điển policy_config. Mô phỏng sẽ tiến triển theo các phân đoạn hành động (action chunks) của chính sách, và kết quả có thể xem qua Simulation.render.

Hình 3. Với một chính sách đã huấn luyện (checkpoint GR00T hoặc MolmoAct2), tác nhân điều khiển SO-100 gắp khối lập phương màu đỏ trong mô phỏng, thay thế cho hành vi của chính sách Mock.

Đối với các nhà phát triển thích suy luận trong tiến trình (không container, không ZeroMQ (ZMQ)), hãy thay thế gr00t_inference bằng một instance LerobotLocalPolicy được tải từ kho lưu trữ Hub. Nhà cung cấp sẽ định tuyến bất kỳ ID mô hình nào thuộc tổ chức lerobot/ đến đường dẫn trong tiến trình:

from strands_robots.policies import create_policy
policy = create_policy("lerobot/act_aloha_sim_transfer_cube_human")

LerobotLocalPolicy hỗ trợ ACT, Diffusion Policy, SmolVLA, $\pi_0$, và $\pi_{0.5}$, bất cứ thứ gì mà registry chính sách của LeRobot có thể giải quyết từ tệp config.json. Tính năng Real-Time Chunking sẽ tự động bật cho các chính sách flow-matching có gửi kèm rtc_config ($\pi_0$, SmolVLA).

Cosmos 3 mới ra mắt của NVIDIA cũng có sẵn dưới dạng nhà cung cấp chính sách thông qua cùng một giao diện, vì vậy mã tác nhân vẫn giữ nguyên bất kể bạn trỏ đến nhà cung cấp nào.

Lưu ý: LerobotLocalPolicy tải các mô hình Hugging Face với trust_remote_code=True. Hãy đặt STRANDS_TRUST_REMOTE_CODE=1 để chấp nhận và chỉ tải các checkpoint từ những tổ chức bạn tin tưởng.

Bước 4 - Triển khai chính sách lên phần cứng vật lý

Đây chính là mã từ Bước 3, chỉ thay đổi một đối số từ khóa. Factory Robot giờ đây trả về một robot hỗ trợ phần cứng được điều khiển bởi make_robot_from_config của LeRobot:

robot = Robot(
    "so100",
    mode="real",
    port="/dev/ttyACM0",
    data_config="so100_dualcam",
    cameras={
        "front": {"type": "opencv", "index_or_path": "/dev/video0", "fps": 30},
        "wrist": {"type": "opencv", "index_or_path": "/dev/video2", "fps": 30},
    },
)
agent = Agent(tools=[robot, gr00t_inference])

agent(
    "Start GR00T inference on port 5555 with the cube-picking checkpoint "
    "from my_user/cube-picker. Then ask the robot to pick up the red cube."
)

Câu lệnh tác nhân tương tự giờ đây chạy trên một cánh tay vật lý. Đường dẫn phần cứng sử dụng trừu tượng hóa robot của LeRobot cho các lệnh khớp và đọc camera, và container GR00T tại port 5555 tạo ra các phân đoạn hành động.

Trước khi chạy trên SO-101, việc hiệu chuẩn cho cả follower và leader phải được hoàn tất. Chạy lệnh hiệu chuẩn của LeRobot (lerobot-calibrate) một lần cho mỗi thiết bị; các tệp sẽ nằm trong ~/.cache/huggingface/lerobot/calibration/ và bất kỳ đường dẫn mã Strands nào chạm vào phần cứng sẽ đọc từ đó.

Bước 5 - Điều phối nhiều robot với mạng lưới (Mesh)

Cho đến nay chúng ta mới điều khiển từng robot một. Mạng lưới (The mesh) là cách Strands Robots xử lý khi có nhiều robot. Hãy hình dung một cánh tay leader trên bàn điều khiển từ xa một cánh tay follower ở phòng khác, hoặc năm robot SO-101 cùng thực hiện một nhiệm vụ trong kho song song. Tất cả đều là các mẫu hình mạng lưới. Mesh được xây dựng trên Zenoh, một giao thức ngang hàng mã nguồn mở; bạn không cần quản lý địa chỉ IP, viết mã khám phá hay chọn broker; các robot mới sẽ xuất hiện trên mesh ngay khi chúng khởi động, và tác nhân có thể giao tiếp với tất cả chúng cùng một lúc.

Mọi Robot() và Simulation() đều tự động gia nhập mạng lưới Zenoh. Công cụ robot_mesh cung cấp cho tác nhân từ vựng cho các hoạt động đội như khám phá, lệnh có cấu trúc, phát sóng và dừng khẩn cấp:

agent = Agent(tools=[robot_mesh])

agent(
    "List every robot and simulation on the mesh. "
    "Then send 'go to home pose' to each one in parallel."
)

Tác nhân gọi robot_mesh(action="peers") để liệt kê các robot cục bộ và ngang hàng được khám phá, sau đó gọi robot_mesh(action="broadcast", ...) để gửi lệnh có cấu trúc đến mọi robot. Thêm tùy chọn [mesh-iot] để định tuyến lưu lượng này qua AWS IoT Core cho các đội robot xuyên mạng.

Theo mặc định, mọi hành động mesh tác động vật lý đều tạm dừng để chờ con người phê duyệt trước khi chạy: bao gồm phát sóng toàn đội, dừng khẩn cấp, và các lệnh tell, send, stop tới một robot đơn lẻ. Bạn có thể điều chỉnh tập hợp này bằng biến môi trường STRANDS_MESH_HITL_ACTIONS. Khi chạy lần đầu, bạn sẽ thấy yêu cầu robot_mesh-broadcast-approval trong terminal; gõ y (hoặc yes/approve) để cho phép. Việc phê duyệt này diễn ra độc lập với các đối số công cụ của LLM, nên nỗ lực tấn công chèn lời nhắc (prompt-injection) nhằm lén đưa cờ phê duyệt vào thân lệnh sẽ không thể vượt qua rào chắn này.

Việc vận chuyển có thể mở rộng mà không cần chạm vào mã tác nhân. Mesh Zenoh tích hợp sẵn là phương án dự phòng tự động: trong LAN, Zenoh multicast xử lý khám phá ngang hàng không cần broker, và việc thêm [mesh-iot] định tuyến lưu lượng qua AWS IoT Core (MQTT5 với mTLS) cho các đội robot đám mây.

Đối với các đội robot sản xuất, Device Connect (lớp mạng nhận biết thiết bị phát triển cùng Arm) xử lý khám phá, hiện diện, RPC có cấu trúc, định tuyến sự kiện và an toàn. Công cụ robot_mesh sẽ điều phối thông qua Device Connect khi có sẵn và tự động chuyển về Zenoh mesh nếu không.

Thử nghiệm bằng ứng dụng mẫu

Bản mẫu đầy đủ có trên GitHub tại strands-labs/robots trong thư mục examples/lerobot/. Nó đóng gói cả năm bước vào một tập lệnh CLI duy nhất (hub_to_hardware.py) và một notebook (hub_to_hardware.ipynb). Các thiết lập mặc định chạy từ đầu đến cuối trong mô phỏng với chính sách Mock, không cần GPU, Docker hay thông tin Hugging Face.

uv pip install "strands-robots[sim-mujoco,lerobot,mesh]"
git clone https://github.com/strands-labs/robots.git
cd robots

export STRANDS_MESH_LOCAL_DEV=1

python examples/lerobot/hub_to_hardware.py

Tập dữ liệu ghi được sẽ nằm tại ~/.cache/huggingface/lerobot/local/strands-cube-pick/. Để đẩy lên Hugging Face Hub, hãy truyền --hf-user <user-của-bạn> sau khi xuất HF_TOKEN. Để có hành vi gắp thực tế trong Bước 3, hãy truyền --policy groot --checkpoint <hf_repo> (yêu cầu Docker + GPU NVIDIA) hoặc --policy lerobot_local --checkpoint <hf_repo> (yêu cầu GPU và STRANDS_TRUST_REMOTE_CODE=1).

Các lưu ý về bảo mật

Những đoạn mã trên là ví dụ “Hello World”. Đối với các trường hợp sử dụng thực tế trong sản xuất, cần lưu ý:

Tấn công chèn lời nhắc (Prompt Injection)

Cung cấp dữ liệu không đáng tin cậy cho tác nhân có thể dẫn đến chèn lời nhắc, nơi ngữ cảnh độc hại được coi là hướng dẫn của LLM. Vì robot tác động vật lý trong không gian thực, đây là rủi ro lớn. Để giảm thiểu, nhà phát triển chỉ nên cung cấp dữ liệu từ nguồn đáng tin cậy hoặc hạn chế các công cụ khả dụng cho tác nhân để ngăn chặn các hành động gây nguy hiểm.

Hành vi xác thực Robot Mesh

Cài đặt STRANDS_MESH_LOCAL_DEV=1 khởi tạo mạng lưới robot mà không có xác thực hoặc kiểm soát truy cập. Điều này có nghĩa là bất kỳ thiết bị nào trong cùng mạng đều có thể gửi lệnh cho đội robot. Điều này chấp nhận được trong môi trường phát triển tin cậy nhưng không phù hợp cho mạng không tin cậy hoặc sản xuất. Đối với những trường hợp này, yêu cầu sử dụng STRANDS_MESH_AUTH_MODE=mtls.

Phê duyệt của người vận hành cho các hành động toàn đội

Các hành động tác động vật lý của công cụ robot_mesh ảnh hưởng đến các robot ngang hàng. Để ngăn tác nhân tự ý phát lệnh (hoặc do bị chèn lời nhắc), cả năm hành động chính đều được đặt rào chắn yêu cầu con người tham gia (human-in-the-loop) theo mặc định. Khi tác nhân gọi một hành động bị chặn, runtime của Strands sẽ tạm dừng vòng lặp và yêu cầu người vận hành phê duyệt.

Dọn dẹp

Quy trình trên khởi động container GR00T, mở các cổng nối tiếp trên phần cứng và ghi bộ nhớ đệm tập dữ liệu cục bộ. Để đưa môi trường về trạng thái sạch:

• Dừng container suy luận GR00T: agent.tool.gr00t_inference(action="stop", port=5555), hoặc dùng lifecycle="teardown" để xóa bỏ container.
• Giải phóng các cổng nối tiếp: ngắt kết nối follower và leader SO-101.
• Xóa bộ nhớ đệm tập dữ liệu cục bộ (tùy chọn): tập dữ liệu nằm trong ~/.cache/huggingface/lerobot/<repo_id>.

Tổng kết: Mọi thứ kết nối với nhau như thế nào

Lựa chọn thiết kế trung tâm của sự tích hợp này là Strands Robots không triển khai lại những gì LeRobot đã cung cấp. Trừu tượng hóa phần cứng, hiệu chuẩn và định dạng tập dữ liệu vẫn nằm ở thượng nguồn. Strands thêm bề mặt AgentTool để khiến chúng có thể kết hợp được thông qua ngôn ngữ tự nhiên.

Hai hệ quả rút ra: Đối với người dùng, mọi tập dữ liệu trên Hub là một tài sản mà tác nhân có thể mở rộng, tinh chỉnh và triển khai mà không cần bước chuyển đổi. Đối với nhà phát triển, dữ liệu mô phỏng và dữ liệu phần cứng chia sẻ cùng một định dạng tệp, vì vậy các tập lệnh huấn luyện cho mô phỏng cũng dùng được cho phần cứng. Ranh giới giữa mô phỏng và thực tế trở thành một chi tiết triển khai, không còn là một sự chia rẽ về kiến trúc.

Hướng đi tiếp theo

Hình 4. Danh mục Strands Robots bao gồm cánh tay, robot hình người, robot bốn chân và bàn tay, tất cả đều trong cùng một mô phỏng MuJoCo và đằng sau cùng một factory Robot(). SO-100 trong bài viết này chỉ là một trong nhiều hình thái được hỗ trợ.

Tài liệu đầy đủ của Strands Robots cung cấp chi tiết về danh mục robot, mô phỏng, nhà cung cấp chính sách, mạng lưới mesh và Device Connect. Đối với các khối lượng công việc lớn hơn, kho lưu trữ strands-labs/robots-sim cung cấp các backend mô phỏng nặng hơn bao gồm Isaac Sim và Newton.

Tài nguyên

• Strands Robots (SDK, AgentTools, Robot factory): github.com/strands-labs/robots
• Strands Robots docs: strands-labs.github.io/robots
• Strands Robots Sim: github.com/strands-labs/robots-sim
• Ví dụ: examples/lerobot/hub_to_hardware.py và hub_to_hardware.ipynb
• LeRobot: github.com/huggingface/lerobot - tập dữ liệu, chính sách, driver phần cứng
• Strands Agents SDK: github.com/strands-agents/harness-sdk
• SmolVLA: huggingface.co/lerobot/smolvla_base
• Pi0: huggingface.co/lerobot/pi0_base
• NVIDIA Isaac-GR00T N1.7: huggingface.co/nvidia/GR00T-N1.7-3B
• NVIDIA Cosmos3 Nano: huggingface.co/nvidia/Cosmos3-Nano

Link bài viết gốc

• Tags:
• Ai
• June 17, 2026
• Huggingface.co