HIL-SERL 실제 로봇 학습 워크플로 가이드

이 튜토리얼에서는 LeRobot을 사용하여 Human-in-the-Loop Sample-Efficient Reinforcement Learning(HIL-SERL) 워크플로우 전체를 진행합니다. 몇 시간 만에 실제 로봇에서 RL로 정책을 학습하는 방법을 익힐 수 있습니다.

HIL-SERL은 인간 데모, 온라인 학습, 인간 개입을 결합한 샘플 효율적인 강화 학습 알고리즘입니다. 이 접근법은 소수의 인간 데모에서 시작하여 이를 활용해 보상 분류기를 학습한 후, 정책 실행 중 인간이 개입하여 탐색을 유도하고 위험한 행동을 수정할 수 있는 액터-러너 아키텍처를 사용합니다. 이 튜토리얼에서는 게임패드를 사용하여 학습 과정 중 개입을 제공하고 로봇을 제어합니다.

세 가지 핵심 요소를 결합합니다:

1. 오프라인 데모 및 보상 분류기: 소수의 인간 텔레오프 에피소드와 비전 기반 성공 감지기를 통해 정책이 형성된 시작점을 갖습니다.

2. 휴먼 개입을 포함하는 온-로봇 액터/러너 루프: 분산형 Soft Actor Critic(SAC) 러너가 정책을 업데이트하는 동안 액터가 물리적 로봇에서 탐색을 수행합니다. 휴먼은 위험하거나 비생산적인 동작을 교정하기 위해 언제든지 개입할 수 있습니다.

3. 안전 및 효율성 도구: 조인트/엔드 이펙터(EE) 한계, 관심 영역(ROI) 크롭 전처리 및 Trackio 모니터링을 통해 데이터의 유용성을 유지하고 하드웨어의 안전을 보장합니다.

이러한 요소들이 결합되어 HIL-SERL은 모방 학습만 사용한 베이스라인에 비해 거의 완벽한 작업 성공률과 더 빠른 사이클 시간을 달성할 수 있습니다.

HIL-SERL 워크플로, Luo et al. 2024

이 가이드는 LeRobot의 HilSerl 구현을 사용하여 실제 로봇에서 학습하기 위한 로봇 정책 학습 단계별 지침을 제공합니다.

무엇이 필요한가요?

• 로봇을 제어하기 위한 게임패드(권장) 또는 키보드
• Nvidia GPU
• 팔로워와 리더 암을 갖춘 실제 로봇(키보드 또는 게임패드를 사용하는 경우 선택 사항)
• kinematics 패키지를 위한 로봇의 URDF 파일(lerobot/model/kinematics.py 확인)

어떤 작업을 학습할 수 있나요?

HIL-SERL을 사용하여 다양한 조작 작업을 학습할 수 있습니다. 몇 가지 권장 사항:

• 시스템의 작동 방식을 이해하기 위해 간단한 작업부터 시작해 보세요.
  • 큐브를 목표 영역으로 밀기
  • 그리퍼로 큐브를 집어 들어 올리기
• 극도로 긴 시간 범위의 작업을 피하세요. 5~10초 안에 완료할 수 있는 작업에 집중하세요.
• 시스템의 작동 방식을 충분히 이해했다면, 더 복잡한 작업과 더 긴 시간 범위를 시도해 볼 수 있습니다.
  • 큐브를 집어 놓기
  • 두 팔로 물체를 집는 양수(雙手) 작업
  • Hand-over tasks를 통해 한 팔에서 다른 팔로 물체를 전달합니다
  • 미친 듯이 달려보세요!

HIL-SERL과 함께 LeRobot 설치

LeRobot에 HIL-SERL을 설치하려면 hilserl extra를 설치해야 합니다.

pip install -e ".[hilserl]"

실제 로봇 학습 워크플로

구성 이해하기

학습 과정은 HILSERl 환경을 위한 적절한 구성으로 시작됩니다. 주요 구성 클래스는 lerobot/rl/gym_manipulator.py에 있는 GymManipulatorConfig이며, lerobot/envs/configs.py에 정의된 HILSerlRobotEnvConfig와 DatasetConfig가 중첩되어 있습니다. 구성은 초점이 명확한 중첩 서브 구성으로 조직됩니다:

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

