Hugging Face's logo

LeRobot documentation

Hướng dẫn quy trình huấn luyện robot thực của HIL-SERL

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Hướng dẫn quy trình huấn luyện robot thực của HIL-SERL

Trong hướng dẫn này, bạn sẽ thực hiện toàn bộ quy trình Học tăng cường hiệu quả mẫu có con người trong vòng lặp (Human-in-the-Loop Sample-Efficient Reinforcement Learning - HIL-SERL) bằng LeRobot. Bạn sẽ làm chủ việc huấn luyện một chính sách bằng RL trên robot thực chỉ trong vài giờ.

HIL-SERL là một thuật toán học tăng cường hiệu quả về mẫu, kết hợp các minh chứng của con người với học trực tuyến và sự can thiệp của con người. Phương pháp này bắt đầu từ một tập nhỏ các minh chứng của con người, sử dụng chúng để huấn luyện một bộ phân loại phần thưởng, sau đó áp dụng kiến trúc actor-learner, trong đó con người có thể can thiệp trong quá trình thực thi chính sách để hướng dẫn khám phá và sửa chữa các hành vi không an toàn. Trong hướng dẫn này, bạn sẽ sử dụng tay cầm trò chơi để cung cấp các can thiệp và điều khiển robot trong quá trình học.

Nó kết hợp ba thành phần chính:

  1. Trình diễn ngoại tuyến & bộ phân loại phần thưởng: một vài tập dữ liệu điều khiển từ xa bởi con người cùng bộ phát hiện thành công dựa trên thị giác cung cấp cho chính sách một điểm khởi đầu được định hình.

  2. Vòng lặp actor / learner trên robot với sự can thiệp của con người: một learner Soft Actor Critic (SAC) phân tán cập nhật chính sách trong khi actor khám phá trên robot vật lý; con người có thể can thiệp bất cứ lúc nào để sửa chữa hành vi nguy hiểm hoặc kém hiệu quả.

  3. Công cụ an toàn & hiệu quả: giới hạn khớp/cầu thủ (EE), tiền xử lý vùng quan tâm (ROI) và giám sát Trackio giúp dữ liệu hữu ích và phần cứng an toàn.

Sự kết hợp của các yếu tố này giúp HIL-SERL đạt được tỷ lệ thành công nhiệm vụ gần như hoàn hảo và thời gian chu kỳ nhanh hơn so với các phương pháp cơ sở chỉ dựa trên mô phỏng.

HIL-SERL workflow

Quy trình HIL-SERL, Luo et al. 2024

Hướng dẫn này cung cấp các bước chi tiết để huấn luyện chính sách robot bằng cách sử dụng triển khai HilSerl của LeRobot để huấn luyện trên robot thực.

Tôi cần những gì?

  • Một tay cầm (khuyến nghị) hoặc bàn phím để điều khiển robot
  • Một GPU Nvidia
  • Một robot thực có cánh tay theo dõi và cánh tay dẫn (không bắt buộc nếu bạn sử dụng bàn phím hoặc tay cầm)
  • Một tệp URDF cho robot dành cho gói kinematics (xem lerobot/model/kinematics.py)

Tôi có thể huấn luyện những loại tác vụ nào?

Có thể sử dụng HIL-SERL để huấn luyện trên nhiều tác vụ thao tác khác nhau. Một số khuyến nghị:

  • Bắt đầu với một tác vụ đơn giản để hiểu cách hệ thống hoạt động.
    • Đẩy khối lập phương đến vùng đích
    • Chạm và nâng khối lập phương bằng kẹp
  • Tránh các tác vụ có tầm nhìn cực kỳ dài. Tập trung vào các tác vụ có thể hoàn thành trong 5-10 giây.
  • Khi bạn đã có cái nhìn tổng quan về cách hệ thống hoạt động, bạn có thể thử các tác vụ phức tạp hơn và các chân trời dài hơn.
    • Chạm và đặt khối lập phương
    • Các tác vụ hai tay để nhặt vật bằng hai cánh tay
    • Nhiệm vụ bàn giao để chuyển các vật thể từ cánh tay này sang cánh tay khác
    • Điên rồ lên nào!

Cài đặt LeRobot với HIL-SERL

Để cài đặt LeRobot với HIL-SERL, bạn cần cài đặt phần mở rộng hilserl.

pip install -e ".[hilserl]"

Quy trình Huấn luyện Robot Thực

Hiểu về Cấu hình

Quá trình huấn luyện bắt đầu với việc cấu hình phù hợp cho môi trường HILSERl. Lớp cấu hình chính là GymManipulatorConfig trong lerobot/rl/gym_manipulator.py, bao gồm HILSerlRobotEnvConfig (được định nghĩa trong lerobot/envs/configs.py) và DatasetConfig. Cấu hình được tổ chức thành các cấu hình con lồng nhau, tập trung:

class GymManipulatorConfig:
    env: HILSerlRobotEnvConfig    # Environment configuration (nested)
    dataset: DatasetConfig    # Dataset recording/replay configuration (nested)
    mode: str | None = None    # "record", "replay", or None (for training)
    device: str = "cpu"    # Compute device

class HILSerlRobotEnvConfig(EnvConfig):
    robot: RobotConfig | None = None    # Main robot agent (defined in `lerobot/robots`)
    teleop: TeleoperatorConfig | None = None    # Teleoperator agent, e.g., gamepad or leader arm
    processor: HILSerlProcessorConfig    # Processing pipeline configuration (nested)
    name: str = "real_robot"    # Environment name
    task: str | None = None    # Task identifier
    fps: int = 30    # Control frequency

