LeRobot SO-101 机械臂实践

WOWROBO SO-ARM101 双臂使用说明书（成品版本专用）

1. 连接与安装 请按以下说明连接设备电源：主控需连接 5V/6A 电源，随从臂连接 12V/8A 电源。 相机组件的安装方法请参考以下视频，在 1 小时 6 分 32 秒（1:06:32） 处开始演示： 链接：https://www.bilibili.com/video/BV13bLyzKES8/

2. 操作指南阅读建议 本产品出厂前已完成舵机 ID、波特率、磁编码器中位设置及遥操作功能测试。建议在完全熟悉产品前不要手动更改舵机参数。 请根据以下文档完成环境配置和端口设置后，从步骤 “Calibrate” 开始操作。 链接：https://huggingface.co/docs/lerobot/so101

3. 重要事项 错误的标定方向可能导致舵机朝错误的限位方向运行，进而产生过载，造成舵机损坏，尤其是从臂的 3 号舵机。因此，在首次进行遥操作时，请仔细观察每个舵机的运动方向是否与预期一致。如发现方向异常，请立即停止并重新运行标定流程。 这款机械臂的建议最大负载重量为 400 克，请勿超出这个重量，超载可能会损坏舵机。 因操作不当导致的舵机损坏（如过载、烧毁）不在保修范围内，敬请知悉。

1. 暂存本地修改：git stash
2. 拉取最新代码：git pull
3. 恢复本地修改：git stash pop
   • 如果有冲突，需要手动解决