프로세서 파이프라인 아키텍처

HIL-SERL은 로봇의 관측값과 행동을 일련의 조합 가능한 단계를 통해 처리하는 모듈형 프로세서 파이프라인 아키텍처를 사용합니다. 파이프라인은 두 가지 주요 구성 요소로 나뉩니다:

Environment Processor 파이프라인

환경 프로세서(env_processor)는 수신된 관찰과 환경 상태를 처리합니다:

1. VanillaObservationProcessorStep: 원시 로봇 관측을 표준화된 형식으로 변환
2. JointVelocityProcessorStep (선택 사항): 관측값에 관절 속도 정보를 추가합니다
3. MotorCurrentProcessorStep (선택 사항): 관측값에 모터 전류 측정값을 추가합니다
4. ForwardKinematicsJointsToEE (선택 사항): 관절 위치에서 엔드 이펙터 포즈를 계산합니다
5. ImageCropResizeProcessorStep (선택 사항): 카메라 이미지를 자르고 크기를 조정합니다
6. TimeLimitProcessorStep (선택 사항): 에피소드 시간 제한을 강제합니다
7. GripperPenaltyProcessorStep (선택 사항): 부적절한 그리퍼 사용에 대한 패널티를 적용합니다
8. RewardClassifierProcessorStep (선택 사항): 비전 모델을 활용한 자동 보상 감지
9. AddBatchDimensionProcessorStep: 신경망 처리를 위해 데이터를 배치 형식으로 변환
10. DeviceProcessorStep: 데이터를 지정된 컴퓨트 장치(CPU/GPU)로 이동

액션 프로세서 파이프라인

액션 프로세서(action_processor)는 나가는 액션과 인간의 개입을 처리합니다:

1. AddTeleopActionAsComplimentaryDataStep: 텔레오퍼레이터의 동작을 로깅을 위해 캡처합니다
2. AddTeleopEventsAsInfoStep: 개입 이벤트와 에피소드 제어 신호를 기록합니다
3. InterventionActionProcessorStep: 인간 개입 및 에피소드 종료를 처리합니다
4. Inverse Kinematics Pipeline (활성화 시):
   • MapDeltaActionToRobotActionStep: 델타 액션을 로봇 액션 형식으로 변환
   • EEReferenceAndDelta: 엔드 이펙터의 기준 및 델타 이동을 계산합니다
   • EEBoundsAndSafety: 워크스페이스 안전 한계를 강제합니다
   • InverseKinematicsEEToJoints: 엔드 이펙터 액션을 조인트 타깃으로 변환
   • GripperVelocityToJoint: 그립퍼 제어 명령을 처리합니다

구성 예시

기본 관찰 처리:

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

이미지 처리:

{
  "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]
      }
    }
  }
}

역학 역학 설정:

{
  "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
        }
      }
    }
  }
}

고급 관찰 처리

HIL-SERL 프레임워크는 정책 학습을 향상시킬 수 있는 추가적인 관찰 처리 기능을 지원합니다:

Joint Velocity Processing

정책에 운동 정보를 제공하기 위해 결합 속도 추정을 활성화합니다:

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

이 프로세서:

• 연속된 관절 위치 읽기 값 사이의 유한 차분을 사용하여 관절 속도를 추정합니다
• 관측 상태 벡터에 속도 정보를 추가합니다
• 동적 작업을 위해 움직임 인식 기능이 필요한 정책에 유용합니다

모터 전류 처리

접촉 힘과 부하 조건을 감지하기 위해 모터 전류를 모니터링합니다:

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

이 프로세서:

• 로봇의 제어 시스템에서 모터 전류 값을 읽습니다
• 관측 상태 벡터에 현재 측정값을 추가합니다
• 접촉 이벤트, 물체 무게, 기계적 저항을 감지하는 데 도움을 줍니다
• 접촉이 많은 조작 작업에 유용

통합 관찰 처리

여러 관찰 처리 기능을 동시에 활성화할 수 있습니다:

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

참고: 추가 관찰 기능을 활성화하면 상태 공간의 차원이 증가하므로, 정책 네트워크 아키텍처를 조정하고 더 많은 학습 데이터를 수집해야 할 수 있습니다.