# Nested processor configuration
class HILSerlProcessorConfig:
    control_mode: str = "gamepad"    # Control mode
    observation: ObservationConfig | None = None    # Observation processing settings
    image_preprocessing: ImagePreprocessingConfig | None = None    # Image crop/resize settings
    gripper: GripperConfig | None = None    # Gripper control and penalty settings
    reset: ResetConfig | None = None    # Environment reset and timing settings
    inverse_kinematics: InverseKinematicsConfig | None = None    # IK processing settings
    reward_classifier: RewardClassifierConfig | None = None    # Reward classifier settings
    max_gripper_pos: float | None = 100.0    # Maximum gripper position

# Sub-configuration classes
class ObservationConfig:
    add_joint_velocity_to_observation: bool = False    # Add joint velocities to state
    add_current_to_observation: bool = False    # Add motor currents to state
    add_ee_pose_to_observation: bool = False    # Add end-effector pose to state
    display_cameras: bool = False    # Display camera feeds during execution

class ImagePreprocessingConfig:
    crop_params_dict: dict[str, tuple[int, int, int, int]] | None = None    # Image cropping parameters
    resize_size: tuple[int, int] | None = None    # Target image size

class GripperConfig:
    use_gripper: bool = True    # Enable gripper control
    gripper_penalty: float = 0.0    # Penalty for inappropriate gripper usage

class ResetConfig:
    fixed_reset_joint_positions: list[float] | None = None    # Joint positions for reset
    reset_time_s: float = 5.0    # Time to wait during reset
    control_time_s: float = 20.0    # Maximum episode duration
    terminate_on_success: bool = True    # Whether to terminate episodes on success detection

class InverseKinematicsConfig:
    urdf_path: str | None = None    # Path to robot URDF file
    target_frame_name: str | None = None    # End-effector frame name
    end_effector_bounds: dict[str, list[float]] | None = None    # EE workspace bounds
    end_effector_step_sizes: dict[str, float] | None = None    # EE step sizes per axis

class RewardClassifierConfig:
    pretrained_path: str | None = None    # Path to pretrained reward classifier
    success_threshold: float = 0.5    # Success detection threshold
    success_reward: float = 1.0    # Reward value for successful episodes

# Dataset configuration
class DatasetConfig:
    repo_id: str    # LeRobot dataset repository ID
    task: str    # Task identifier
    root: str | None = None    # Local dataset root directory
    num_episodes_to_record: int = 5    # Number of episodes for recording
    replay_episode: int | None = None    # Episode index for replay
    push_to_hub: bool = False    # Whether to push datasets to Hub

Kiến trúc Pipeline của Processor

HIL-SERL sử dụng kiến trúc đường ống xử lý (processor pipeline) có tính mô-đun, xử lý quan sát và hành động của robot thông qua một loạt các bước có thể kết hợp được. Đường ống được chia thành hai thành phần chính:

Đường ống xử lý môi trường

Bộ xử lý môi trường (env_processor) xử lý các quan sát và trạng thái môi trường đến:

  1. VanillaObservationProcessorStep: Chuyển đổi quan sát thô của robot sang định dạng chuẩn
  2. JointVelocityProcessorStep (tùy chọn): Thêm thông tin vận tốc khớp vào các quan sát
  3. MotorCurrentProcessorStep (tùy chọn): Thêm các giá trị đọc dòng điện động cơ vào quan sát
  4. ForwardKinematicsJointsToEE (tùy chọn): Tính tư thế đầu cuối từ vị trí các khớp
  5. ImageCropResizeProcessorStep (tùy chọn): Cắt và thay đổi kích thước ảnh từ camera
  6. TimeLimitProcessorStep (tùy chọn): Áp dụng giới hạn thời gian cho từng episode
  7. GripperPenaltyProcessorStep (tùy chọn): Áp dụng các hình phạt cho việc sử dụng kẹp không phù hợp
  8. RewardClassifierProcessorStep (tùy chọn): Phát hiện phần thưởng tự động bằng các mô hình thị giác
  9. AddBatchDimensionProcessorStep: Chuyển đổi dữ liệu sang định dạng batch để xử lý bằng mạng nơ-ron
  10. DeviceProcessorStep: Di chuyển dữ liệu đến thiết bị tính toán được chỉ định (CPU/GPU)

Đường ống xử lý hành động

Bộ xử lý hành động (action_processor) xử lý các hành động gửi đi và sự can thiệp của con người:

  1. AddTeleopActionAsComplimentaryDataStep: Thu thập hành động của người vận hành từ xa để ghi log
  2. AddTeleopEventsAsInfoStep: Ghi lại các sự kiện can thiệp và tín hiệu điều khiển tập
  3. InterventionActionProcessorStep: Xử lý can thiệp của con người và kết thúc tập
  4. Inverse Kinematics Pipeline (khi được bật):
    • MapDeltaActionToRobotActionStep: Chuyển đổi các hành động delta sang định dạng hành động của robot
    • EEReferenceAndDelta: Tính toán chuyển động tham chiếu và delta của đầu cuối
    • EEBoundsAndSafety: Áp dụng các giới hạn an toàn cho vùng làm việc
    • InverseKinematicsEEToJoints: Chuyển đổi hành động của đầu cuối (end-effector) sang các mục tiêu khớp
    • GripperVelocityToJoint: Xử lý các lệnh điều khiển gắp

Ví dụ về cấu hình

Xử lý quan sát cơ bản:

{
  "env": {
    "processor": {
      "observation": {
        "add_joint_velocity_to_observation": true,
        "add_current_to_observation": false,
        "display_cameras": false
      }
    }
  }
}

Xử lý hình ảnh:

{
  "env": {
    "processor": {
      "image_preprocessing": {
        "crop_params_dict": {
          "observation.images.front": [180, 250, 120, 150],
          "observation.images.side": [180, 207, 180, 200]
        },
        "resize_size": [128, 128]
      }
    }
  }
}

Cấu hình Động học ngược:

{
  "env": {
    "processor": {
      "inverse_kinematics": {
        "urdf_path": "path/to/robot.urdf",
        "target_frame_name": "end_effector",
        "end_effector_bounds": {
          "min": [0.16, -0.08, 0.03],
          "max": [0.24, 0.2, 0.1]
        },
        "end_effector_step_sizes": {
          "x": 0.02,
          "y": 0.02,
          "z": 0.02
        }
      }
    }
  }
}

Xử lý quan sát nâng cao

Khung HIL-SERL hỗ trợ các tính năng xử lý quan sát bổ sung có thể cải thiện việc học chính sách:

Xử lý Tốc độ Liên hợp

Bật ước lượng vận tốc liên hợp để cung cấp cho chính sách thông tin về chuyển động:

{
  "env": {
    "processor": {
      "observation": {
        "add_joint_velocity_to_observation": true
      }
    }
  }
}

Bộ xử lý này:

  • Ước tính vận tốc khớp bằng sai phân hữu hạn giữa các lần đọc vị trí khớp liên tiếp
  • Thêm thông tin vận tốc vào vector trạng thái quan sát
  • Có ích cho các chính sách cần nhận thức chuyển động cho các tác vụ động

Xử lý dòng điện động cơ

Giám sát dòng điện động cơ để phát hiện lực tiếp xúc và điều kiện tải:

{
  "env": {
    "processor": {
      "observation": {
        "add_current_to_observation": true
      }
    }
  }
}

Bộ xử lý này:

  • Đọc các giá trị dòng điện động cơ từ hệ thống điều khiển của robot
  • Thêm các phép đo hiện tại vào vector trạng thái quan sát
  • Giúp phát hiện các sự kiện tiếp xúc, trọng lượng của vật thể và lực cản cơ học
  • Có ích cho các tác vụ thao tác có nhiều tiếp xúc

Xử lý Quan sát Kết hợp

Bạn có thể bật đồng thời nhiều tính năng xử lý quan sát:

{
  "env": {
    "processor": {
      "observation": {
        "add_joint_velocity_to_observation": true,
        "add_current_to_observation": true,
        "display_cameras": false
      }
    }
  }
}

Lưu ý: Việc bật các tính năng quan sát bổ sung sẽ làm tăng chiều không gian trạng thái, điều này có thể đòi hỏi bạn phải điều chỉnh kiến trúc mạng chính sách và có thể thu thập thêm dữ liệu huấn luyện.

Tìm phạm vi không gian làm việc của robot

Trước khi thu thập các bản demo, bạn cần xác định các giới hạn vận hành phù hợp cho robot của mình.

Điều này giúp đơn giản hóa bài toán học trên robot thực theo hai cách: 1) bằng cách giới hạn không gian vận hành của robot trong một vùng cụ thể giải quyết được tác vụ và tránh việc khám phá không cần thiết hoặc không an toàn, và 2) bằng cách cho phép huấn luyện trong không gian end-effector thay vì không gian khớp. Về mặt thực nghiệm, việc học trong không gian khớp cho reinforcement learning trong thao tác thường là một bài toán khó hơn - một số tác vụ gần như không thể học được trong không gian khớp nhưng trở nên có thể học được khi không gian hành động được chuyển đổi sang tọa độ end-effector.

Sử dụng lerobot-find-joint-limits

Script này giúp bạn tìm ra các giới hạn vận hành an toàn cho end-effector của robot. Với việc bạn có một cánh tay follower và một cánh tay leader, bạn có thể sử dụng script để tìm ra các giới hạn cho cánh tay follower sẽ được áp dụng trong quá trình huấn luyện. Việc đặt giới hạn cho không gian hành động sẽ giảm thiểu việc khám phá dư thừa của agent và đảm bảo an toàn.

lerobot-find-joint-limits \
  --robot.type=so100_follower \
  --robot.port=/dev/tty.usbmodem58760431541 \
  --robot.id=black \
  --teleop.type=so100_leader \
  --teleop.port=/dev/tty.usbmodem58760431551 \
  --teleop.id=blue \
  --urdf_path=SO-ARM100/Simulation/SO101/so101_new_calib.urdf \
  --target_frame_name=gripper

--urdf_path là bắt buộc: nó trỏ đến tệp URDF của robot, được script sử dụng để tính toán vị trí end-effector. Đối với SO-100/SO-101, hãy clone SO-ARM100 repository bằng git clone https://github.com/TheRobotStudio/SO-ARM100.git; tệp URDF sẽ nằm tại SO-ARM100/Simulation/SO101/so101_new_calib.urdf.

Quy trình

  1. Chạy script và di chuyển robot qua không gian để giải quyết tác vụ

  2. Script sẽ ghi lại vị trí đầu cuối (end-effector) tối thiểu và tối thiểu cũng như các góc khớp, sau đó in chúng ra console, ví dụ:

    # End Effector Bounds (x, y, z):
max_ee = [0.2417, 0.2012, 0.1027]
min_ee = [0.1663, -0.0823, 0.0336]