1. 在src/lerobot下创建extra文件夹，并添加web_visualization_utils.py和lerobot_teleoperate_web.py两个文件，内容如下：

   • web_visualization_utils.py：

     # Copyright 2024 The HuggingFace Inc. team. All rights reserved.
     #
     # Licensed under the Apache License, Version 2.0 (the "License");
     # you may not use this file except in compliance with the License.
     # You may obtain a copy of the License at
     #
     #     http://www.apache.org/licenses/LICENSE-2.0
     #
     # Unless required by applicable law or agreed to in writing, software
     # distributed under the License is distributed on an "AS IS" BASIS,
     # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     # See the License for the specific language governing permissions and
     # limitations under the License.
     
     """Web-based visualization utilities using Rerun web viewer."""
     
     import numbers
     import os
     from typing import Any
     
     import numpy as np
     import rerun as rr
     
     from lerobot.utils.constants import OBS_PREFIX, OBS_STR
     
     
     def init_rerun_web(
         session_name: str = "lerobot_control_loop",
         port: int = 9090,
         open_browser: bool = True,
         memory_limit: str = "10%",
     ) -> None:
         """
         初始化 Rerun SDK 用于 Web 浏览器可视化控制循环。
     
         Initializes the Rerun SDK for visualizing the control loop in a web browser.
     
         参数 Args:
             session_name: Rerun 会话名称 / Name of the Rerun session
             port: Web 服务器端口 / Web server port (default: 9090)
             open_browser: 是否自动打开浏览器 / Whether to automatically open browser (default: True)
             memory_limit: 内存限制 / Memory limit for Rerun (default: "10%")
     
         使用示例 Example:
             ```python
             from lerobot.extra.web_visualization_utils import init_rerun_web
     
             # 在浏览器中启动可视化 / Start visualization in browser
             init_rerun_web(session_name="my_teleoperation", port=9090)
             ```
     
         访问 Access:
             在浏览器中打开 / Open in browser: http://localhost:9090
         """
         batch_size = os.getenv("RERUN_FLUSH_NUM_BYTES", "8000")
         os.environ["RERUN_FLUSH_NUM_BYTES"] = batch_size
     
         rr.init(session_name)
     
         print("🌐 启动 Rerun Web Viewer / Starting Rerun Web Viewer")
         print(f"📍 访问地址 / Access URL: http://localhost:{port}")
         print(f"💾 内存限制 / Memory limit: {memory_limit}")
     
         rr.serve(
             open_browser=open_browser,
             web_port=port,
             server_memory_limit=memory_limit,
         )
     
     
     def init_rerun_connect(
         addr: str = "127.0.0.1:9876",
         session_name: str = "lerobot_control_loop",
     ) -> None:
         """
         连接到远程 Rerun Viewer (适用于远程服务器)。
     
         Connect to a remote Rerun Viewer (useful for remote servers).
     
         参数 Args:
             addr: 远程 Rerun Viewer 地址 / Remote Rerun Viewer address (default: "127.0.0.1:9876")
             session_name: Rerun 会话名称 / Name of the Rerun session
     
         使用示例 Example:
             ```python
             from lerobot.extra.web_visualization_utils import init_rerun_connect
     
             # 连接到远程 Rerun Viewer / Connect to remote Rerun Viewer
             # 首先在另一个终端运行: rerun --port 9876
             # First run in another terminal: rerun --port 9876
             init_rerun_connect(addr="127.0.0.1:9876")
             ```
         """
         batch_size = os.getenv("RERUN_FLUSH_NUM_BYTES", "8000")
         os.environ["RERUN_FLUSH_NUM_BYTES"] = batch_size
     
         rr.init(session_name)
     
         print("🔗 连接到远程 Rerun Viewer / Connecting to remote Rerun Viewer")
         print(f"📍 地址 / Address: {addr}")
     
         rr.connect_tcp(addr=addr)
     
     
     def _is_scalar(x):
         return isinstance(x, (float | numbers.Real | np.integer | np.floating)) or (
             isinstance(x, np.ndarray) and x.ndim == 0
         )
     
     
     def log_rerun_data(
         observation: dict[str, Any] | None = None,
         action: dict[str, Any] | None = None,
     ) -> None:
         """
         将观测和动作数据记录到 Rerun 用于实时可视化。
     
         Logs observation and action data to Rerun for real-time visualization.
     
         This function iterates through the provided observation and action dictionaries and sends their contents
         to the Rerun viewer. It handles different data types appropriately:
         - Scalar values (floats, ints) are logged as `rr.Scalar`.
         - 3D NumPy arrays that resemble images (e.g., with 1, 3, or 4 channels first) are transposed
           from CHW to HWC format and logged as `rr.Image`.
         - 1D NumPy arrays are logged as a series of individual scalars, with each element indexed.
         - Other multi-dimensional arrays are flattened and logged as individual scalars.
     
         Keys are automatically namespaced with "observation." or "action." if not already present.
     
         参数 Args:
             observation: 包含观测数据的可选字典 / An optional dictionary containing observation data to log.
             action: 包含动作数据的可选字典 / An optional dictionary containing action data to log.
         """
         if observation:
             for k, v in observation.items():
                 if v is None:
                     continue
                 key = k if str(k).startswith(OBS_PREFIX) else f"{OBS_STR}.{k}"
     
                 if _is_scalar(v):
                     rr.log(key, rr.Scalar(float(v)))
                 elif isinstance(v, np.ndarray):
                     arr = v
                     # Convert CHW -> HWC when needed
                     if arr.ndim == 3 and arr.shape[0] in (1, 3, 4) and arr.shape[-1] not in (1, 3, 4):
                         arr = np.transpose(arr, (1, 2, 0))
                     if arr.ndim == 1:
                         for i, vi in enumerate(arr):
                             rr.log(f"{key}_{i}", rr.Scalar(float(vi)))
                     else:
                         rr.log(key, rr.Image(arr), static=True)
     
         if action:
             for k, v in action.items():
                 if v is None:
                     continue
                 key = k if str(k).startswith("action.") else f"action.{k}"
     
                 if _is_scalar(v):
                     rr.log(key, rr.Scalar(float(v)))
                 elif isinstance(v, np.ndarray):
                     if v.ndim == 1:
                         for i, vi in enumerate(v):
                             rr.log(f"{key}_{i}", rr.Scalar(float(vi)))
                     else:
                         # Fall back to flattening higher-dimensional arrays
                         flat = v.flatten()
                         for i, vi in enumerate(flat):
                             rr.log(f"{key}_{i}", rr.Scalar(float(vi)))
     

   • lerobot_teleoperate_web.py：

     #!/usr/bin/env python3
     # Copyright 2024 The HuggingFace Inc. team. All rights reserved.
     #
     # Licensed under the Apache License, Version 2.0 (the "License");
     # you may not use this file except in compliance with the License.
     # You may obtain a copy of the License at
     #
     #     http://www.apache.org/licenses/LICENSE-2.0
     #
     # Unless required by applicable law or agreed to in writing, software
     # distributed under the License is distributed on an "AS IS" BASIS,
     # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     # See the License for the specific language governing permissions and
     # limitations under the License.
     
     """
     通过遥操作控制机器人的脚本 (使用 Web 可视化)。
     
     Simple script to control a robot from teleoperation (with Web visualization).
     """
     
     import logging
     import time
     from dataclasses import asdict, dataclass
     from pprint import pformat
     import rerun as rr
     from lerobot.cameras.opencv.configuration_opencv import OpenCVCameraConfig
     from lerobot.cameras.realsense.configuration_realsense import RealSenseCameraConfig
     from lerobot.configs import parser
     from lerobot.processor import (
         RobotAction,
         RobotObservation,
         RobotProcessorPipeline,
         make_default_processors,
     )
     from lerobot.robots import (
         Robot,
         RobotConfig,
         bi_so100_follower,
         hope_jr,
         koch_follower,
         make_robot_from_config,
         so100_follower,
         so101_follower,
     )
     from lerobot.teleoperators import (
         Teleoperator,
         TeleoperatorConfig,
         bi_so100_leader,
         gamepad,
         homunculus,
         koch_leader,
         make_teleoperator_from_config,
         so100_leader,
         so101_leader,
     )
     from lerobot.utils.robot_utils import busy_wait
     from lerobot.utils.utils import init_logging, move_cursor_up
     from .web_visualization_utils import init_rerun_web, log_rerun_data
     
     
     @dataclass
     class TeleoperateWebConfig:
         teleop: TeleoperatorConfig
         robot: RobotConfig
         # Limit the maximum frames per second.
         # 限制最大帧率
         fps: int = 60
         teleop_time_s: float | None = None
         # Display all cameras on screen
         # 在屏幕上显示所有摄像头
         display_data: bool = False
         # Web viewer port
         # Web 查看器端口
         web_port: int = 9090
         # Auto open browser
         # 自动打开浏览器
         open_browser: bool = True
     
     
     def teleop_loop(
         teleop: Teleoperator,
         robot: Robot,
         fps: int,
         teleop_action_processor: RobotProcessorPipeline[tuple[RobotAction, RobotObservation], RobotAction],
         robot_action_processor: RobotProcessorPipeline[tuple[RobotAction, RobotObservation], RobotAction],
         robot_observation_processor: RobotProcessorPipeline[RobotObservation, RobotObservation],
         display_data: bool = False,
         duration: float | None = None,
     ):
         """
         This function continuously reads actions from a teleoperation device, processes them through optional
         pipelines, sends them to a robot, and optionally displays the robot's state. The loop runs at a
         specified frequency until a set duration is reached or it is manually interrupted.
     
         Args:
             teleop: The teleoperator device instance providing control actions.
             robot: The robot instance being controlled.
             fps: The target frequency for the control loop in frames per second.
             display_data: If True, fetches robot observations and displays them in the console and Rerun.
             duration: The maximum duration of the teleoperation loop in seconds. If None, the loop runs indefinitely.
             teleop_action_processor: An optional pipeline to process raw actions from the teleoperator.
             robot_action_processor: An optional pipeline to process actions before they are sent to the robot.
             robot_observation_processor: An optional pipeline to process raw observations from the robot.
         """
     
         display_len = max(len(key) for key in robot.action_features)
         start = time.perf_counter()
     
         while True:
             loop_start = time.perf_counter()
     
             # Get robot observation
             # 获取机器人观测
             obs = robot.get_observation()
     
             # Get teleop action
             # 获取遥操作动作
             raw_action = teleop.get_action()
     
             # Process teleop action through pipeline
             # 通过处理流水线处理遥操作动作
             teleop_action = teleop_action_processor((raw_action, obs))
     
             # Process action for robot through pipeline
             # 通过处理流水线生成发送给机器人的动作
             robot_action_to_send = robot_action_processor((teleop_action, obs))
     
             # Send processed action to robot
             # 发送处理后的动作给机器人
             _ = robot.send_action(robot_action_to_send)
     
             if display_data:
                 # Process robot observation through pipeline
                 # 通过处理流水线处理机器人观测
                 obs_transition = robot_observation_processor(obs)
     
                 log_rerun_data(
                     observation=obs_transition,
                     action=teleop_action,
                 )
     
                 print("\n" + "-" * (display_len + 10))  # 分隔线
                 print(f"{'NAME':<{display_len}} | {'NORM':>7}")  # 标题：名称与归一化值
                 # Display the final robot action that was sent
                 # 显示已发送给机器人的最终动作
                 for motor, value in robot_action_to_send.items():
                     print(f"{motor:<{display_len}} | {value:>7.2f}")  # 每个电机的动作值（保留 2 位小数）
                 move_cursor_up(len(robot_action_to_send) + 5)  # 上移光标以覆盖刷新
     
             dt_s = time.perf_counter() - loop_start
             busy_wait(1 / fps - dt_s)  # 忙等待以维持目标帧率（若剩余时间为正）
             loop_s = time.perf_counter() - loop_start
             print(f"\ntime: {loop_s * 1e3:.2f}ms ({1 / loop_s:.0f} Hz)")  # 打印单次循环耗时与频率
     
             if duration is not None and time.perf_counter() - start >= duration:
                 return
     
     
     @parser.wrap()
     def teleoperate_web(cfg: TeleoperateWebConfig):
         init_logging()  # 初始化日志
         logging.info(pformat(asdict(cfg)))  # 记录当前配置
     
         if cfg.display_data:
             # 使用 Web 可视化
             init_rerun_web(
                 session_name="teleoperation_web",
                 port=cfg.web_port,
                 open_browser=cfg.open_browser,
             )
     
         teleop = make_teleoperator_from_config(cfg.teleop)
         robot = make_robot_from_config(cfg.robot)
         teleop_action_processor, robot_action_processor, robot_observation_processor = make_default_processors()
     
         teleop.connect()  # 连接遥操作设备
         robot.connect()  # 连接机器人
     
         try:
             teleop_loop(
                 teleop=teleop,
                 robot=robot,
                 fps=cfg.fps,
                 display_data=cfg.display_data,
                 duration=cfg.teleop_time_s,
                 teleop_action_processor=teleop_action_processor,
                 robot_action_processor=robot_action_processor,
                 robot_observation_processor=robot_observation_processor,
             )
         except KeyboardInterrupt:
             pass  # 捕获 Ctrl+C 中断，正常退出
         finally:
             if cfg.display_data:
                 rr.rerun_shutdown()  # 关闭 Rerun 会话
             teleop.disconnect()  # 断开遥操作设备
             robot.disconnect()  # 断开机器人
     
     
     def main():
         teleoperate_web()
     
     
     if __name__ == "__main__":
         main()
     