로봇 워크스페이스 경계 찾기

데모를 수집하기 전에 로봇의 적절한 작동 범위를 결정해야 합니다.

이것은 실제 로봇에서의 학습 문제를 두 가지 측면에서 단순화하는 데 도움이 됩니다. 1) 작업을 해결하고 불필요하거나 위험한 탐색을 피할 수 있는 특정 영역으로 로봇의 작동 공간을 제한하는 것, 그리고 2) 관절 공간이 아닌 엔드 이펙터 공간에서 훈련을 가능하게 하는 것입니다. 경험적으로, 조작을 위한 강화 학습에서 관절 공간으로 학습하는 것은 종종 더 어려운 문제입니다. 일부 작업은 관절 공간에서는 거의 학습이 불가능하지만, 동작 공간을 엔드 이펙터 좌표로 변환하면 학습이 가능해집니다.

lerobot-find-joint-limits 사용

이 스크립트는 로봇의 엔드 이펙터(end-effector)에 대한 안전한 작동 범위를 찾는 데 도움을 줍니다. 팔로어(follower)와 리더(leader) 팔이 있는 경우, 이 스크립트를 사용하여 학습 중에 적용될 팔로어 팔의 범위를 찾을 수 있습니다. 액션 스페이스(action space)에 경계를 설정하면 에이전트의 중복 탐색을 줄이고 안전을 보장합니다.

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는 필수입니다. 로봇의 URDF 파일 경로를 지정하며, 스크립트는 이 파일을 사용하여 엔드 이펙터(end-effector) 위치를 계산합니다. SO-100/SO-101의 경우 git clone https://github.com/TheRobotStudio/SO-ARM100.git 명령으로 SO-ARM100 저장소를 클론하고, URDF 파일은 SO-ARM100/Simulation/SO101/so101_new_calib.urdf 경로에 위치합니다.

워크플로

1. … 스크립트를 실행하고 로봇을 이동시켜 작업을 해결하는 공간을 탐색합니다

2. … 스크립트는 엔드 이펙터의 최소 및 최대 위치와 관절 각도를 기록하여 콘솔에 출력합니다. 예를 들어:

   복사됨

   # 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. 이 값들은 lerobot/envs/configs.py의 InverseKinematicsConfig(참조)에 따라 환경 구성의 env.processor.inverse_kinematics.end_effector_bounds 아래에서 사용하세요.

예시 구성

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

데모 수집

경계가 정의되면 학습을 위한 데모를 안전하게 수집할 수 있습니다. 오프-폴리시(off-policy) 알고리즘을 사용한 RL 학습은 학습 과정의 효율성을 높이기 위해 순서대로 수집된 오프라인 데이터셋을 활용할 수 있게 합니다.

레코드 모드 설정

이 가이드의 예제 구성 파일은 Hub의 lerobot/config_examples 데이터셋에 있습니다. 환경 및 학습 구성 파일을 작업 디렉터리로 다운로드하세요:

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

이 파일들은 아래 명령에서 사용되는 경로인 rl/env_config.json과 rl/train_config.json에 저장됩니다. 데모를 기록하려면 rl/env_config.json를 편집하세요:

1. 루트 레벨에서 mode를 "record"(으)로 설정합니다
2. dataset 섹션에서 데이터셋에 고유한 repo_id를 지정하세요 (예: “username/task_name”)
3. dataset 섹션에서 num_episodes_to_record를 수집하려는 데모의 수로 설정하세요
4. env.processor.image_preprocessing.crop_params_dict를 처음에는 {}로 설정합니다(크롭은 나중에 결정합니다).
5. env 섹션에서 env.robot, env.teleop 및 기타 하드웨어 설정을 구성합니다

예시 구성 섹션:

{
  "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"
}

원격 조작 장치 사용

로봇과 함께, 온라인 학습 중 개입을 수행하고 작업의 데이터셋을 수집하기 위해 로봇을 제어하는 텔레오퍼레이션 장치가 필요합니다. 게임패드, 키보드 또는 로봇의 리더 암을 사용하는 것을 지원합니다.

HIL-Serl은 로봇의 엔드 이펙터 공간에서 동작을 학습합니다. 따라서 텔레오퍼레이션은 엔드 이펙터의 x,y,z 변위를 제어합니다.