# Joint Position Limits (radians):
max_pos = [...]
min_pos = [...]

  3. Sử dụng các giá trị này trong cấu hình môi trường của bạn dưới env.processor.inverse_kinematics.end_effector_bounds (xem InverseKinematicsConfig trong lerobot/envs/configs.py)

Cấu hình mẫu

{
  "env": {
    "processor": {
      "inverse_kinematics": {
        "end_effector_bounds": {
          "max": [0.24, 0.2, 0.1],
          "min": [0.16, -0.08, 0.03]
        }
      }
    }
  }
}

Thu thập các ví dụ minh họa

Với các giới hạn đã được xác định, bạn có thể thu thập các minh chứng (demonstrations) một cách an toàn để phục vụ huấn luyện. Huấn luyện RL bằng thuật toán off-policy cho phép chúng ta sử dụng các bộ dữ liệu ngoại tuyến (offline) đã được thu thập nhằm cải thiện hiệu quả của quá trình học.

Cài đặt Chế độ Ghi

Các tệp cấu hình mẫu cho hướng dẫn này nằm trong bộ dữ liệu lerobot/config_examples trên Hub. Tải xuống các cấu hình môi trường và huấn luyện vào thư mục làm việc của bạn:

hf download lerobot/config_examples rl/env_config.json rl/train_config.json --repo-type dataset --local-dir .

Điều này lưu chúng vào rl/env_config.json và rl/train_config.json, các đường dẫn được sử dụng trong các lệnh bên dưới. Chỉnh sửa rl/env_config.json để ghi lại các bản trình diễn:

  1. Đặt mode thành "record" ở cấp độ gốc
  2. Chỉ định một repo_id duy nhất cho bộ dữ liệu của bạn trong phần dataset (ví dụ: “username/task_name”)
  3. Đặt num_episodes_to_record trong phần dataset thành số lượng minh chứng bạn muốn thu thập
  4. Đặt env.processor.image_preprocessing.crop_params_dict thành {} ban đầu (chúng ta sẽ xác định các vùng cắt sau)
  5. Cấu hình env.robot, env.teleop và các cài đặt phần cứng khác trong phần env

Mục cấu hình ví dụ:

{
  "env": {
    "type": "gym_manipulator",
    "name": "real_robot",
    "fps": 10,
    "processor": {
      "control_mode": "gamepad",
      "observation": {
        "display_cameras": false
      },
      "image_preprocessing": {
        "crop_params_dict": {},
        "resize_size": [128, 128]
      },
      "gripper": {
        "use_gripper": true,
        "gripper_penalty": 0.0
      },
      "reset": {
        "reset_time_s": 5.0,
        "control_time_s": 20.0
      }
    },
    "robot": {
      // ... robot configuration ...
    },
    "teleop": {
      // ... teleoperator configuration ...
    }
  },
  "dataset": {
    "repo_id": "username/pick_lift_cube",
    "root": null,
    "task": "pick_and_lift",
    "num_episodes_to_record": 15,
    "replay_episode": 0,
    "push_to_hub": true
  },
  "mode": "record",
  "device": "cpu"
}

Sử dụng thiết bị điều khiển từ xa

Cùng với robot của bạn, bạn sẽ cần một thiết bị điều khiển từ xa để điều khiển nó nhằm thu thập các bộ dữ liệu cho tác vụ của bạn và thực hiện các can thiệp trong quá trình huấn luyện trực tuyến. Chúng tôi hỗ trợ việc sử dụng tay cầm chơi game, bàn phím hoặc cánh tay dẫn của robot.

HIL-Serl học các hành động trong không gian đầu cuối (end-effector) của robot. Do đó, thao tác từ xa (teleoperation) sẽ điều khiển các độ dịch chuyển x, y, z của đầu cuối.

Biến đổi end-effector được áp dụng bởi pipeline processor (InverseKinematicsRLStep, EEBoundsAndSafety, EEReferenceAndDelta, GripperVelocityToJoint) được cấu hình dưới env.processor.inverse_kinematics (InverseKinematicsConfig) và env.processor.gripper / env.processor.max_gripper_pos. Các giá trị mặc định liên quan đến không gian end-effector là:

class InverseKinematicsConfig:
    """Configuration for inverse kinematics processing."""

    urdf_path: str | None = None
    target_frame_name: str | None = None
    # bounds for the end-effector in x,y,z direction
    end_effector_bounds: dict[str, list[float]] | None = None
    # maximum step size for the end-effector in x,y,z direction
    end_effector_step_sizes: dict[str, float] | None = None

class HILSerlProcessorConfig:
    ...
    # maximum gripper position that the gripper will be open at
    max_gripper_pos: float | None = 100.0

Teleoperator định nghĩa thiết bị điều khiển từ xa. Bạn có thể xem danh sách các teleoperator khả dụng trong lerobot/teleoperators.

Cài đặt tay cầm

Gamepad cung cấp một cách rất tiện lợi để điều khiển robot và trạng thái của episode.

Để thiết lập tay cầm, bạn cần đặt control_mode thành "gamepad" và định nghĩa phần teleop trong tệp cấu hình.

{
  "env": {
    "teleop": {
      "type": "gamepad",
      "use_gripper": true
    },
    "processor": {
      "control_mode": "gamepad",
      "gripper": {
        "use_gripper": true
      }
    }
  }
}

Figure shows the control mappings on a Logitech gamepad.

Ánh xạ nút gamepad để điều khiển robot và quản lý tập

Cài đặt leader SO101

Cánh tay leader của SO101 có bộ giảm tốc, cho phép nó di chuyển và theo dõi cánh tay follower trong quá trình khám phá. Do đó, việc tiếp quản diễn ra mượt mà hơn nhiều so với SO100 không có bộ giảm tốc.