2. 执行遥操作：

   python -m lerobot.extra.lerobot_teleoperate_web \
     --robot.type=so101_follower \
     --robot.port=/dev/follower_arm \
     --robot.id=my_follower_arm \
     --robot.calibration_dir=./data/calibration \
     --robot.cameras="{ wrist_left: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30}, front_rgb: {type: opencv, index_or_path: 8, width: 640, height: 480, fps: 30}}" \
     --teleop.type=so101_leader \
     --teleop.port=/dev/leader_arm \
     --teleop.id=my_leader_arm \
     --teleop.calibration_dir=./data/calibration \
     --display_data=true \
     --web_port=9090
   

3. 运行后默认情况下会在浏览器打开http://localhost:9090/?url=ws://localhost:9877，可以查看机械臂和摄像头画面

4. 摆动主臂，从臂会跟随运动，按Ctrl+C退出

1. 在src/lerobot下的extra文件夹中添加web_visualization_utils.py和lerobot_record_web.py两个文件，内容如下：

   • web_visualization_utils.py： 在### 使用摄像头进行遥操作中有，按步骤来这里不需要再做。

   • lerobot_record_web.py：

   #!/usr/bin/env python3
   # Copyright 2024 The HuggingFace Inc. team. All rights reserved.
   #
   # Licensed under the Apache License, Version 2.0 (the "License");
   # you may not use this file except in compliance with the License.
   # You may obtain a copy of the License at
   #
   #     http://www.apache.org/licenses/LICENSE-2.0
   #
   # Unless required by applicable law or agreed to in writing, software
   # distributed under the License is distributed on an "AS IS" BASIS,
   # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   # See the License for the specific language governing permissions and
   # limitations under the License.
   
   """
   录制数据集 (使用 Web 可视化)。机器人动作可由遥操作或策略生成。
   
   Records a dataset (with Web visualization). Actions for the robot can be either generated by teleoperation or by a policy.
   
   然后在浏览器中打开 / Then open in browser: http://localhost:9090
   """
   
   import logging
   import time
   from dataclasses import asdict, dataclass, field
   from pathlib import Path
   from pprint import pformat
   from typing import Any
   
   from lerobot.cameras import (
       CameraConfig,
   )
   from lerobot.cameras.opencv.configuration_opencv import OpenCVCameraConfig
   from lerobot.cameras.realsense.configuration_realsense import RealSenseCameraConfig
   from lerobot.configs import parser
   from lerobot.configs.policies import PreTrainedConfig
   from lerobot.datasets.image_writer import safe_stop_image_writer
   from lerobot.datasets.lerobot_dataset import LeRobotDataset
   from lerobot.datasets.pipeline_features import aggregate_pipeline_dataset_features, create_initial_features
   from lerobot.datasets.utils import build_dataset_frame, combine_feature_dicts
   from lerobot.datasets.video_utils import VideoEncodingManager
   from lerobot.policies.factory import make_policy, make_pre_post_processors
   from lerobot.policies.pretrained import PreTrainedPolicy
   from lerobot.processor import (
       PolicyAction,
       PolicyProcessorPipeline,
       RobotAction,
       RobotObservation,
       RobotProcessorPipeline,
       make_default_processors,
   )
   from lerobot.processor.rename_processor import rename_stats
   from lerobot.robots import (
       Robot,
       RobotConfig,
       bi_so100_follower,
       hope_jr,
       koch_follower,
       make_robot_from_config,
       so100_follower,
       so101_follower,
   )
   from lerobot.teleoperators import (
       Teleoperator,
       TeleoperatorConfig,
       bi_so100_leader,
       homunculus,
       koch_leader,
       make_teleoperator_from_config,
       so100_leader,
       so101_leader,
   )
   from lerobot.teleoperators.keyboard.teleop_keyboard import KeyboardTeleop
   from lerobot.utils.constants import ACTION, OBS_STR
   from lerobot.utils.control_utils import (
       init_keyboard_listener,
       is_headless,
       predict_action,
       sanity_check_dataset_name,
       sanity_check_dataset_robot_compatibility,
   )
   from lerobot.utils.robot_utils import busy_wait
   from lerobot.utils.utils import (
       get_safe_torch_device,
       init_logging,
       log_say,
   )
   
   # 导入 Web 可视化工具 / Import web visualization utilities
   from .web_visualization_utils import init_rerun_web, log_rerun_data
   
   
   @dataclass
   class DatasetRecordConfig:
       # Dataset identifier. By convention it should match '{hf_username}/{dataset_name}' (e.g. `lerobot/test`).
       # 数据集标识符，按约定为"用户名/数据集名"
       repo_id: str
       # A short but accurate description of the task performed during the recording (e.g. "Pick the Lego block and drop it in the box on the right.")
       # 对录制任务的简短准确描述
       single_task: str
       # Root directory where the dataset will be stored (e.g. 'dataset/path').
       # 数据集保存的根目录
       root: str | Path | None = None
       # Limit the frames per second.
       # 限制帧率
       fps: int = 30
       # Number of seconds for data recording for each episode.
       # 每个 episode 的录制时长（秒）
       episode_time_s: int | float = 60
       # Number of seconds for resetting the environment after each episode.
       # 每个 episode 后重置环境的时长（秒）
       reset_time_s: int | float = 60
       # Number of episodes to record.
       # 录制的 episode 数量
       num_episodes: int = 50
       # Encode frames in the dataset into video
       # 是否将帧编码为视频
       video: bool = True
       # Upload dataset to Hugging Face hub.
       # 是否上传到 Hugging Face Hub
       push_to_hub: bool = True
       # Upload on private repository on the Hugging Face hub.
       # 是否上传到私有仓库
       private: bool = False
       # Add tags to your dataset on the hub.
       # 为数据集添加标签
       tags: list[str] | None = None
       # Number of subprocesses handling the saving of frames as PNG. Set to 0 to use threads only;
       # 负责保存 PNG 帧的子进程数；设为 0 仅用线程
       # set to ≥1 to use subprocesses, each using threads to write images. The best number of processes
       # 设为 ≥1 时使用子进程，每个子进程内使用线程
       # and threads depends on your system. We recommend 4 threads per camera with 0 processes.
       # 进程与线程数取决于系统，建议每个相机 4 线程、0 子进程
       # If fps is unstable, adjust the thread count. If still unstable, try using 1 or more subprocesses.
       # fps 不稳先调线程数；若仍不稳尝试增加子进程
       num_image_writer_processes: int = 0
       # Number of threads writing the frames as png images on disk, per camera.
       # 每个相机写 PNG 的线程数
       # Too many threads might cause unstable teleoperation fps due to main thread being blocked.
       # 线程过多可能阻塞主线程导致遥操作 fps 不稳
       # Not enough threads might cause low camera fps.
       # 线程过少可能导致相机 fps 低
       num_image_writer_threads_per_camera: int = 4
       # Number of episodes to record before batch encoding videos
       # 批量编码视频前要累计的 episode 数
       # Set to 1 for immediate encoding (default behavior), or higher for batched encoding
       # 1 表示立即编码（默认），更大表示批量
       video_encoding_batch_size: int = 1
       # Rename map for the observation to override the image and state keys
       # 覆盖图像与状态键名的重命名映射
       rename_map: dict[str, str] = field(default_factory=dict)
   
       def __post_init__(self):
           if self.single_task is None:
               raise ValueError("You need to provide a task as argument in `single_task`.")
   
   
   @dataclass
   class RecordWebConfig:
       robot: RobotConfig
       dataset: DatasetRecordConfig
       # Whether to control the robot with a teleoperator
       # 是否使用遥操作控制机器人
       teleop: TeleoperatorConfig | None = None
       # Whether to control the robot with a policy
       # 是否使用策略控制机器人
       policy: PreTrainedConfig | None = None
       # Display all cameras on screen
       # 是否在屏幕显示所有摄像头
       display_data: bool = False
       # Use vocal synthesis to read events.
       # 是否用语音播报事件
       play_sounds: bool = True
       # Resume recording on an existing dataset.
       # 继续录制已有数据集
       resume: bool = False
       # Web viewer port
       # Web 查看器端口
       web_port: int = 9090
       # Auto open browser
       # 自动打开浏览器
       open_browser: bool = True
   
       def __post_init__(self):
           # HACK: We parse again the cli args here to get the pretrained path if there was one.
           # 再次解析 CLI 以获取预训练路径（若存在）
           policy_path = parser.get_path_arg("policy")
           if policy_path:
               cli_overrides = parser.get_cli_overrides("policy")
               self.policy = PreTrainedConfig.from_pretrained(policy_path, cli_overrides=cli_overrides)
               self.policy.pretrained_path = policy_path
   
           if self.teleop is None and self.policy is None:
               raise ValueError("Choose a policy, a teleoperator or both to control the robot")
   
       @classmethod
       def __get_path_fields__(cls) -> list[str]:
           """This enables the parser to load config from the policy using `--policy.path=local/dir`"""  # 允许解析器通过 --policy.path 加载配置
           return ["policy"]
   
   
   """ --------------- record_loop() data flow --------------------------
         [ Robot ]
             V
       [ robot.get_observation() ] ---> raw_obs
             V
       [ robot_observation_processor ] ---> processed_obs
             V
       .-----( ACTION LOGIC )------------------.
       V                                       V
       [ From Teleoperator ]                   [ From Policy ]
       |                                       |
       |  [teleop.get_action] -> raw_action    |   [predict_action]
       |          |                            |          |
       |          V                            |          V
       | [teleop_action_processor]             |          |
       |          |                            |          |
       '---> processed_teleop_action           '---> processed_policy_action
       |                                       |
       '-------------------------.-------------'
                                 V
                     [ robot_action_processor ] --> robot_action_to_send
                                 V
                       [ robot.send_action() ] -- (Robot Executes)
                                 V
                       ( Save to Dataset )
                                 V
                     ( Rerun Log / Loop Wait )
   """
   
   
   @safe_stop_image_writer
   def record_loop(
       robot: Robot,
       events: dict,
       fps: int,
       teleop_action_processor: RobotProcessorPipeline[
           tuple[RobotAction, RobotObservation], RobotAction
       ],  # runs after teleop  # 在遥操作之后运行
       robot_action_processor: RobotProcessorPipeline[
           tuple[RobotAction, RobotObservation], RobotAction
       ],  # runs before robot  # 在发送到机器人之前运行
       robot_observation_processor: RobotProcessorPipeline[
           RobotObservation, RobotObservation
       ],  # runs after robot  # 在机器人观测之后运行
       dataset: LeRobotDataset | None = None,
       teleop: Teleoperator | list[Teleoperator] | None = None,
       policy: PreTrainedPolicy | None = None,
       preprocessor: PolicyProcessorPipeline[dict[str, Any], dict[str, Any]] | None = None,
       postprocessor: PolicyProcessorPipeline[PolicyAction, PolicyAction] | None = None,
       control_time_s: int | None = None,
       single_task: str | None = None,
       display_data: bool = False,
   ):
       if dataset is not None and dataset.fps != fps:
           raise ValueError(f"The dataset fps should be equal to requested fps ({dataset.fps} != {fps}).")
   
       teleop_arm = teleop_keyboard = None
       if isinstance(teleop, list):
           teleop_keyboard = next((t for t in teleop if isinstance(t, KeyboardTeleop)), None)
           teleop_arm = next(
               (
                   t
                   for t in teleop
                   if isinstance(
                       t,
                       (so100_leader.SO100Leader | so101_leader.SO101Leader | koch_leader.KochLeader),
                   )
               ),
               None,
           )
   
           if not (teleop_arm and teleop_keyboard and len(teleop) == 2 and robot.name == "lekiwi_client"):
               raise ValueError(
                   "For multi-teleop, the list must contain exactly one KeyboardTeleop and one arm teleoperator. Currently only supported for LeKiwi robot."
               )
   
       # Reset policy and processor if they are provided
       if policy is not None and preprocessor is not None and postprocessor is not None:
           policy.reset()
           preprocessor.reset()
           postprocessor.reset()
   
       timestamp = 0
       start_episode_t = time.perf_counter()
       while timestamp < control_time_s:
           start_loop_t = time.perf_counter()
   
           if events["exit_early"]:
               events["exit_early"] = False
               break
   
           # Get robot observation
           # 获取机器人观测
           obs = robot.get_observation()
   
           # Applies a pipeline to the raw robot observation, default is IdentityProcessor
           # 对观测应用处理流水线（默认恒等）
           obs_processed = robot_observation_processor(obs)
   
           if policy is not None or dataset is not None:
               observation_frame = build_dataset_frame(dataset.features, obs_processed, prefix=OBS_STR)
   
           # Get action from either policy or teleop
           # 从策略或遥操作获取动作
           if policy is not None and preprocessor is not None and postprocessor is not None:
               action_values = predict_action(
                   observation=observation_frame,
                   policy=policy,
                   device=get_safe_torch_device(policy.config.device),
                   preprocessor=preprocessor,
                   postprocessor=postprocessor,
                   use_amp=policy.config.use_amp,
                   task=single_task,
                   robot_type=robot.robot_type,
               )
   
               action_names = dataset.features[ACTION]["names"]
               act_processed_policy: RobotAction = {
                   f"{name}": float(action_values[i]) for i, name in enumerate(action_names)
               }
   
           elif policy is None and isinstance(teleop, Teleoperator):
               act = teleop.get_action()
   
               # Applies a pipeline to the raw teleop action, default is IdentityProcessor
               # 对遥操作动作应用处理流水线（默认恒等）
               act_processed_teleop = teleop_action_processor((act, obs))
   
           elif policy is None and isinstance(teleop, list):
               arm_action = teleop_arm.get_action()
               arm_action = {f"arm_{k}": v for k, v in arm_action.items()}
               keyboard_action = teleop_keyboard.get_action()
               base_action = robot._from_keyboard_to_base_action(keyboard_action)
               act = {**arm_action, **base_action} if len(base_action) > 0 else arm_action
               act_processed_teleop = teleop_action_processor((act, obs))
           else:
               logging.info(
                   "No policy or teleoperator provided, skipping action generation."
                   "This is likely to happen when resetting the environment without a teleop device."
                   "The robot won't be at its rest position at the start of the next episode."
               )
               continue
   
           # Applies a pipeline to the action, default is IdentityProcessor
           # 对动作应用处理流水线（默认恒等）
           if policy is not None and act_processed_policy is not None:
               action_values = act_processed_policy
               robot_action_to_send = robot_action_processor((act_processed_policy, obs))
           else:
               action_values = act_processed_teleop
               robot_action_to_send = robot_action_processor((act_processed_teleop, obs))
   
           # Send action to robot
           # 发送动作到机器人
           # Action can eventually be clipped using `max_relative_target`,
           # 动作可能被裁剪（max_relative_target）
           # so action actually sent is saved in the dataset. action = postprocessor.process(action)
           # 实际发送的动作会存入数据集
           # TODO(steven, pepijn, adil): we should use a pipeline step to clip the action, so the sent action is the action that we input to the robot.
           # 建议在流水线中裁剪，保持一致
           _sent_action = robot.send_action(robot_action_to_send)
   
           # Write to dataset
           # 写入数据集
           if dataset is not None:
               action_frame = build_dataset_frame(dataset.features, action_values, prefix=ACTION)
               frame = {**observation_frame, **action_frame, "task": single_task}
               dataset.add_frame(frame)
   
           if display_data:
               log_rerun_data(observation=obs_processed, action=action_values)
   
           dt_s = time.perf_counter() - start_loop_t
           busy_wait(1 / fps - dt_s)
   
           timestamp = time.perf_counter() - start_episode_t
   
   
   @parser.wrap()
   def record_web(cfg: RecordWebConfig) -> LeRobotDataset:
       init_logging()
       logging.info(pformat(asdict(cfg)))
   
       if cfg.display_data:
           # 使用 Web 可视化 / Use web visualization
           init_rerun_web(
               session_name="recording_web",
               port=cfg.web_port,
               open_browser=cfg.open_browser,
           )
   
       robot = make_robot_from_config(cfg.robot)
       teleop = make_teleoperator_from_config(cfg.teleop) if cfg.teleop is not None else None
   
       teleop_action_processor, robot_action_processor, robot_observation_processor = make_default_processors()
   
       dataset_features = combine_feature_dicts(
           aggregate_pipeline_dataset_features(
               pipeline=teleop_action_processor,
               initial_features=create_initial_features(
                   action=robot.action_features
               ),  # TODO(steven, pepijn): in future this should be come from teleop or policy
               use_videos=cfg.dataset.video,
           ),
           aggregate_pipeline_dataset_features(
               pipeline=robot_observation_processor,
               initial_features=create_initial_features(observation=robot.observation_features),
               use_videos=cfg.dataset.video,
           ),
       )
   
       if cfg.resume:
           dataset = LeRobotDataset(
               cfg.dataset.repo_id,
               root=cfg.dataset.root,
               batch_encoding_size=cfg.dataset.video_encoding_batch_size,
           )
   
           if hasattr(robot, "cameras") and len(robot.cameras) > 0:
               dataset.start_image_writer(
                   num_processes=cfg.dataset.num_image_writer_processes,
                   num_threads=cfg.dataset.num_image_writer_threads_per_camera * len(robot.cameras),
               )
           sanity_check_dataset_robot_compatibility(dataset, robot, cfg.dataset.fps, dataset_features)
       else:
           # Create empty dataset or load existing saved episodes
           sanity_check_dataset_name(cfg.dataset.repo_id, cfg.policy)
           dataset = LeRobotDataset.create(
               cfg.dataset.repo_id,
               cfg.dataset.fps,
               root=cfg.dataset.root,
               robot_type=robot.name,
               features=dataset_features,
               use_videos=cfg.dataset.video,
               image_writer_processes=cfg.dataset.num_image_writer_processes,
               image_writer_threads=cfg.dataset.num_image_writer_threads_per_camera * len(robot.cameras),
               batch_encoding_size=cfg.dataset.video_encoding_batch_size,
           )
   
       # Load pretrained policy
       policy = None if cfg.policy is None else make_policy(cfg.policy, ds_meta=dataset.meta)
       preprocessor = None
       postprocessor = None
       if cfg.policy is not None:
           preprocessor, postprocessor = make_pre_post_processors(
               policy_cfg=cfg.policy,
               pretrained_path=cfg.policy.pretrained_path,
               dataset_stats=rename_stats(dataset.meta.stats, cfg.dataset.rename_map),
               preprocessor_overrides={
                   "device_processor": {"device": cfg.policy.device},
                   "rename_observations_processor": {"rename_map": cfg.dataset.rename_map},
               },
           )
   
       robot.connect()
       if teleop is not None:
           teleop.connect()
   
       listener, events = init_keyboard_listener()
   
       with VideoEncodingManager(dataset):
           recorded_episodes = 0
           while recorded_episodes < cfg.dataset.num_episodes and not events["stop_recording"]:
               log_say(f"Recording episode {dataset.num_episodes}", cfg.play_sounds)
               record_loop(
                   robot=robot,
                   events=events,
                   fps=cfg.dataset.fps,
                   teleop_action_processor=teleop_action_processor,
                   robot_action_processor=robot_action_processor,
                   robot_observation_processor=robot_observation_processor,
                   teleop=teleop,
                   policy=policy,
                   preprocessor=preprocessor,
                   postprocessor=postprocessor,
                   dataset=dataset,
                   control_time_s=cfg.dataset.episode_time_s,
                   single_task=cfg.dataset.single_task,
                   display_data=cfg.display_data,
               )
   
               # Execute a few seconds without recording to give time to manually reset the environment
               # 暂停录制以便手动重置环境
               # Skip reset for the last episode to be recorded
               # 最后一个 episode 可跳过重置
               if not events["stop_recording"] and (
                   (recorded_episodes < cfg.dataset.num_episodes - 1) or events["rerecord_episode"]
               ):
                   log_say("Reset the environment", cfg.play_sounds)
                   record_loop(
                       robot=robot,
                       events=events,
                       fps=cfg.dataset.fps,
                       teleop_action_processor=teleop_action_processor,
                       robot_action_processor=robot_action_processor,
                       robot_observation_processor=robot_observation_processor,
                       teleop=teleop,
                       control_time_s=cfg.dataset.reset_time_s,
                       single_task=cfg.dataset.single_task,
                       display_data=cfg.display_data,
                   )
   
               if events["rerecord_episode"]:
                   log_say("Re-record episode", cfg.play_sounds)
                   events["rerecord_episode"] = False
                   events["exit_early"] = False
                   dataset.clear_episode_buffer()
                   continue
   
               dataset.save_episode()
               recorded_episodes += 1
   
       log_say("Stop recording", cfg.play_sounds, blocking=True)
   
       robot.disconnect()
       if teleop is not None:
           teleop.disconnect()
   
       if not is_headless() and listener is not None:
           listener.stop()
   
       if cfg.dataset.push_to_hub:
           dataset.push_to_hub(tags=cfg.dataset.tags, private=cfg.dataset.private)
   
       log_say("Exiting", cfg.play_sounds)
       return dataset
   
   
   def main():
       record_web()
   
   
   if __name__ == "__main__":
       main()
   