엔드 이펙터 변환은 env.processor.inverse_kinematics (InverseKinematicsConfig) 및 env.processor.gripper / env.processor.max_gripper_pos 아래에서 구성된 프로세서 파이프라인(InverseKinematicsRLStep, EEBoundsAndSafety, EEReferenceAndDelta, GripperVelocityToJoint)에 의해 적용됩니다. 엔드 이펙터 공간과 관련된 기본값은 다음과 같습니다:

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은 텔레오퍼레이션 장치를 정의합니다. 사용 가능한 텔레오퍼레이터 목록은 lerobot/teleoperators에서 확인할 수 있습니다.

게임패드 설정

게임패드는 로봇과 에피소드 상태를 제어하는 매우 편리한 방법을 제공합니다.

게임패드를 설정하려면 control_mode를 "gamepad"로 설정하고 구성 파일에 teleop 섹션을 정의해야 합니다.

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

로봇 제어 및 에피소드 관리를 위한 게임패드 버튼 매핑

SO101 리더 설정

SO101 리더 암은 감속 기어가 장착되어 있어 탐색 중에 팔을 움직이고 팔로워 암을 추적할 수 있습니다. 따라서 기어가 없는 SO100에 비해 제어 전환이 훨씬 부드럽습니다.

SO101 리더를 설정하려면 control_mode를 "leader"로 설정하고 구성 파일에 teleop 섹션을 정의해야 합니다.

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

에피소드의 성공/실패를 주석 처리하려면, 키보드를 사용하여 성공은 s, 실패는 esc 키를 눌러야 합니다. 온라인 학습 중에는 space 키를 눌러 정책을 직접 제어하고, 다시 space 키를 눌러 제어권을 정책으로 되돌립니다.

데모 기록

위에서 편집한 환경 구성을 사용하여 녹화 프로세스를 시작합니다:

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

녹화 중:

1. 로봇은 구성 파일에 정의된 초기 위치 env.processor.reset.fixed_reset_joint_positions로 리셋됩니다.
2. 작업을 성공적으로 완료하세요
3. 에피소드는 “success” 버튼을 누르면 보상 1로 종료됩니다
4. 시간 제한에 도달하거나 실패 버튼을 누르면 에피소드가 보상 0으로 종료됩니다
5. “rerecord” 버튼을 눌러 에피소드를 다시 녹화할 수 있습니다
6. 이 과정은 자동으로 다음 에피소드로 진행됩니다
7. 모든 에피소드를 기록한 후, 데이터셋은 Hugging Face Hub에 업로드(선택 사항)되고 로컬에 저장됩니다

데이터셋 처리

데모를 수집한 후, 최적의 카메라 크롭을 결정하도록 처리합니다. 강화 학습은 배경의 방해 요소에 민감하므로, 이미지를 관련 작업 영역으로 크롭하는 것이 중요합니다.

Visual RL 알고리즘은 픽셀 입력에서 직접 학습하므로, 관련 없는 시각 정보에 취약합니다. 조도 변화, 그림자, 이동하는 사람, 작업 공간 외부의 객체와 같은 배경 요소는 학습 과정을 혼란스럽게 할 수 있습니다. 좋은 ROI 선택은 다음과 같아야 합니다:

• 작업이 수행되는 필수 워크스페이스만 포함
• 로봇의 엔드 이펙터(end-effector)와 작업에 관여하는 모든 객체를 캡처합니다
• 불필요한 배경 요소와 주의 분산 요소를 제외

Note: 이미 crop 매개변수를 알고 있다면 이 단계를 건너뛰고 녹화 중 구성 파일에서 crop_params_dict만 설정하면 됩니다.

크롭 매개변수 결정

crop_dataset_roi.py 스크립트를 사용하여 카메라 이미지에서 관심 영역을 인터랙티브하게 선택합니다:

python -m lerobot.rl.crop_dataset_roi --repo-id username/pick_lift_cube

1. 각 카메라 뷰에 대해 스크립트는 첫 번째 프레임을 표시합니다
2. 관련 워크스페이스 영역을 사각형으로 표시
3. 선택을 확인하려면 ‘c’를 누르세요
4. 모든 카메라 뷰에 대해 반복합니다
5. …