Để thiết lập SO101 leader, bạn cần đặt control_mode thành "leader" và định nghĩa phần teleop trong tệp cấu hình.

{
  "env": {
    "teleop": {
      "type": "so101_leader",
      "port": "/dev/tty.usbmodem585A0077921",
      "use_degrees": true
    },
    "processor": {
      "control_mode": "leader",
      "gripper": {
        "use_gripper": true
      }
    }
  }
}

Để chú thích thành công/thất bại của tập, bạn cần sử dụng bàn phím để nhấn s cho thành công, esc cho thất bại. Trong quá trình huấn luyện trực tuyến, nhấn space để tiếp quản chính sách và nhấn space một lần nữa để trả quyền kiểm soát lại cho chính sách.

Video: SO101 leader teleoperation

Ví dụ teleoperation với leader SO101, leader theo dõi follower, nhấn `space` để can thiệp

Thu thập dữ liệu minh họa

Bắt đầu quá trình ghi âm với cấu hình môi trường bạn đã chỉnh sửa ở trên:

python -m lerobot.rl.gym_manipulator --config_path rl/env_config.json

Trong quá trình ghi âm:

  1. Robot sẽ được đặt lại về vị trí ban đầu được định nghĩa trong tệp cấu hình env.processor.reset.fixed_reset_joint_positions
  2. Hoàn thành nhiệm vụ thành công
  3. Tập kết thúc với phần thưởng là 1 khi bạn nhấn nút “success”
  4. Nếu thời gian giới hạn đã hết, hoặc nút fail được nhấn, tập sẽ kết thúc với phần thưởng là 0
  5. Bạn có thể ghi lại một tập bằng cách nhấn nút “rerecord”
  6. Quy trình tự động tiếp tục sang tập tiếp theo
  7. Sau khi ghi lại tất cả các tập, bộ dữ liệu sẽ được đẩy lên Hugging Face Hub (tuỳ chọn) và lưu cục bộ

Xử lý Bộ dữ liệu

Sau khi thu thập các bản demo, hãy xử lý chúng để xác định các vùng cắt camera tối ưu. Học tăng cường nhạy cảm với các yếu tố gây xao nhãng ở nền, vì vậy việc cắt các hình ảnh xuống vùng không gian làm việc liên quan là rất quan trọng.

Các thuật toán RL trực quan học trực tiếp từ đầu vào dạng pixel, khiến chúng dễ bị ảnh hưởng bởi thông tin thị giác không liên quan. Các yếu tố nền như ánh sáng thay đổi, bóng đổ, người di chuyển hoặc các vật thể nằm ngoài không gian làm việc có thể gây nhiễu quá trình học. Việc chọn ROI tốt nên:

  • Chỉ bao gồm không gian làm việc thiết yếu nơi tác vụ được thực hiện
  • Chụp lại đầu cuối (end-effector) của robot và tất cả các đối tượng liên quan đến tác vụ
  • Loại bỏ các yếu tố nền và chi tiết gây xao nhãng không cần thiết

Lưu ý: Nếu bạn đã biết các tham số cắt, bạn có thể bỏ qua bước này và chỉ cần đặt crop_params_dict trong tệp cấu hình khi ghi.

Xác định thông số cắt

Sử dụng script crop_dataset_roi.py để tương tác chọn các vùng quan tâm trong ảnh camera của bạn:

python -m lerobot.rl.crop_dataset_roi --repo-id username/pick_lift_cube
  1. Với mỗi góc nhìn của camera, script sẽ hiển thị khung hình đầu tiên
  2. Vẽ một hình chữ nhật bao quanh khu vực làm việc liên quan
  3. Nhấn ‘c’ để xác nhận lựa chọn
  4. Lặp lại cho tất cả các góc nhìn của camera
  5. Script in ra các tham số cắt và tạo một tập dữ liệu đã cắt mới

Ví dụ về kết quả đầu ra:

Selected Rectangular Regions of Interest (top, left, height, width):
observation.images.side: [180, 207, 180, 200]
observation.images.front: [180, 250, 120, 150]

Công cụ cắt tương tác để chọn các vùng quan tâm

Cập nhật Cấu hình

Thêm các tham số crop này vào cấu hình huấn luyện của bạn:

{
  "env": {
    "processor": {
      "image_preprocessing": {
        "crop_params_dict": {
          "observation.images.side": [180, 207, 180, 200],
          "observation.images.front": [180, 250, 120, 150]
        },
        "resize_size": [128, 128]
      }
    }
  }
}

Độ phân giải hình ảnh được khuyến nghị

Hầu hết các chính sách dựa trên thị giác đã được kiểm chứng trên các đầu vào vuông có kích thước 128×128 (mặc định) hoặc 64×64 pixel. Do đó, chúng tôi khuyên bạn nên đặt tham số resize_size thành [128, 128] – hoặc [64, 64] nếu bạn cần tiết kiệm bộ nhớ và băng thông GPU. Các độ phân giải khác là có thể nhưng chưa được kiểm tra rộng rãi.

Huấn luyện một Bộ phân loại phần thưởng

Bộ phân loại phần thưởng đóng vai trò quan trọng trong quy trình HIL-SERL bằng cách tự động hóa việc gán phần thưởng và tự động phát hiện thành công của tập. Thay vì phải định nghĩa thủ công các hàm phần thưởng hoặc dựa vào phản hồi của con người cho mỗi bước thời gian, bộ phân loại phần thưởng học cách dự đoán thành công/thất bại từ các quan sát thị giác. Điều này cho phép thuật toán RL học một cách hiệu quả bằng cách cung cấp các tín hiệu phần thưởng nhất quán và tự động dựa trên đầu vào từ camera của robot.