2. 执行遥操作：

   python -m lerobot.extra.lerobot_record_web \
         --robot.type=so101_follower \
         --robot.port=/dev/follower_arm \
         --robot.id=my_follower_arm \
         --robot.calibration_dir=./data/calibration \
         --robot.cameras="{ wrist_left: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30}, front_rgb: {type: opencv, index_or_path: 8, width: 640, height: 480, fps: 30}}" \
         --teleop.type=so101_leader \
         --teleop.port=/dev/leader_arm \
         --teleop.id=my_leader_arm \
         --teleop.calibration_dir=./data/calibration \
         --display_data=true \
         --dataset.repo_id=xiadengma/record-test-so101 \
         --dataset.num_episodes=3 \
         --dataset.single_task="Put the red pepper toy in the cardboard box" \
         --web_port=9090 \
         --dataset.push_to_hub=false \
         --dataset.root=./data/datasets/xiadengma/record-test-so101
   

3. 运行后默认情况下会在浏览器打开http://localhost:9090/?url=ws://localhost:9877，可以查看机械臂和摄像头画面

1. 在src/lerobot下的extra文件夹中添加lerobot_dataset_viz_web.py文件，内容如下：

   • lerobot_dataset_viz_web.py：

   #!/usr/bin/env python
   
   # Copyright 2024 The HuggingFace Inc. team. All rights reserved.
   #
   # Licensed under the Apache License, Version 2.0 (the "License");
   # you may not use this file except in compliance with the License.
   # You may obtain a copy of the License at
   #
   #     http://www.apache.org/licenses/LICENSE-2.0
   #
   # Unless required by applicable law or agreed to in writing, software
   # distributed under the License is distributed on an "AS IS" BASIS,
   # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   # See the License for the specific language governing permissions and
   # limitations under the License.
   
   """
   使用 Web 浏览器可视化 LeRobotDataset 中任意 episode 的所有帧数据。
   Visualize data of **all** frames of any episode of a dataset of type LeRobotDataset in a web browser.
   
   注意 Note:
       - Episode 的最后一帧不一定对应最终状态 / The last frame doesn't always correspond to a final state
       - 图像可能存在压缩伪影 / Images may show compression artifacts from mp4 encoding
   
   访问 Access:
       浏览器打开 / Open in browser: http://localhost:PORT
   """
   
   import argparse
   import gc
   import logging
   from collections.abc import Iterator
   from pathlib import Path
   
   import numpy as np
   import rerun as rr
   import torch
   import torch.utils.data
   import tqdm
   
   from lerobot.datasets.lerobot_dataset import LeRobotDataset
   from lerobot.utils.constants import ACTION, DONE, OBS_STATE, REWARD
   
   
   class EpisodeSampler(torch.utils.data.Sampler):
       """用于采样单个 episode 的所有帧 / Sampler for all frames of a single episode."""
   
       def __init__(self, dataset: LeRobotDataset, episode_index: int):
           from_idx = dataset.meta.episodes["dataset_from_index"][episode_index]
           to_idx = dataset.meta.episodes["dataset_to_index"][episode_index]
           self.frame_ids = range(from_idx, to_idx)
   
       def __iter__(self) -> Iterator:
           return iter(self.frame_ids)
   
       def __len__(self) -> int:
           return len(self.frame_ids)
   
   
   def to_hwc_uint8_numpy(chw_float32_torch: torch.Tensor) -> np.ndarray:
       """
       将 PyTorch CHW float32 图像转换为 NumPy HWC uint8 格式。
       Convert PyTorch CHW float32 image to NumPy HWC uint8 format.
       """
       assert chw_float32_torch.dtype == torch.float32
       assert chw_float32_torch.ndim == 3
       c, h, w = chw_float32_torch.shape
       assert c < h and c < w, (
           f"期望通道优先格式，但得到 / expect channel first images, but got {chw_float32_torch.shape}"
       )
       hwc_uint8_numpy = (chw_float32_torch * 255).type(torch.uint8).permute(1, 2, 0).numpy()
       return hwc_uint8_numpy
   
   
   def visualize_episode(
       dataset: LeRobotDataset,
       episode_index: int,
       batch_size: int = 32,
       num_workers: int = 0,
   ) -> None:
       """
       在 Rerun 中可视化单个 episode 的所有帧。
       Visualize all frames of a single episode in Rerun.
   
       Args:
           dataset: LeRobot 数据集 / LeRobot dataset
           episode_index: Episode 索引 / Episode index
           batch_size: 批处理大小 / Batch size for dataloader
           num_workers: 数据加载进程数 / Number of worker processes
       """
       logging.info(
           f"📊 加载 Episode {episode_index} 的数据加载器 / Loading dataloader for Episode {episode_index}"
       )
   
       episode_sampler = EpisodeSampler(dataset, episode_index)
       dataloader = torch.utils.data.DataLoader(
           dataset,
           num_workers=num_workers,
           batch_size=batch_size,
           sampler=episode_sampler,
       )
   
       total_frames = len(episode_sampler)
       logging.info(
           f"📈 Episode {episode_index} 共有 {total_frames} 帧 / Episode {episode_index} has {total_frames} frames"
       )
   
       # 记录数据到 Rerun / Log data to Rerun
       for batch in tqdm.tqdm(dataloader, total=len(dataloader), desc=f"Episode {episode_index}"):
           # 遍历批次中的每一帧 / iterate over the batch
           for i in range(len(batch["index"])):
               rr.set_time_sequence("frame_index", batch["frame_index"][i].item())
               rr.set_time_seconds("timestamp", batch["timestamp"][i].item())
   
               # 显示相机图像 / display camera images
               for key in dataset.meta.camera_keys:
                   rr.log(f"cameras/{key}", rr.Image(to_hwc_uint8_numpy(batch[key][i])))
   
               # 显示动作空间的每个维度 / display each dimension of action space
               if ACTION in batch:
                   for dim_idx, val in enumerate(batch[ACTION][i]):
                       rr.log(f"{ACTION}/dim_{dim_idx}", rr.Scalar(val.item()))
   
               # 显示观测状态空间的每个维度 / display each dimension of observed state space
               if OBS_STATE in batch:
                   for dim_idx, val in enumerate(batch[OBS_STATE][i]):
                       rr.log(f"state/dim_{dim_idx}", rr.Scalar(val.item()))
   
               # 显示完成标志 / display done flag
               if DONE in batch:
                   rr.log(DONE, rr.Scalar(batch[DONE][i].item()))
   
               # 显示奖励 / display reward
               if REWARD in batch:
                   rr.log(REWARD, rr.Scalar(batch[REWARD][i].item()))
   
               # 显示成功标志 / display success flag
               if "next.success" in batch:
                   rr.log("success", rr.Scalar(batch["next.success"][i].item()))
   
       logging.info(f"✅ Episode {episode_index} 可视化完成 / Episode {episode_index} visualization complete")
   
   
   def visualize_dataset_web(
       dataset: LeRobotDataset,
       episode_indices: list[int],
       batch_size: int = 32,
       num_workers: int = 0,
       port: int = 9090,
       open_browser: bool = True,
       memory_limit: str = "25%",
   ) -> None:
       """
       使用 Web 界面可视化数据集。
       Visualize dataset using web interface.
   
       Args:
           dataset: LeRobot 数据集 / LeRobot dataset
           episode_indices: 要可视化的 episode 索引列表 / List of episode indices to visualize
           batch_size: 批处理大小 / Batch size for dataloader
           num_workers: 数据加载进程数 / Number of worker processes
           port: Web 服务器端口 / Web server port
           open_browser: 是否自动打开浏览器 / Whether to automatically open browser
           memory_limit: Rerun 内存限制 / Memory limit for Rerun
       """
       repo_id = dataset.repo_id
   
       # 初始化 Rerun Web 界面 / Initialize Rerun web interface
       logging.info("🌐 启动 Rerun Web 界面 / Starting Rerun Web interface")
       logging.info(f"📍 访问地址 / Access URL: http://localhost:{port}")
       logging.info(f"💾 内存限制 / Memory limit: {memory_limit}")
   
       rr.init(f"{repo_id}_web_viz", spawn=False)
   
       # 手动触发垃圾回收，避免阻塞 / Manually call garbage collector to avoid blocking
       gc.collect()
   
       # 启动 Web 服务器 / Start web server
       rr.serve_web(
           open_browser=open_browser,
           web_port=port,
           server_memory_limit=memory_limit,
       )
   
       # 可视化每个 episode / Visualize each episode
       for episode_idx in episode_indices:
           if episode_idx >= len(dataset.meta.episodes):
               logging.warning(
                   f"⚠️  Episode {episode_idx} 不存在，跳过 / Episode {episode_idx} does not exist, skipping"
               )
               continue
   
           # 为每个 episode 创建记录路径 / Create recording path for each episode
           rr.log(f"episode_{episode_idx}/info", rr.TextLog(f"Episode {episode_idx}"), static=True)
   
           # 设置时间序列标记当前 episode / Set time sequence for current episode
           rr.set_time_sequence("episode", episode_idx)
   
           visualize_episode(
               dataset=dataset,
               episode_index=episode_idx,
               batch_size=batch_size,
               num_workers=num_workers,
           )
   
       logging.info("✨ 所有 episode 可视化完成 / All episodes visualization complete")
       logging.info("🌐 Web 服务器持续运行中，按 Ctrl+C 退出 / Web server running, press Ctrl+C to exit")
   
       # 保持服务器运行 / Keep server running
       try:
           import time
   
           while True:
               time.sleep(1)
       except KeyboardInterrupt:
           logging.info("👋 收到 Ctrl-C，正在退出 / Ctrl-C received, exiting")
   
   
   def main():
       parser = argparse.ArgumentParser(
           description="使用 Web 浏览器可视化 LeRobot 数据集 / Visualize LeRobot dataset in web browser",
           formatter_class=argparse.RawDescriptionHelpFormatter,
       )
   
       parser.add_argument(
           "--repo-id",
           type=str,
           required=True,
           help="数据集仓库 ID / Dataset repository ID (e.g. `lerobot/pusht` or `xiadengma/record-test-so101`)",
       )
   
       # Episode 选择参数 / Episode selection arguments
       group = parser.add_mutually_exclusive_group(required=True)
       group.add_argument(
           "--episode-index",
           type=int,
           help="要可视化的单个 episode 索引 / Single episode index to visualize",
       )
       group.add_argument(
           "--episodes",
           type=int,
           nargs="+",
           help="要可视化的多个 episode 索引 / Multiple episode indices to visualize (e.g. 0 1 2 3)",
       )
   
       parser.add_argument(
           "--root",
           type=Path,
           default=None,
           help="本地数据集根目录 / Root directory for local dataset (e.g. `--root ./data/datasets/xiadengma/record-test-so101`)",
       )
       parser.add_argument(
           "--batch-size",
           type=int,
           default=32,
           help="DataLoader 批处理大小 / Batch size for DataLoader (default: 32)",
       )
       parser.add_argument(
           "--num-workers",
           type=int,
           default=4,
           help="DataLoader 进程数 / Number of DataLoader worker processes (default: 4)",
       )
       parser.add_argument(
           "--port",
           type=int,
           default=9090,
           help="Web 服务器端口 / Web server port (default: 9090)",
       )
       parser.add_argument(
           "--open-browser",
           type=lambda x: str(x).lower() in ("true", "1", "yes"),
           default=True,
           help="是否自动打开浏览器 / Whether to automatically open browser (default: True)",
       )
       parser.add_argument(
           "--memory-limit",
           type=str,
           default="25%",
           help="Rerun 内存限制 / Memory limit for Rerun (default: 25%%)",
       )
       parser.add_argument(
           "--tolerance-s",
           type=float,
           default=1e-4,
           help="时间戳容差（秒）/ Tolerance in seconds for timestamps (default: 1e-4)",
       )
   
       args = parser.parse_args()
   
       # 配置日志 / Configure logging
       logging.basicConfig(
           level=logging.INFO,
           format="%(asctime)s - %(levelname)s - %(message)s",
           datefmt="%Y-%m-%d %H:%M:%S",
       )
   
       # 确定要可视化的 episode 列表 / Determine episode list
       if args.episode_index is not None:
           episode_indices = [args.episode_index]
       else:
           episode_indices = args.episodes
   
       logging.info("=" * 80)
       logging.info("🤖 LeRobot 数据集 Web 可视化工具 / LeRobot Dataset Web Visualizer")
       logging.info("=" * 80)
       logging.info(f"📦 数据集 / Dataset: {args.repo_id}")
       logging.info(f"📂 根目录 / Root: {args.root if args.root else 'HuggingFace Cache'}")
       logging.info(f"📊 Episodes: {episode_indices}")
       logging.info("=" * 80)
   
       # 加载数据集 / Load dataset
       logging.info("🔄 正在加载数据集 / Loading dataset...")
       dataset = LeRobotDataset(
           repo_id=args.repo_id,
           episodes=episode_indices,
           root=args.root,
           tolerance_s=args.tolerance_s,
       )
   
       logging.info("✅ 数据集加载成功 / Dataset loaded successfully")
       logging.info(f"📈 数据集总帧数 / Total frames: {len(dataset)}")
       logging.info(f"📹 相机数量 / Number of cameras: {len(dataset.meta.camera_keys)}")
       logging.info(f"🎥 相机列表 / Camera keys: {dataset.meta.camera_keys}")
   
       # 启动 Web 可视化 / Start web visualization
       visualize_dataset_web(
           dataset=dataset,
           episode_indices=episode_indices,
           batch_size=args.batch_size,
           num_workers=args.num_workers,
           port=args.port,
           open_browser=args.open_browser,
           memory_limit=args.memory_limit,
       )
   
   
   if __name__ == "__main__":
       main()
   

2. 查看数据集：

   • 查看单个回合：

     python -m lerobot.extra.lerobot_dataset_viz_web \
     --repo-id xiadengma/record-test-so101 \
     --root ./data/datasets/xiadengma/record-test-so101 \
     --episode-index 0 \
     --port 9090
     

   • 查看多个回合：

     python -m lerobot.extra.lerobot_dataset_viz_web \
     --repo-id xiadengma/record-test-so101 \
     --root ./data/datasets/xiadengma/record-test-so101 \
     --episodes 0 1 2 3 4 \
     --port 9090