예시 출력:

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

관심 영역을 선택하기 위한 인터랙티브 크롭 도구

설정 업데이트

학습 설정에 다음 crop 매개변수를 추가하세요:

{
  "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]
      }
    }
  }
}

권장 이미지 해상도

대부분의 비전 기반 정책은 128×128(기본값) 또는 64×64 픽셀의 정사각형 입력으로 검증되었습니다. 따라서 GPU 메모리와 대역폭을 절약해야 하는 경우 [64, 64]를, 그렇지 않은 경우 [128, 128]으로 resize_size 매개변수를 설정하는 것을 권장합니다. 다른 해상도도 가능하지만 광범위하게 테스트되지는 않았습니다.

보상 분류기 학습

보상 분류기는 보상 할당을 자동화하고 에피소드 성공을 자동으로 감지함으로써 HIL-SERL 워크플로에서 중요한 역할을 합니다. 모든 타임스텝마다 수동으로 보상 함수를 정의하거나 인간 피드백에 의존하는 대신, 보상 분류기는 시각적 관측으로부터 성공/실패를 예측하도록 학습합니다. 이를 통해 로봇의 카메라 입력을 기반으로 일관되고 자동화된 보상 신호를 제공하여 RL 알고리즘이 효율적으로 학습할 수 있게 합니다.

This guide explains how to train a reward classifier for human-in-the-loop reinforcement learning implementation of LeRobot. Reward classifiers learn to predict the reward value given a state which can be used in an RL setup to train a policy.

참고: 보상 분류기 학습은 선택 사항입니다. 게임패드 또는 키보드 장치를 사용하여 수동으로 성공을 주석 처리하여 RL 실험의 첫 라운드를 시작할 수 있습니다.

lerobot/rewards/classifier/modeling_classifier.py의 reward classifier 구현은 사전 학습된 비전 모델을 사용하여 이미지를 처리합니다. 성공/실패를 예측하는 이진 reward의 경우 단일 값을, 다중 클래스 설정의 경우 여러 값을 출력할 수 있습니다.

보상 분류기를 위한 데이터셋 수집

학습을 시작하기 전에 라벨이 지정된 예시로 구성된 데이터셋을 수집해야 합니다. 설정 파일에서 mode: "record"를 설정하고 gym_manipulator.py를 실행하면 관측값, 행동, 보상 데이터셋을 수집하는 프로세스가 활성화됩니다.

HILSerlRobotEnvConfig 기반의 환경 구성에서 일부 매개변수를 수정하여 데이터셋을 수집해야 합니다.

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

데이터 수집의 주요 매개변수

• mode: 루트 레벨에서 데이터셋을 수집하려면 "record"로 설정
• dataset.repo_id: "hf_username/dataset_name", 허브에 있는 데이터셋 및 저장소의 이름
• dataset.num_episodes_to_record: 기록할 에피소드 수
• env.processor.reset.terminate_on_success: 성공이 감지되면 에피소드를 자동으로 종료할지 여부 (기본값: true)
• env.fps: 기록할 초당 프레임 수
• dataset.push_to_hub: 데이터셋을 허브에 푸시할지 여부

env.processor.reset.terminate_on_success 매개변수를 사용하면 에피소드 종료 동작을 제어할 수 있습니다. false로 설정하면 성공이 감지된 후에도 에피소드가 계속 진행되어 reward=1 라벨을 가진 더 많은 긍정 예시를 수집할 수 있습니다. 이는 데이터셋에 성공 상태 예시를 더 많이 제공하므로 보상 분류기를 학습하는 데 중요합니다. true(기본값)로 설정하면 성공이 감지되는 즉시 에피소드가 종료됩니다.

중요: 보상 분류기 학습의 경우, 충분한 양의 긍정 예시를 수집하기 위해 terminate_on_success: false로 설정하세요. 일반적인 HIL-SERL 학습의 경우, 작업이 성공적으로 완료되면 에피소드가 자동으로 종료되도록 true로 유지하세요.

데이터 수집을 위한 예시 구성 섹션:

{
  "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"
}

보상 분류기 구성