Hướng dẫn này giải thích cách huấn luyện một bộ phân loại phần thưởng cho việc triển khai học tăng cường có sự tham gia của con người trong LeRobot. Các bộ phân loại phần thưởng học cách dự đoán giá trị phần thưởng dựa trên một trạng thái, có thể được sử dụng trong một cấu hình RL để huấn luyện một chính sách.

Lưu ý: Việc huấn luyện bộ phân loại phần thưởng là tùy chọn. Bạn có thể bắt đầu vòng thử nghiệm RL đầu tiên bằng cách tự động ghi chú thành công bằng thiết bị tay cầm hoặc bàn phím của mình.

Cài đặt bộ phân loại phần thưởng trong lerobot/rewards/classifier/modeling_classifier.py sử dụng một mô hình thị giác được huấn luyện trước để xử lý các hình ảnh. Nó có thể xuất ra một giá trị duy nhất cho phần thưởng nhị phân để dự đoán các trường hợp thành công/thất bại, hoặc nhiều giá trị cho các cấu hình đa lớp.

Thu thập Dữ liệu cho bộ phân loại phần thưởng

Trước khi huấn luyện, bạn cần thu thập một bộ dữ liệu gồm các ví dụ đã gắn nhãn. Việc đặt mode: "record" trong cấu hình của bạn và chạy gym_manipulator.py sẽ kích hoạt quy trình thu thập bộ dữ liệu gồm các quan sát, hành động và phần thưởng.

Để thu thập một bộ dữ liệu, bạn cần sửa đổi một số tham số trong cấu hình môi trường dựa trên HILSerlRobotEnvConfig.

python -m lerobot.rl.gym_manipulator --config_path rl/env_config.json

Các tham số chính cho việc thu thập dữ liệu

  • mode: đặt thành "record" để thu thập một bộ dữ liệu (ở cấp độ gốc)
  • dataset.repo_id: "hf_username/dataset_name", tên của bộ dữ liệu và kho trên hub
  • dataset.num_episodes_to_record: Số lượng episode cần ghi lại
  • env.processor.reset.terminate_on_success: Xác định xem có tự động kết thúc các episode khi phát hiện thành công hay không (mặc định: true)
  • env.fps: Số khung hình mỗi giây để ghi
  • dataset.push_to_hub: Có đẩy bộ dữ liệu lên hub hay không

Tham số env.processor.reset.terminate_on_success cho phép bạn kiểm soát hành vi kết thúc episode. Khi đặt thành false, các episode sẽ tiếp tục ngay cả sau khi phát hiện thành công, cho phép bạn thu thập thêm nhiều ví dụ tích cực với nhãn reward=1. Điều này rất quan trọng để huấn luyện bộ phân loại phần thưởng vì nó cung cấp thêm nhiều ví dụ trạng thái thành công trong bộ dữ liệu của bạn. Khi đặt thành true (mặc định), các episode sẽ kết thúc ngay lập tức khi phát hiện thành công.

Quan trọng: Đối với huấn luyện bộ phân loại phần thưởng, hãy đặt terminate_on_success: false để thu thập đủ các ví dụ dương. Đối với huấn luyện HIL-SERL thông thường, hãy giữ nguyên giá trị true để kích hoạt việc kết thúc episode tự động khi nhiệm vụ được hoàn thành thành công.

Mục cấu hình ví dụ cho việc thu thập dữ liệu:

{
  "env": {
    "type": "gym_manipulator",
    "name": "real_robot",
    "fps": 10,
    "processor": {
      "reset": {
        "reset_time_s": 5.0,
        "control_time_s": 20.0,
        "terminate_on_success": false
      },
      "gripper": {
        "use_gripper": true
      }
    },
    "robot": {
      // ... robot configuration ...
    },
    "teleop": {
      // ... teleoperator configuration ...
    }
  },
  "dataset": {
    "repo_id": "hf_username/dataset_name",
    "root": "data/your_dataset",
    "task": "reward_classifier_task",
    "num_episodes_to_record": 20,
    "replay_episode": null,
    "push_to_hub": true
  },
  "mode": "record",
  "device": "cpu"
}

Cấu hình Bộ phân loại phần thưởng

Bộ phân loại phần thưởng được cấu hình bằng lerobot/rewards/classifier/configuration_classifier.py. Dưới đây là các tham số chính:

  • model_name: Kiến trúc mô hình cơ sở (ví dụ: chúng tôi chủ yếu sử dụng "helper2424/resnet10")
  • model_type: "cnn" hoặc "transformer"
  • num_cameras: Số lượng đầu vào camera
  • num_classes: Số lượng lớp đầu ra (thường là 2 cho thành công/thất bại nhị phân)
  • hidden_dim: Kích thước của biểu diễn ẩn
  • dropout_rate: Tham số điều hòa
  • learning_rate: Tốc độ học cho bộ tối ưu

Cấu hình mẫu để huấn luyện bộ phân loại phần thưởng. Lưu nó dưới dạng reward_classifier_train_config.json:

{
  "dataset": {
    "repo_id": "hf_username/dataset_name",
    "root": null
  },
  "reward_model": {
    "type": "reward_classifier",
    "model_name": "helper2424/resnet10",
    "model_type": "cnn",
    "num_cameras": 2,
    "num_classes": 2,
    "hidden_dim": 256,
    "dropout_rate": 0.1,
    "learning_rate": 1e-4,
    "device": "cuda",
    "input_features": {
      "observation.images.front": {
        "type": "VISUAL",
        "shape": [3, 128, 128]
      },
      "observation.images.side": {
        "type": "VISUAL",
        "shape": [3, 128, 128]
      }
    },
    "push_to_hub": true,
    "repo_id": "hf_username/model_repo"
  },
  "batch_size": 16,
  "num_workers": 4,
  "steps": 5000,
  "log_freq": 10,
  "env_eval_freq": 1000,
  "save_freq": 1000,
  "save_checkpoint": true,
  "seed": 2,
  "resume": false,
  "optimizer": {
    "grad_clip_norm": 10.0
  },
  "trackio": {
    "enable": true,
    "project": "reward-classifier"
  },
  "job_name": "reward-classifier"
}

Đào tạo bộ phân loại

Để huấn luyện bộ phân loại, hãy sử dụng script train.py với cấu hình của bạn:

lerobot-train --config_path reward_classifier_train_config.json

Triển khai và Kiểm thử Mô hình

Để sử dụng bộ phân loại phần thưởng đã huấn luyện của bạn, hãy cấu hình HILSerlRobotEnvConfig để sử dụng mô hình của bạn:

config = GymManipulatorConfig(
    env=HILSerlRobotEnvConfig(
        processor=HILSerlProcessorConfig(
            reward_classifier=RewardClassifierConfig(
                pretrained_path="path_to_your_pretrained_trained_model"
            )
        ),
        # Other environment parameters
    ),
    dataset=DatasetConfig(...),
    mode=None  # For training
)

hoặc đặt tham số trong tệp cấu hình json.

{
  "env": {
    "processor": {
      "reward_classifier": {
        "pretrained_path": "path_to_your_pretrained_model",
        "success_threshold": 0.7,
        "success_reward": 1.0
      },
      "reset": {
        "terminate_on_success": true
      }
    }
  }
}

Chạy gym_manipulator.py để kiểm tra mô hình.

python -m lerobot.rl.gym_manipulator --config_path rl/env_config.json

Bộ phân loại phần thưởng sẽ tự động cung cấp phần thưởng dựa trên đầu vào hình ảnh từ các camera của robot.

Quy trình ví dụ để huấn luyện bộ phân loại phần thưởng

  1. Tạo các tệp cấu hình: Tạo các tệp cấu hình json cần thiết cho bộ phân loại phần thưởng và môi trường: reward_classifier_train_config.json từ ví dụ ở trên và rl/env_config.json đã tải xuống.

  2. Thu thập một bộ dữ liệu:

    python -m lerobot.rl.gym_manipulator --config_path rl/env_config.json

  3. Đào tạo bộ phân loại:

    lerobot-train --config_path reward_classifier_train_config.json

  4. Thử nghiệm bộ phân loại:

    python -m lerobot.rl.gym_manipulator --config_path rl/env_config.json

Huấn luyện với Actor-Learner

Hệ thống LeRobot sử dụng kiến trúc actor-learner phân tán để huấn luyện. Kiến trúc này tách biệt tương tác của robot khỏi quá trình học, cho phép chúng chạy đồng thời mà không chặn lẫn nhau. Máy chủ actor xử lý quan sát và hành động của robot, gửi dữ liệu tương tác đến máy chủ learner. Máy chủ learner thực hiện hạ gradient và định kỳ cập nhật trọng số chính sách của actor. Bạn sẽ cần khởi động hai tiến trình: một learner và một actor.

Cấu hình thiết lập

Chỉnh sửa tệp cấu hình huấn luyện bạn đã tải xuống trước đó, rl/train_config.json (có ví dụ tại đây). Cấu hình huấn luyện dựa trên lớp chính TrainRLServerPipelineConfig trong lerobot/rl/train_rl.py.

  1. Cấu hình cài đặt chính sách (type="gaussian_actor", device, v.v.)
  2. Cấu hình cài đặt thuật toán trong khối algorithm cấp trên cùng (type="sac", tốc độ học, chiết khấu, v.v., được định nghĩa trong lerobot/rl/algorithms/sac/configuration_sac.py).
  3. Đặt dataset thành bộ dữ liệu đã cắt của bạn
  4. Cấu hình cài đặt môi trường với các tham số cắt
  5. Kiểm tra các tham số khác liên quan đến Gaussian Actor trong configuration_gaussian_actor.py.
  6. Kiểm tra xem cấu hình policy có chính xác với input_features và output_features phù hợp cho tác vụ của bạn hay không.

Bắt đầu Learner

Đầu tiên, hãy khởi chạy tiến trình máy chủ learner:

python -m lerobot.rl.learner --config_path rl/train_config.json

Người học:

  • Khởi tạo mạng chính sách
  • Chuẩn bị bộ đệm phát lại
  • Mở một máy chủ gRPC để giao tiếp với các actor
  • Xử lý các bước chuyển và cập nhật chính sách

Khởi động Actor

Trong một terminal riêng, khởi chạy tiến trình actor với cùng cấu hình:

python -m lerobot.rl.actor --config_path rl/train_config.json

Diễn viên:

  • Kết nối với learner thông qua gRPC
  • Khởi tạo môi trường
  • Thực hiện các lượt rollout của chính sách để thu thập kinh nghiệm
  • Gửi các chuyển tiếp đến trình học
  • Nhận các tham số chính sách đã cập nhật

Luồng huấn luyện

