LeRobot documentation
EnvHub: Chia sẻ một Simulator trên Hub
EnvHub: Chia sẻ một Simulator trên Hub
Một môi trường EnvHub là một kho lưu trữ trên Hugging Face Hub có chứa env.py để xây dựng môi trường Gymnasium theo các quy ước của LeRobot (xem The environment). Tệp đó chính là toàn bộ phần tích hợp: không cần pull request vào LeRobot, cũng không cần phát hành gói. Khi tệp đã được đưa lên Hub, bất kỳ ai cũng có thể:
- đánh giá một chính sách trên nó bằng
lerobot-eval, - điều khiển nó như một robot bằng
lerobot-rollout,lerobot-record,lerobot-teleoperatevàlerobot-replay, có thể thay thế bằng robot thực mà nó mô phỏng, - chạy trên máy cục bộ, trong môi trường Python của riêng họ, hoặc được phục vụ bởi
lerobot-env-servertrong một ảnh Docker được xây dựng từ kho lưu trữ, để các phụ thuộc của trình mô phỏng không bao giờ gặp các phụ thuộc của chính sách.
Trang này cho thấy cách sử dụng một môi trường EnvHub, sau đó là mọi thứ cần thiết để viết và phát hành một môi trường. Mô phỏng đi sâu vào các lệnh; Thêm một benchmark dành cho các benchmark mà LeRobot duy trì trong CI của mình.
Sử dụng môi trường EnvHub
Duyệt các môi trường đã được công bố trong bộ sưu tập môi trường EnvHub, hoặc tìm kiếm trên Hub với thẻ envhub.
Các ví dụ sử dụng lerobot/so101-tabletop-mujoco: một cánh tay SO-101, bốn khối lập phương và một hộp trên bàn, được mô phỏng bằng MuJoCo. Trạng thái và hành động của nó là của so101_follower thực với use_degrees=True.
Cung cấp
Từ bản checkout mã nguồn LeRobot (ảnh được xây dựng từ đó), với Docker và quyền truy cập GPU cho các container của nó:
lerobot-env-server --envhub=lerobot/so101-tabletop-mujoco@<commit> --trust_remote_code=true --docker=trueLệnh này tạo một image chứa repository cùng requirements.txt của nó khi sử dụng lần đầu, và khởi động server trên localhost:7448. --trust_remote_code=true là sự đồng ý của bạn để chạy mã nguồn của repository, trong container: hãy đọc env.py, requirements.txt và packages.txt trước, và cố định commit mà bạn đã đọc, để đảm bảo bạn chạy chính xác mã nguồn đó và kết quả vẫn tái lập được. Nếu không có cờ này, server sẽ từ chối khởi động. Phía client cần thêm extra remote (pip install 'lerobot[remote]').
Máy chủ cũng có thể chạy trên một máy khác, chẳng hạn như trạm làm việc GPU hoặc một instance trên cloud, trong khi policy chạy trên máy của bạn: xem Nơi máy chủ chạy.
Đánh giá một chính sách
lerobot-eval \
--policy.path=<your SO-101 checkpoint> \
--env.type=envhub --env.hub_path=lerobot/so101-tabletop-mujoco@<commit> \
--env.server.endpoint=tcp/127.0.0.1:7448 \
--rename_map='{"observation.images.front": "observation.images.camera1", "observation.images.wrist": "observation.images.camera2"}' \
--eval.n_episodes=10 --eval.batch_size=1Observations đến policy dưới dạng observation.images.<camera> và observation.state; --rename_map ánh xạ chúng sang các tên mà checkpoint đã được huấn luyện.
Điều khiển nó như một robot
Môi trường tương tự là một robot: --robot.type=sim, với các tùy chọn môi trường nằm dưới --robot.env.*. Điều khiển nó bằng tay dẫn SO-101 thực, giống như cách bạn điều khiển tay theo thực:
lerobot-teleoperate \
--robot.type=sim --robot.env.type=envhub --robot.env.hub_path=lerobot/so101-tabletop-mujoco@<commit> \
--robot.env.server.endpoint=tcp/127.0.0.1:7448 \
--teleop.type=so101_leader --teleop.port=/dev/ttyACM0 --teleop.id=my_leader \
--fps=30 --display_data=truelerobot-record nhận cùng các tùy chọn để ghi lại một tập dữ liệu, và lerobot-rollout để chạy một chính sách. Tập dữ liệu ghi lại thân robot mà môi trường khai báo, ở đây là so_follower, giống như follower thực. Xem Chạy robot mô phỏng để biết về các episode, tần suất và việc ghi hình.
Chạy cục bộ
Nếu không có --env.server.endpoint (hoặc --robot.env.server.endpoint), môi trường sẽ chạy trong tiến trình của bạn. Hãy cài đặt requirements.txt của nó cạnh LeRobot và thêm --env.trust_remote_code=true (--robot.env.trust_remote_code=true): tiến trình của bạn sẽ chạy env.py của kho lưu trữ. Khi được phục vụ (served), tiến trình của bạn không bao giờ chạy tệp này, nên client không cần sự đồng ý: --trust_remote_code=true của server sẽ bao quát điều đó.
Từ thư mục cục bộ
Một thư mục chứa env.py hoạt động ở mọi nơi mà một kho Hub hoạt động, cho một môi trường bạn đang viết hoặc một bản clone bạn đã đọc: --env.hub_path=./my-env, --robot.env.hub_path=./my-env, --envhub=./my-env. Nó cần cùng sự đồng ý, vì về bản chất nó vẫn là code. Để phục vụ nó mà không cần xây dựng một image, hãy bỏ --docker=true: khi đó server sẽ chạy trong môi trường Python hiện tại của bạn, với requirements.txt của thư mục được cài đặt ở đó.
lerobot-env-server --envhub=./my-env --trust_remote_code=true # in your Python environment
lerobot-env-server --envhub=./my-env --trust_remote_code=true --docker=true # in an image built from the folderTạo một môi trường
Kho lưu trữ
| File | Bắt buộc | Nội dung |
|---|---|---|
env.py | yes | make_env, môi trường, và tùy chọn LEROBOT_SIM |
requirements.txt | không | Các gói Python mà env.py cần, được cài đặt trong ảnh máy chủ |
packages.txt | không | Các gói Ubuntu, mỗi dòng một gói, được cài đặt trong ảnh máy chủ |
README.md | yes | Môi trường mô phỏng điều gì, các quan sát, hành động, nhiệm vụ, phần thưởng và kết thúc tập của nó, các lệnh để chạy nó, giấy phép của nó |
| bất kỳ điều gì khác | không | Cảnh, mô hình robot, kết cấu, cấu hình: env.py tìm thấy chúng ở ngay cạnh nó, trong mọi chế độ |
Tạo nó dưới dạng kho lưu trữ mô hình trên Hub.
Python và các phụ thuộc
LeRobot yêu cầu Python 3.12 hoặc mới hơn, và môi trường của bạn cũng vậy: khi chạy cục bộ, env.py chạy trong tiến trình của LeRobot, còn image của server chạy Python 3.12 của Ubuntu 24.04. Một trình mô phỏng chỉ hỗ trợ phiên bản Python cũ hơn (ví dụ Isaac Sim 5 và Isaac Lab 2, trên Python 3.11) sẽ không chạy được theo cách nào; hãy sử dụng một bản phát hành hỗ trợ Python 3.12 (Isaac Sim 6 và Isaac Lab 3, như RoboLab đang làm).
Ảnh server chỉ chứa những gì server cần: không có torch cũng như phần còn lại của LeRobot. Liệt kê mọi thứ mà env.py import trong requirements.txt, bao gồm cả torch nếu trình mô phỏng của bạn cần, và cố định phiên bản.
make_env
env.py phải định nghĩa make_env(n_envs: int = 1, use_async_envs: bool = False, **kwargs), hàm này trả về {suite_name: {task_id: vector_env}}, trong đó mỗi vector env chứa n_envs môi trường của tác vụ đó:
def make_env(n_envs: int = 1, use_async_envs: bool = False, **kwargs):
factory = partial(MyEnv, **kwargs)
vector_cls = gym.vector.AsyncVectorEnv if use_async_envs else gym.vector.SyncVectorEnv
return {"my_task": {0: vector_cls([factory] * n_envs)}}- Xây dựng mỗi vector env từ các factory theo từng môi trường, như ở trên, và trả về nó ở dạng chưa bọc: LeRobot sẽ nhận các factory và tự chạy các môi trường (xem Batches). Một vector wrapper tùy chỉnh hoặc subclass sẽ bị từ chối thay vì bị loại bỏ một cách im lặng. Một
gym.Envđơn lẻ cũng được chấp nhận, như một suite với task ID 0. - Một số suite hoặc task ID tạo thành một benchmark đa tác vụ:
lerobot-evalbáo cáo tỷ lệ thành công cho từng tác vụ, từng suite và tổng thể. Một robot mô phỏng chạy suite được chỉ định bởi--robot.env.task(mặc định là suite đầu tiên) và tác vụ được chỉ định bởi--robot.task_id. kwargslà các tùy chọn riêng của môi trường. Người dùng truyền chúng bằng--env.make_env_kwargs='{"episode_length": 900}'(--robot.env.make_env_kwargscho robot mô phỏng); máy chủ nhận chúng bằng--sim.kwargs='{make_env_kwargs: {episode_length: 900}}'.env.pyđược nhập một lần cho mỗi tiến trình, do đó nó có thể giữ trạng thái trên toàn tiến trình, chẳng hạn như một ứng dụng mô phỏng chỉ có thể khởi động một lần (SimulationAppcủa Isaac Sim).
Môi trường
Mỗi môi trường là một gym.Env tuân theo các quy ước sau. Một môi trường Gymnasium thông thường thường không tuân theo: quan sát của CartPole là một vector phẳng và hành động của nó là rời rạc, do đó LeRobot từ chối nó. Hãy bọc một môi trường như vậy để trả về từ điển quan sát này và một hành động liên tục Box.
| Điều gì | Hợp đồng |
|---|---|
| Quan sát | Một dict các mảng NumPy: pixels (một ảnh RGB HWC uint8, hoặc một dict chứa các ảnh đó, một ảnh cho mỗi camera), agent_pos (trạng thái của robot) và tùy chọn environment_state. Các mảng khác được truyền qua |
| Hành động | Một Box liên tục một chiều |
task_description | Lệnh ngôn ngữ được cung cấp cho chính sách (sẽ dùng task nếu không có) |
_max_episode_steps | Giới hạn số bước, sau đó LeRobot sẽ cắt ngắn tập (500 nếu không có) |
trả về của step() | terminated khi tập kết thúc (thành công hoặc thất bại), truncated khi bị cắt ngắn |
info["is_success"] | Nhiệm vụ có được hoàn thành hay không, ở mỗi step() |
info["metrics"] | Tùy chọn: các số khác cần báo cáo, {name: float}; lerobot-eval lưu chúng theo từng tập, lấy tại bước mà tập kết thúc |
LeRobot ánh xạ quan sát vào observation.images.<camera> (observation.image cho một hình ảnh đơn không đặt tên), observation.state và observation.environment_state. Chuyển đổi đầu ra của trình mô phỏng của bạn sang các quy ước này bên trong môi trường: hình ảnh camera đúng chiều, trạng thái theo đơn vị và thứ tự của các hành động của bạn khi chúng chia sẻ các khớp.
Nếu trình mô phỏng của bạn cấp phát ngữ cảnh GPU hoặc EGL, hãy tạo chúng ở lần reset() đầu tiên thay vì trong __init__, để môi trường được xây dựng trong tiến trình worker không kế thừa các handle cũ.
LEROBOT_SIM
Một từ điển ở cấp module trong env.py mô tả môi trường. Nó được áp dụng cục bộ và khi được phục vụ, và mọi khóa đều là tùy chọn:
| Khóa | Ý nghĩa | Mặc định |
|---|---|---|
fps | Tốc độ điều khiển: số lần step() trên mỗi giây thời gian mô phỏng | 30 |
control_mode | Quy ước hành động: position, delta hoặc eef_pose | "position" |
semantics | Tên của các quy ước quan sát và hành động | "envhub-v1" |
state_names | Tên của các thành phần observation.state, theo thứ tự | state_0, state_1, … |
action_names | Tên của các thành phần hành động, theo thứ tự | command_0, command_1, … |
robot_type | Cơ thể mô phỏng, được ghi nhận dưới dạng robot_type của các bộ dữ liệu | không có (bản ghi datasets sim_robot) |
Khai báo nó bất cứ khi nào các giá trị mặc định không khớp với môi trường của bạn. Một khóa không xác định sẽ gây ra lỗi, đồng thời chỉ ra khóa hợp lệ gần nhất. Các tùy chọn --sim.* của máy chủ sẽ ghi đè lên nó, ví dụ --sim.fps=15.
Để biến một môi trường thành bản sao của một robot thực mà LeRobot hỗ trợ, hãy sử dụng tên, đơn vị và robot_type của robot đó. Khi đó, người vận hành từ xa sẽ điều khiển nó giống như cách họ điều khiển robot thực, các bộ dữ liệu được ghi lại trong mô phỏng và trên phần cứng sẽ khớp nhau, và một checkpoint được huấn luyện trên hệ thống này sẽ chạy được trên hệ thống kia. Đối với SO-101, đó là shoulder_pan.pos … gripper.pos, tính bằng độ với giá trị kẹp từ 0 đến 100, và robot_type: "so_follower". Khi LeRobot không có lớp cho robot của bạn, hãy chọn một robot_type ngắn theo kiểu snake_case (panda, sawyer).
Một ví dụ hoàn chỉnh
Một điểm để di chuyển đến đích, không có phụ thuộc nào ngoài Gymnasium và NumPy. Nó đáp ứng mọi yêu cầu ở trên; hãy sao chép nó làm điểm khởi đầu:
# env.py
from functools import partial
import gymnasium as gym
import numpy as np
from gymnasium import spaces
JOINTS = ["x.pos", "y.pos"]
# How LeRobot describes this environment, locally and when served. Every key is optional.
LEROBOT_SIM = {
"fps": 10,
"control_mode": "position",
"state_names": JOINTS,
"action_names": JOINTS,
}
class ReachEnv(gym.Env):
"""Move a point to a target on a plane. The action is the point's next position, in [-1, 1]."""
metadata = {"render_modes": ["rgb_array"], "render_fps": 10}
def __init__(self, image_size: int = 96, episode_length: int = 100):
super().__init__()
self.image_size = image_size
self._max_episode_steps = episode_length
self.task = "reach"
self.task_description = "Move the blue point onto the red target."
image = spaces.Box(0, 255, (image_size, image_size, 3), np.uint8)
self.observation_space = spaces.Dict(
{"pixels": spaces.Dict({"top": image}), "agent_pos": spaces.Box(-1, 1, (2,), np.float32)}
)
self.action_space = spaces.Box(-1, 1, (2,), np.float32)
def reset(self, seed=None, options=None):
super().reset(seed=seed)
self.point = self.np_random.uniform(-1, 1, 2).astype(np.float32)
self.target = self.np_random.uniform(-1, 1, 2).astype(np.float32)
return self._obs(), {"is_success": False}
def step(self, action):
self.point = np.clip(np.asarray(action, np.float32), -1, 1)
distance = float(np.linalg.norm(self.point - self.target))
success = distance < 0.1
info = {"is_success": success, "metrics": {"distance": distance}}
# Ends on success (terminated); LeRobot truncates the episode after _max_episode_steps.
return self._obs(), -distance, success, False, info
def _obs(self):
image = np.full((self.image_size, self.image_size, 3), 255, np.uint8)
for xy, color in ((self.target, (220, 40, 40)), (self.point, (40, 40, 220))):
col, row = ((xy + 1) / 2 * (self.image_size - 1)).astype(int)
image[max(row - 3, 0) : row + 4, max(col - 3, 0) : col + 4] = color
return {"pixels": {"top": image}, "agent_pos": self.point.copy()}
def make_env(n_envs: int = 1, use_async_envs: bool = False, **kwargs):
"""The EnvHub entry point. `kwargs` come from --env.make_env_kwargs."""
factory = partial(ReachEnv, **kwargs)
vector_cls = gym.vector.AsyncVectorEnv if use_async_envs else gym.vector.SyncVectorEnv
return {"reach": {0: vector_cls([factory] * n_envs)}}Đối với trình mô phỏng thực tế, hãy xem lerobot/so101-tabletop-mujoco (MuJoCo) và lerobot/so101-tabletop-isaac (Isaac Sim, được cài đặt thông qua requirements.txt và packages.txt). Chúng phục vụ cùng một cảnh SO-101 với cùng các quan sát, hành động và LEROBOT_SIM, do đó cùng các chính sách và lệnh có thể chạy trên cả hai. Nhiều hơn nữa nằm trong bộ sưu tập môi trường EnvHub.
Các lô
lerobot-eval --eval.batch_size=N chạy N môi trường của một tác vụ cùng lúc, và make_env nhận n_envs=N; một robot mô phỏng chạy một. Một batch được bước theo một trong hai cách.
LeRobot thực hiện bước (step) cho một lô (batch) các môi trường đơn, đây là mặc định và là điều mà hầu hết các trình mô phỏng cần (MuJoCo, PyBullet, …). Hãy viết một gym.Env mô phỏng một môi trường, và trả về n_envs nhà máy (factory) của nó từ make_env, như ở trên. LeRobot xây dựng các môi trường từ các nhà máy: với --eval.use_async_envs=true (mặc định), mỗi môi trường chạy trong tiến trình worker riêng của nó và lô bước được thực hiện song song; với false, tất cả chúng chạy trong một tiến trình, lần lượt. LeRobot chỉ sử dụng các nhà máy, nên việc make_env xây dựng chúng thành lớp vector nào không có sự khác biệt.
Trình mô phỏng của bạn thực hiện bước cho toàn bộ batch, khi nó giữ mọi môi trường trong một thế giới và thực hiện bước cho chúng cùng lúc, như các trình mô phỏng GPU chẳng hạn như Isaac Lab. Hãy định nghĩa vector_env_fns trong env.py, trả về một nhà máy cho mỗi tác vụ, mỗi nhà máy xây dựng một môi trường vector gồm n_envs môi trường; LeRobot sau đó sẽ sử dụng nó thay cho make_env:
from functools import partial
def vector_env_fns(task: str, n_envs: int, **make_env_kwargs):
# {suite_name: {task_id: factory}}, each factory building one vector env of n_envs envs
return {"suite_1": {0: partial(MyBatchedEnv, n_envs, "Task1"), 1: partial(MyBatchedEnv, n_envs, "Task2")}}Mỗi vector env phải có num_envs == n_envs và không được tự động reset (metadata["autoreset_mode"] = gym.vector.AutoresetMode.DISABLED). Nó trả về các quan sát dạng batch theo định dạng ở trên, nhận một seed cho mỗi môi trường trong reset(seed=[...]), và báo cáo info["is_success"] cho từng môi trường. --env.make_env_kwargs sẽ được truyền vào. Vì nó đã thực hiện bước cho toàn bộ batch, hãy đánh giá với --eval.use_async_envs=false: một tiến trình worker chỉ sao chép mỗi batch giữa các tiến trình, còn một server sẽ xây dựng trình mô phỏng lần thứ hai, trong worker.
vector_env_fns cũng phù hợp với một benchmark có nhiều tác vụ: make_env xây dựng môi trường của mọi tác vụ khi được gọi, trong khi chỉ các factory của các tác vụ được chạy mới được gọi.
Kiểm tra trước khi xuất bản
Mỗi bước sử dụng thư mục cục bộ chứa env.py thay cho kho Hub.
Xây dựng các môi trường như cách LeRobot thực hiện, và kiểm tra các khóa quan sát, hình dạng và tác vụ:
import numpy as np from lerobot.envs import HubEnvConfig, make_env # LeRobot's make_env, which calls the make_env of your env.py envs = make_env(HubEnvConfig(hub_path="./my-env", trust_remote_code=True), n_envs=2) suite = next(iter(envs)) env = envs[suite][0] obs, info = env.reset(seed=0) print({key: (value.shape, value.dtype) for key, value in obs.items()}) print(env.call("task_description")) obs, reward, terminated, truncated, info = env.step(np.zeros(env.action_space.shape, np.float32)) print(reward, terminated, truncated, info["is_success"]) env.close()Kiểm tra nó như một robot: tên trạng thái và hành động, cùng các góc nhìn từ camera:
from lerobot.envs.configs import HubEnvConfig from lerobot.robots.sim_robot import SimRobot, SimRobotConfig robot = SimRobot(SimRobotConfig(env=HubEnvConfig(hub_path="./my-env", trust_remote_code=True))) print(robot.robot_type, list(robot.action_features)) robot.connect() observation = robot.get_observation() robot.send_action({name: observation[name] for name in robot.action_features}) robot.disconnect()Với một teleoperator có các hành động khớp với bạn,
lerobot-teleoperate --robot.type=sim --robot.env.type=envhub --robot.env.hub_path=./my-env --robot.env.trust_remote_code=true ... --display_data=truesẽ hiển thị các camera trong Rerun khi bạn điều khiển nó.Cung cấp nó từ thư mục, điều này sẽ xây dựng image từ
requirements.txtvàpackages.txtcủa bạn, sau đó chạy các kiểm tra tương tự đối với nó bằng--env.server.endpoint=tcp/127.0.0.1:7448:lerobot-env-server --envhub=./my-env --trust_remote_code=true --docker=true--build=truechỉ xây dựng lại những phần đã thay đổi: các gói apt khipackages.txtthay đổi, các yêu cầu khirequirements.txtthay đổi, và nếu không thì chỉ là các tệp của kho.
Xuất bản
Tải thư mục lên kho mô hình trên Hub, sau đó:
- Lưu ý commit và sử dụng nó trong các lệnh của README: người dùng sẽ chạy chính xác những gì bạn đã kiểm thử.
- Trong README, hãy nêu rõ giấy phép của mọi thứ mà kho lưu trữ bao gồm (mô hình robot, cảnh, kết cấu), và một kết quả tham chiếu nếu bạn có: một checkpoint, phiên bản của nó, lệnh
lerobot-evalvà tỷ lệ thành công mà nó đạt được. - Thêm
tags: [lerobot, envhub]vào metadata của README để môi trường có thể được tìm thấy trên Hub. - Để được liệt kê trong bộ sưu tập môi trường EnvHub, hãy mở một issue trên GitHub của LeRobot kèm liên kết đến kho lưu trữ.
Các bản cập nhật là các commit mới: người dùng cố định vào một commit cũ hơn sẽ tiếp tục chạy mã mà họ đã xem xét.
Tham khảo
Đường dẫn Hub
--env.hub_path (và --envhub cho máy chủ) nhận:
| Mẫu | Tải | Ví dụ |
|---|---|---|
user/repo | env.py từ nhánh chính | lerobot/so101-tabletop-mujoco |
user/repo@revision | env.py tại một commit, branch hoặc tag | lerobot/so101-tabletop-mujoco@4684f500b94d07194f2c860314c4e27cb9349e8c |
user/repo:path | Một tệp khác | my-org/my-envs:envs/task_a.py |
user/repo@rev:path | Một tệp khác tại một bản sửa | my-org/my-envs@v1.0:envs/task_a.py |
./folder | env.py trong thư mục cục bộ | ./my-env |
Phiên bản
Phiên bản của một môi trường chính là các commit trên Hub. Một revision sau @ (một commit, một branch hoặc một tag) sẽ chọn ra một phiên bản, trong tiến trình của bạn và trên máy chủ:
- Trong quy trình của bạn, kho tại bản sửa đổi đó sẽ được tải xuống và lưu vào bộ nhớ đệm. Nếu không chỉ định bản sửa đổi, mỗi lần chạy sẽ theo commit mới nhất của
main. - Trên máy chủ,
--envhub=user/repo@<revision>xây dựng image từ các tệp của revision đó, và mỗi revision sẽ có một image riêng. Nếu không chỉ định revision, image sẽ giữ nguyên commit mới nhất tại thời điểm xây dựng, cho đến khi--build=truexây dựng lại từ commit mới nhất. - Đánh dấu các bản phát hành để người dùng có thể cố định một tên thay vì một hash, và giữ
maincho mục đích phát triển. Cố định một commit cho các bài báo và so sánh: khác với tag hoặc branch, nó không thể thay đổi.
Tùy chọn
| Tùy chọn | Ý nghĩa |
|---|---|
--env.type=envhub | Một môi trường EnvHub (--robot.env.type=envhub cho robot mô phỏng) |
--env.hub_path | Kho lưu trữ, xem đường dẫn Hub |
--env.trust_remote_code | Cho phép chạy mã của kho lưu trữ trong tiến trình của bạn; không cần thiết khi được phục vụ |
lerobot-env-server --trust_remote_code=true | Cho phép chạy mã của kho trên máy chủ, cần thiết để phục vụ nó, từ --envhub hoặc một tệp YAML |
--env.make_env_kwargs | Các đối số từ khóa cho make_env; khi được phục vụ, hãy đặt chúng trên máy chủ |
--env.server.endpoint | Chạy môi trường trên một máy chủ env; xem Mô phỏng để biết các tùy chọn máy chủ khác |
lerobot-env-server --envhub=<path> | Phục vụ một kho lưu trữ; với --docker=true, trong một image được xây dựng từ nó |
lerobot-env-server --sim.kwargs=... | Các tùy chọn make_env của máy chủ, ví dụ '{make_env_kwargs: {episode_length: 900}}' |
lerobot-env-server --sim.<key>=... | Ghi đè một giá trị LEROBOT_SIM, ví dụ --sim.fps=15 |
Bảo mật
Chạy một môi trường EnvHub sẽ thực thi mã của nó, với quyền của bạn. LeRobot không bao giờ chạy nó mà không có sự đồng ý rõ ràng của bạn: trust_remote_code trong tiến trình của bạn, --trust_remote_code=true trên máy chủ. Trước khi cấp quyền:
- Đọc
env.py,requirements.txtvàpackages.txt. - Ghim commit mà bạn đã đọc.
- Ưu tiên việc phục vụ: trong container, mã chỉ nhìn thấy ảnh của nó và cấu hình của máy chủ, chứ không phải các tệp của bạn. Container chia sẻ mạng của máy chủ (host) với bạn.
Xử lý sự cố
| Lỗi | Sửa |
|---|---|
Refusing to run the EnvHub environment | Thêm --env.trust_remote_code=true (--robot.env.trust_remote_code=true) sau khi đọc mã, hoặc phục vụ môi trường |
failed to import because the dependency '<name>' is not installed | Cài đặt requirements.txt của kho bên cạnh LeRobot, hoặc phục vụ môi trường |
requires an unwrapped SyncVectorEnv or AsyncVectorEnv | Trả về vector env được xây dựng từ các factory, không có wrappers |
LEROBOT_SIM has unknown keys | Sử dụng các phím được liệt kê trong LEROBOT_SIM; thông báo lỗi sẽ nêu tên phím gần nhất |
The env server at ... runs another environment than this command describes | Máy chủ đang chạy một môi trường khác với mô tả của --env.*; hãy truyền các tùy chọn tương tự hoặc khởi động lại máy chủ với tùy chọn của bạn |
A sim robot needs an observation.state feature with component names | Trả về agent_pos trong quan sát |
images must be HWC uint8 with three channels | Chuyển đổi hình ảnh từ camera thành chiều cao x chiều rộng x 3, uint8 |