보상 분류기는 lerobot/rewards/classifier/configuration_classifier.py를 사용하여 구성됩니다. 주요 매개변수는 다음과 같습니다:

• model_name: 기본 모델 아키텍처 (예: 주로 "helper2424/resnet10"을 사용합니다)
• model_type: "cnn" 또는 "transformer"
• num_cameras: 카메라 입력의 개수
• num_classes: 출력 클래스의 수 (이진 성공/실패의 경우 일반적으로 2)
• hidden_dim: 숨겨진 표현의 크기
• dropout_rate: 정규화 파라미터
• learning_rate: 옵티마이저의 학습률

보상 분류기 학습을 위한 예시 구성입니다. 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"
}

분류기 학습

분류기를 학습하려면 구성을 사용하여 train.py 스크립트를 사용하세요:

lerobot-train --config_path reward_classifier_train_config.json

모델 배포 및 테스트

학습한 보상 분류기를 사용하려면 HILSerlRobotEnvConfig를 해당 모델을 사용하도록 구성하세요:

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
)

또는 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
      }
    }
  }
}

gym_manipulator.py를 실행하여 모델을 테스트합니다.

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

리워드 분류기는 로봇 카메라의 시각적 입력을 기반으로 리워드를 자동으로 제공합니다.

보상 분류기 학습을 위한 예제 워크플로

1. 설정 파일 생성: 보상 분류기 및 환경을 위한 필요한 json 설정 파일인 위의 예시에서 가져온 reward_classifier_train_config.json과 다운로드한 rl/env_config.json을 생성합니다.

2. 데이터셋 수집:

   복사됨

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

3. 분류기 학습:

   복사됨

   lerobot-train --config_path reward_classifier_train_config.json

4. 분류기 테스트:

   복사됨

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

Actor-Learner를 사용한 학습

LeRobot 시스템은 학습을 위해 분산 actor-learner 아키텍처를 사용합니다. 이 아키텍처는 로봇 상호작용을 학습 프로세스와 분리하여, 서로를 차단하지 않고 동시에 실행되도록 합니다. actor 서버는 로봇의 관측과 행동을 처리하고 상호작용 데이터를 learner 서버로 전송합니다. learner 서버는 경사 하강법을 수행하고 주기적으로 actor의 정책 가중치를 업데이트합니다. learner와 actor, 두 프로세스를 시작해야 합니다.

구성 설정

이전에 다운로드한 학습 구성 파일 rl/train_config.json을 편집하세요 (예시는 여기에서 확인 가능합니다). 학습 구성은 lerobot/rl/train_rl.py의 TrainRLServerPipelineConfig 클래스를 기반으로 합니다.

1. 정책 설정(type="gaussian_actor", device 등)을 구성합니다
2. 상위 algorithm 블록 아래에서 알고리즘 설정을 구성합니다(type="sac", 학습률, 할인율 등은 lerobot/rl/algorithms/sac/configuration_sac.py에 정의되어 있습니다).
3. dataset을 자른 데이터세트로 설정하세요
4. crop 매개변수를 사용하여 환경 설정을 구성합니다
5. configuration_gaussian_actor.py에서 Gaussian Actor와 관련된 다른 매개변수를 확인하세요.
6. 작업에 맞는 input_features와 output_features가 포함된 policy 구성이 올바른지 확인하세요.

Learner 시작하기

먼저, learner 서버 프로세스를 시작합니다:

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

학습자:

• 정책 네트워크를 초기화합니다
• 리플레이 버퍼를 준비합니다
• gRPC 서버를 열어 액터와 통신합니다
• 전이(transition)를 처리하고 정책을 업데이트합니다

Actor 시작

별개의 터미널에서 동일한 구성으로 actor 프로세스를 시작합니다:

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

액터:

• gRPC를 통해 학습기에 연결합니다
• 환경을 초기화합니다
• policy의 rollouts를 실행하여 experience를 수집합니다
• 학습기로 전이를 전송합니다
• 업데이트된 정책 매개변수를 수신합니다

학습 흐름

학습이 자동으로 진행됩니다:

1. actor는 환경 내에서 정책을 실행합니다
2. Transitions는 수집되어 learner로 전송됩니다
3. 학습자는 이러한 전이를 기반으로 정책을 업데이트합니다
4. 업데이트된 정책 매개변수가 액터로 다시 전송됩니다
5. …