Quá trình huấn luyện diễn ra tự động:

  1. Actor thực thi chính sách trong môi trường
  2. Các chuyển tiếp được thu thập và gửi đến trình học
  3. Learner cập nhật chính sách dựa trên các bước chuyển này
  4. Các tham số chính sách đã được cập nhật được gửi ngược lại cho actor
  5. Quy trình tiếp tục cho đến khi đạt đến giới hạn bước được chỉ định

Con người trong vòng lặp

  • Chìa khóa để học tập hiệu quả là có sự can thiệp của con người nhằm cung cấp phản hồi hiệu chỉnh và hoàn thành nhiệm vụ, từ đó hỗ trợ việc học chính sách và khám phá.
  • Để thực hiện can thiệp của con người, bạn có thể nhấn nút trigger phía trên bên phải trên tay cầm (hoặc phím space trên bàn phím). Thao tác này sẽ tạm dừng các hành động của policy và cho phép bạn tiếp quản.
  • Một thí nghiệm thành công là thí nghiệm mà con người phải can thiệp ở giai đoạn đầu nhưng sau đó giảm dần mức độ can thiệp khi chính sách được cải thiện. Bạn có thể theo dõi tỷ lệ can thiệp trên bảng điều khiển Trackio (trackio show --project <project>).

Figure shows the control mappings on a Logitech gamepad.

Ví dụ minh họa cách can thiệp của con người giúp định hướng việc học chính sách theo thời gian

  • Hình vẽ cho thấy đồ thị phần thưởng theo từng bước tương tác. Hình vẽ cho thấy tác động của sự can thiệp của con người đối với việc học chính sách.
  • Đường cong màu cam là một thí nghiệm không có sự can thiệp của con người. Trong khi đó, các đường cong màu hồng và màu xanh lam là các thí nghiệm có sự can thiệp của con người.
  • Chúng ta có thể quan sát thấy rằng số bước mà chính sách bắt đầu đạt được phần thưởng tối đa giảm đi một phần tư khi có sự can thiệp của con người.

Giám sát và gỡ lỗi

Nếu bạn đã đặt trackio.enable thành true trong cấu hình của mình, bạn có thể theo dõi tiến độ huấn luyện theo thời gian thực qua bảng điều khiển Trackio (trackio show --project <project>).

Hướng dẫn về can thiệp của con người

Quá trình học tập rất nhạy cảm với chiến lược can thiệp. Sẽ mất một vài lần chạy để hiểu cách can thiệp hiệu quả. Một số mẹo và gợi ý:

  • Cho phép chính sách khám phá trong một vài tập ở đầu quá trình huấn luyện.
  • Tránh việc không can thiệp trong thời gian dài. Hãy cố gắng can thiệp trong tình huống để sửa chữa hành vi của robot khi nó đi chệch hướng.
  • Khi chính sách bắt đầu hoàn thành được tác vụ, ngay cả khi chưa hoàn hảo, bạn có thể giới hạn các can thiệp của mình vào những hành động đơn giản, nhanh chóng như các lệnh nắm đơn giản.

Hành vi lý tưởng là tỷ lệ can thiệp của bạn nên giảm dần trong quá trình huấn luyện như được minh họa trong hình dưới đây.

Intervention rate

Biểu đồ tỷ lệ can thiệp trong một lượt huấn luyện trên tác vụ nhặt và nâng khối lập phương

Các siêu tham số chính cần tinh chỉnh

Một số giá trị cấu hình có tác động không cân xứng đến độ ổn định và tốc độ huấn luyện:

  • temperature_init (algorithm.temperature_init) – nhiệt độ entropy ban đầu trong SAC. Giá trị cao hơn khuyến khích khám phá nhiều hơn; giá trị thấp hơn khiến chính sách trở nên tất định hơn ở giai đoạn đầu. Điểm khởi đầu tốt là 1e-2. Chúng tôi nhận thấy rằng việc đặt giá trị này quá cao có thể khiến các can thiệp của con người trở nên kém hiệu quả và làm chậm quá trình học.
  • policy_parameters_push_frequency (policy.actor_learner_config.policy_parameters_push_frequency) – khoảng thời gian tính bằng giây giữa hai lần đẩy trọng số từ learner sang actor. Giá trị mặc định là 4 s. Giảm xuống 1-2 s để cung cấp trọng số mới hơn (đánh đổi bằng lượng lưu lượng mạng lớn hơn); chỉ tăng lên nếu kết nối của bạn chậm, vì điều này sẽ làm giảm hiệu quả lấy mẫu.
  • storage_device (policy.storage_device) – thiết bị mà learner lưu trữ các tham số của policy. Nếu bạn có bộ nhớ GPU dự phòng, hãy đặt giá trị này thành "cuda" (thay vì mặc định là "cpu"). Việc giữ trọng số trên GPU giúp loại bỏ chi phí chuyển dữ liệu từ CPU sang GPU và có thể tăng đáng kể số lần cập nhật learner mỗi giây.

Chúc mừng 🎉, bạn đã hoàn thành hướng dẫn này!

Nếu bạn có bất kỳ câu hỏi nào hoặc cần hỗ trợ, vui lòng liên hệ trên Discord.

Trích dẫn bài báo:

@article{luo2024precise,
  title={Precise and Dexterous Robotic Manipulation via Human-in-the-Loop Reinforcement Learning},
  author={Luo, Jianlan and Xu, Charles and Wu, Jeffrey and Levine, Sergey},
  journal={arXiv preprint arXiv:2410.21845},
  year={2024}
}
Update on GitHub

←Dùng phần cứng của riêng bạn Huấn luyện RL trong Mô phỏng→