Human in the Loop

• 효율적인 학습의 핵심은 정책 학습과 탐색을 돕기 위해 교정 피드백을 제공하고 작업을 완료하는 데 인간 개입을 활용하는 것입니다.
• 인간 개입을 수행하려면 게임패드의 오른쪽 상단 트리거 버튼(또는 키보드의 space 키)을 누르세요. 그러면 정책 동작이 일시 중지되고 사용자가 직접 조작할 수 있습니다.
• 성공적인 실험은 인간이 시작 시점에 개입해야 하지만, 정책이 개선됨에 따라 개입 횟수가 줄어드는 실험입니다. Trackio 대시보드(trackio show --project <project>)에서 개입률을 모니터링할 수 있습니다.

시간에 따라 인간의 개입이 정책 학습을 어떻게 유도하는지 보여주는 예시

• 그림은 상호작용 단계에 따른 에피소드 보상의 그래프를 보여줍니다. 그림은 인간 개입이 정책 학습에 미치는 영향을 보여줍니다.
• 주황색 곡선은 어떤 인간 개입도 없는 실험을 나타냅니다. 분홍색과 파란색 곡선은 인간 개입이 있는 실험을 나타냅니다.
• 인간 개입이 존재할 때, 정책이 최대 보상을 달성하기 시작하는 단계 수가 4분의 1로 줄어든다는 것을 관찰할 수 있습니다.

모니터링 및 디버깅

구성에서 trackio.enable을 true(으)로 설정한 경우, Trackio 대시보드(trackio show --project <project>)를 통해 학습 진행 상황을 실시간으로 모니터링할 수 있습니다.

인간 개입 가이드

학습 과정은 개입 전략에 매우 민감합니다. 효과적인 개입 방법을 이해하려면 몇 번의 실행이 필요합니다. 몇 가지 팁과 힌트:

• 학습 시작 시 정책이 몇 에피소드 동안 탐색할 수 있도록 허용합니다.
• 오래 방치하지 마세요. 로봇의 동작이 궤도에서 벗어날 때 상황을 개입하여 동작을 수정하도록 하세요.
• 정책이 작업을 달성하기 시작하면, 완벽하지 않더라도 개입을 간단한 그립 명령과 같은 단순하고 빠른 동작으로 제한할 수 있습니다.

아래 그림과 같이, 이상적인 동작은 학습 과정에서 개입률이 점진적으로 감소하는 것입니다.

픽 앤 리프트 큐브 작업에서 학습 실행 중 개입률 플롯

조정할 주요 하이퍼파라미터

일부 구성 값은 학습 안정성과 속도에 불균형한 영향을 미칩니다:

• temperature_init (algorithm.temperature_init) – SAC의 초기 엔트로피 온도입니다. 값이 높을수록 탐색을 더 장려하고, 낮을수록 초기에 정책이 더 결정론적이 됩니다. 좋은 시작점은 1e-2입니다. 이 값을 너무 높게 설정하면 인간 개입이 비효율적이 되고 학습이 느려질 수 있음을 관찰했습니다.
• policy_parameters_push_frequency (policy.actor_learner_config.policy_parameters_push_frequency) – learner에서 actor로 두 번의 가중치 푸시 사이의 초 단위 간격입니다. 기본값은 4 s입니다. 더 최신의 가중치를 제공하려면 1-2 s로 줄이세요(네트워크 트래픽이 증가하는 대가로). 이 값은 샘플 효율성을 낮추므로, 연결이 느린 경우에만 늘리세요.
• storage_device (policy.storage_device) – learner가 정책 파라미터를 저장하는 장치입니다. 여유 GPU 메모리가 있다면 기본값인 "cpu" 대신 "cuda"로 설정하세요. 가중치를 GPU에 유지하면 CPU→GPU 전송 오버헤드가 제거되어 초당 learner 업데이트 횟수가 크게 증가할 수 있습니다.

축하합니다 🎉, 이 튜토리얼을 완료했습니다!

질문이 있거나 도움이 필요하시면 Discord로 문의해 주세요.

논문 인용:

@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}
}