Hugging Face's logo

LeRobot documentation

Panduan Alur Kerja Pelatihan Robot Nyata HIL-SERL

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Panduan Alur Kerja Pelatihan Robot Nyata HIL-SERL

Pada tutorial ini, Anda akan mengikuti alur kerja lengkap Human-in-the-Loop Sample-Efficient Reinforcement Learning (HIL-SERL) menggunakan LeRobot. Anda akan menguasai pelatihan kebijakan dengan RL pada robot sungguhan hanya dalam beberapa jam.

HIL-SERL adalah algoritma pembelajaran penguatan yang efisien sampel, yang menggabungkan demonstrasi manusia dengan pembelajaran online dan intervensi manusia. Pendekatan ini dimulai dari seperangkat kecil demonstrasi manusia, menggunakannya untuk melatih pengklasifikasi reward, dan kemudian menerapkan arsitektur actor-learner di mana manusia dapat melakukan intervensi selama eksekusi kebijakan untuk memandu eksplorasi dan mengoreksi perilaku yang tidak aman. Dalam tutorial ini, Anda akan menggunakan gamepad untuk memberikan intervensi dan mengontrol robot selama proses pembelajaran.

Ini menggabungkan tiga komponen utama:

  1. Demonstrasi offline & klasifikator reward: beberapa episode teleop manusia ditambah detektor keberhasilan berbasis visual memberikan titik awal yang telah dibentuk bagi kebijakan.

  2. Loop aktor / pembelajar di robot dengan intervensi manusia: pembelajar Soft Actor Critic (SAC) terdistribusi memperbarui kebijakan sementara aktor menjelajahi robot fisik; manusia dapat ikut campur kapan saja untuk mengoreksi perilaku yang berbahaya atau tidak produktif.

  3. Alat keselamatan & efisiensi: batas sendi/ujung-efektor (EE), prapemrosesan area kepentingan (ROI) yang dipotong, dan pemantauan Trackio menjaga agar data tetap berguna dan perangkat keras tetap aman.

Kombinasi elemen-elemen ini memungkinkan HIL-SERL mencapai tingkat keberhasilan tugas yang mendekati sempurna dan waktu siklus yang lebih cepat dibandingkan baseline yang hanya menggunakan imitasi.

HIL-SERL workflow

Alur kerja HIL-SERL, Luo et al. 2024

Panduan ini menyediakan instruksi langkah demi langkah untuk melatih kebijakan robot menggunakan implementasi HilSerl dari LeRobot untuk melatih pada robot nyata.

Apa yang saya butuhkan?

  • Gamepad (disarankan) atau keyboard untuk mengontrol robot
  • GPU Nvidia
  • Robot sungguhan dengan lengan pengikut dan pemimpin (opsional jika Anda menggunakan keyboard atau gamepad)
  • File URDF untuk robot untuk paket kinematika (periksa lerobot/model/kinematics.py)

Tugas apa saja yang bisa saya latih?

HIL-SERL dapat digunakan untuk melatih berbagai tugas manipulasi. Beberapa rekomendasi:

  • Mulai dengan tugas sederhana untuk memahami cara kerja sistem.
    • Dorong kubus ke area tujuan
    • Ambil dan angkat kubus dengan gripper
  • Hindari tugas dengan horizon yang sangat panjang. Fokus pada tugas yang dapat diselesaikan dalam 5-10 detik.
  • Setelah Anda memahami cara kerja sistem, Anda dapat mencoba tugas yang lebih kompleks dan horizon yang lebih panjang.
    • Ambil dan letakkan kubus
    • Tugas bimanual untuk mengambil objek dengan dua lengan
    • Tugas hand-over untuk memindahkan objek dari satu lengan ke lengan lainnya
    • Gila!

Install LeRobot dengan HIL-SERL

Untuk menginstal LeRobot dengan HIL-SERL, Anda perlu menginstal ekstra hilserl.

pip install -e ".[hilserl]"

Alur Kerja Pelatihan Robot Nyata

Memahami Konfigurasi

Proses pelatihan dimulai dengan konfigurasi yang tepat untuk lingkungan HILSERl. Kelas konfigurasi utama adalah GymManipulatorConfig di lerobot/rl/gym_manipulator.py, yang berisi HILSerlRobotEnvConfig bersarang (didefinisikan di lerobot/envs/configs.py) dan DatasetConfig. Konfigurasi ini diorganisasikan ke dalam sub-konfigurasi bersarang yang fokus:

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

Arsitektur Pipeline Processor

HIL-SERL menggunakan arsitektur pipeline prosesor modular yang memproses observasi dan aksi robot melalui serangkaian langkah yang dapat dikomposisikan. Pipeline ini dibagi menjadi dua komponen utama:

Pipeline Pemroses Lingkungan

Pemroses lingkungan (env_processor) menangani observasi yang masuk dan status lingkungan:

  1. VanillaObservationProcessorStep: Mengubah observasi robot mentah menjadi format standar
  2. JointVelocityProcessorStep (opsional): Menambahkan informasi kecepatan sendi ke observasi
  3. MotorCurrentProcessorStep (opsional): Menambahkan pembacaan arus motor ke observasi
  4. ForwardKinematicsJointsToEE (opsional): Menghitung pose end-effector dari posisi sendi
  5. ImageCropResizeProcessorStep (opsional): Memotong dan mengubah ukuran gambar kamera
  6. TimeLimitProcessorStep (opsional): Menegakkan batas waktu episode
  7. GripperPenaltyProcessorStep (opsional): Menerapkan penalti untuk penggunaan gripper yang tidak tepat
  8. RewardClassifierProcessorStep (opsional): Deteksi reward otomatis menggunakan model visi
  9. AddBatchDimensionProcessorStep: Mengonversi data ke format batch untuk pemrosesan jaringan saraf
  10. DeviceProcessorStep: Memindahkan data ke perangkat komputasi yang ditentukan (CPU/GPU)

Pipeline Pemroses Aksi

Prosesor aksi (action_processor) menangani aksi keluar dan intervensi manusia:

  1. AddTeleopActionAsComplimentaryDataStep: Mengambil aksi teleoperator untuk pencatatan
  2. AddTeleopEventsAsInfoStep: Mencatat peristiwa intervensi dan sinyal kontrol episode
  3. InterventionActionProcessorStep: Menangani intervensi manusia dan pengakhiran episode
  4. Inverse Kinematics Pipeline (ketika diaktifkan:
    • MapDeltaActionToRobotActionStep: Mengonversi aksi delta ke format aksi robot
    • EEReferenceAndDelta: Menghitung gerakan referensi dan delta ujung-efektor
    • EEBoundsAndSafety: Menegakkan batas keamanan ruang kerja
    • InverseKinematicsEEToJoints: Mengonversi aksi ujung-efektor menjadi target sendi
    • GripperVelocityToJoint: Menangani perintah kontrol gripper

Contoh Konfigurasi

Pemrosesan Pengamatan Dasar:

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

Pemrosesan Gambar:

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

Pengaturan Kinematika Invers:

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

Pemrosesan Observasi Lanjutan

Framework HIL-SERL mendukung fitur pemrosesan observasi tambahan yang dapat meningkatkan pembelajaran kebijakan:

Pemrosesan Kecepatan Gabungan

Aktifkan estimasi kecepatan bersama untuk memberikan informasi gerak kepada kebijakan:

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

Pemroses ini:

  • Mengestimasi kecepatan sendi menggunakan perbedaan terbatas antara pembacaan posisi sendi yang berurutan
  • Menambahkan informasi kecepatan ke vektor keadaan observasi
  • Berguna untuk kebijakan yang membutuhkan kesadaran gerak untuk tugas dinamis

Pemrosesan Arus Motor

Pantau arus motor untuk mendeteksi gaya kontak dan kondisi beban:

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

Pemroses ini:

  • Membaca nilai arus motor dari sistem kontrol robot
  • Menambahkan pengukuran saat ini ke vektor keadaan observasi
  • Membantu mendeteksi peristiwa kontak, berat objek, dan resistansi mekanis
  • Berguna untuk tugas manipulasi yang kaya kontak

Pemrosesan Observasi Gabungan

Anda dapat mengaktifkan beberapa fitur pemrosesan observasi secara bersamaan:

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

Catatan: Mengaktifkan fitur observasi tambahan meningkatkan dimensi ruang keadaan, yang mungkin memerlukan penyesuaian arsitektur jaringan kebijakan Anda dan pengumpulan data pelatihan yang lebih banyak.

Menemukan Batas Ruang Kerja Robot

Sebelum mengumpulkan demonstrasi, Anda perlu menentukan batas operasional yang tepat untuk robot Anda.

Hal ini membantu menyederhanakan masalah pembelajaran pada robot nyata dalam dua cara: 1) dengan membatasi ruang operasional robot ke wilayah tertentu yang menyelesaikan tugas dan menghindari eksplorasi yang tidak perlu atau tidak aman, dan 2) dengan memungkinkan pelatihan di ruang end-effector alih-alih ruang sendi. Secara empiris, pembelajaran di ruang sendi untuk reinforcement learning dalam manipulasi sering kali merupakan masalah yang lebih sulit - beberapa tugas hampir mustahil dipelajari di ruang sendi tetapi menjadi dapat dipelajari ketika ruang aksi ditransformasikan ke koordinat end-effector.

Menggunakan lerobot-find-joint-limits

Skrip ini membantu Anda menemukan batas operasional yang aman untuk end-effector robot Anda. Mengingat Anda memiliki lengan pengikut (follower) dan pemimpin (leader), Anda dapat menggunakan skrip ini untuk menemukan batas untuk lengan pengikut yang akan diterapkan selama pelatihan. Membatasi ruang aksi akan mengurangi eksplorasi yang redundan dari agen dan menjamin keselamatan.

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 wajib diisi: parameter ini menunjuk ke file URDF robot Anda, yang digunakan oleh skrip untuk menghitung posisi end-effector. Untuk SO-100/SO-101, clone repo SO-ARM100 dengan git clone https://github.com/TheRobotStudio/SO-ARM100.git; file URDF kemudian berada di SO-ARM100/Simulation/SO101/so101_new_calib.urdf.

Alur kerja

  1. Jalankan skrip dan gerakkan robot melalui ruang yang menyelesaikan tugas

  2. Skrip akan merekam posisi ujung efektor minimum dan maksimum serta sudut sendi, lalu mencetaknya ke konsol, misalnya:

    # 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. Gunakan nilai-nilai ini dalam konfigurasi lingkungan Anda di bawah env.processor.inverse_kinematics.end_effector_bounds (lihat InverseKinematicsConfig di lerobot/envs/configs.py)

Konfigurasi Contoh

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

Mengumpulkan Demonstrasi

Dengan batas yang telah didefinisikan, Anda dapat dengan aman mengumpulkan demonstrasi untuk pelatihan. Pelatihan RL dengan algoritma off-policy memungkinkan kita untuk menggunakan dataset offline yang dikumpulkan guna meningkatkan efisiensi proses pembelajaran.

Mengatur Mode Rekam

File konfigurasi contoh untuk panduan ini ada di dataset lerobot/config_examples di Hub. Unduh konfigurasi lingkungan dan pelatihan ke direktori kerja Anda:

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

Ini menyimpannya ke rl/env_config.json dan rl/train_config.json, jalur yang digunakan dalam perintah di bawah. Edit rl/env_config.json untuk merekam demonstrasi:

  1. Setel mode ke "record" di level akar
  2. Tentukan repo_id yang unik untuk dataset Anda di bagian dataset (misalnya, “username/task_name”)
  3. Set num_episodes_to_record di bagian dataset ke jumlah demonstrasi yang ingin Anda kumpulkan
  4. Set env.processor.image_preprocessing.crop_params_dict ke {} pada awalnya (kami akan menentukan crops nanti)
  5. Konfigurasikan env.robot, env.teleop, dan pengaturan perangkat keras lainnya di bagian env

Bagian konfigurasi contoh:

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

Menggunakan Perangkat Teleoperasi

Bersama dengan robot Anda, Anda akan memerlukan perangkat teleoperasi untuk mengendalikannya guna mengumpulkan dataset tugas Anda dan melakukan intervensi selama pelatihan online. Kami mendukung penggunaan gamepad atau keyboard atau lengan pemimpin dari robot.

HIL-Serl mempelajari aksi dalam ruang ujung-efektor robot. Oleh karena itu, teleoperasi akan mengontrol perpindahan x,y,z dari ujung-efektor.

Transformasi end-effector diterapkan oleh pipeline prosesor (InverseKinematicsRLStep, EEBoundsAndSafety, EEReferenceAndDelta, GripperVelocityToJoint) yang dikonfigurasi di bawah env.processor.inverse_kinematics (InverseKinematicsConfig) dan env.processor.gripper / env.processor.max_gripper_pos. Nilai default yang terkait dengan ruang end-effector adalah:

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 mendefinisikan perangkat teleoperasi. Anda dapat memeriksa daftar teleoperator yang tersedia di lerobot/teleoperators.

Mengatur Gamepad

Gamepad menyediakan cara yang sangat nyaman untuk mengontrol robot dan status episode.

Untuk mengatur gamepad, Anda perlu mengatur control_mode menjadi "gamepad" dan mendefinisikan bagian teleop dalam file konfigurasi.

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

Figure shows the control mappings on a Logitech gamepad.

Pemetaan tombol gamepad untuk pengendalian robot dan manajemen episode

Mengatur leader SO101

Lengan pemimpin SO101 memiliki roda gigi yang dikurangi sehingga memungkinkan lengan tersebut bergerak dan melacak lengan pengikut selama eksplorasi. Oleh karena itu, proses pengambilalihan jauh lebih mulus dibandingkan SO100 yang tanpa roda gigi.

Untuk mengatur leader SO101, Anda perlu mengatur control_mode menjadi "leader" dan mendefinisikan bagian teleop dalam file konfigurasi.

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

Untuk menandai keberhasilan/gagalnya episode, Anda perlu menggunakan keyboard untuk menekan s untuk keberhasilan, esc untuk kegagalan. Selama pelatihan online, tekan space untuk mengambil alih kebijakan dan space lagi untuk mengembalikan kendali kepada kebijakan.

Video: SO101 leader teleoperation

Contoh teleoperasi pemimpin SO101, pemimpin melacak pengikut, tekan `space` untuk campur tangan

Merekam Demonstrasi

Mulai proses perekaman dengan konfigurasi lingkungan yang Anda edit di atas:

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

Selama perekaman:

  1. Robot akan direset ke posisi awal yang didefinisikan dalam file konfigurasi env.processor.reset.fixed_reset_joint_positions
  2. Selesaikan tugas dengan sukses
  3. Episode berakhir dengan reward sebesar 1 saat Anda menekan tombol “success”
  4. Jika batas waktu tercapai, atau tombol gagal ditekan, episode berakhir dengan reward 0
  5. Anda dapat merekam ulang episode dengan menekan tombol “rerecord”
  6. Proses ini secara otomatis berlanjut ke episode berikutnya
  7. Setelah semua episode direkam, dataset didorong ke Hugging Face Hub (opsional) dan disimpan secara lokal

Memproses Dataset

Setelah mengumpulkan demonstrasi, proseslah data tersebut untuk menentukan crop kamera yang optimal. Pembelajaran penguatan sangat sensitif terhadap gangguan latar belakang, sehingga penting untuk memotong gambar ke area ruang kerja yang relevan.

Algoritma RL visual belajar langsung dari input piksel, sehingga rentan terhadap informasi visual yang tidak relevan. Elemen latar belakang seperti pencahayaan yang berubah, bayangan, orang yang bergerak, atau objek di luar area kerja dapat membingungkan proses pembelajaran. Pemilihan ROI yang baik harus:

  • Sertakan hanya ruang kerja esensial tempat tugas dilakukan
  • Ambil end-effector robot dan semua objek yang terlibat dalam tugas
  • Hilangkan elemen latar belakang yang tidak perlu dan gangguan

Catatan: Jika Anda sudah mengetahui parameter crop, Anda dapat melewati langkah ini dan langsung mengatur crop_params_dict di file konfigurasi saat perekaman.

Menentukan Parameter Crop

Gunakan skrip crop_dataset_roi.py untuk memilih area kepentingan secara interaktif pada gambar kamera Anda:

python -m lerobot.rl.crop_dataset_roi --repo-id username/pick_lift_cube
  1. Untuk setiap tampilan kamera, skrip akan menampilkan bingkai pertama
  2. Gambarkan persegi panjang di sekitar area workspace yang relevan
  3. Tekan ‘c’ untuk mengonfirmasi pilihan
  4. Ulangi untuk semua tampilan kamera
  5. Skrip ini mengoutputkan parameter pemotongan dan membuat dataset baru yang sudah dipotong

Contoh keluaran:

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

Alat pemotongan interaktif untuk memilih area yang diminati

Memperbarui Konfigurasi

Tambahkan parameter crop ini ke konfigurasi pelatihan Anda:

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

Resolusi gambar yang direkomendasikan

Sebagian besar kebijakan berbasis visi telah divalidasi pada input persegi berukuran 128×128 (default) atau 64×64 piksel. Oleh karena itu, kami menyarankan untuk mengatur parameter resize_size menjadi [128, 128] – atau [64, 64] jika Anda perlu menghemat memori dan bandwidth GPU. Resolusi lain dimungkinkan tetapi belum diuji secara luas.

Melatih Pengklasifikasi Reward

Klasifikator reward memainkan peran penting dalam alur kerja HIL-SERL dengan mengotomatisasi penugasan reward dan mendeteksi keberhasilan episode secara otomatis. Alih-alih mendefinisikan fungsi reward secara manual atau mengandalkan umpan balik manusia untuk setiap langkah waktu, klasifikator reward belajar memprediksi keberhasilan/gagal dari pengamatan visual. Hal ini memungkinkan algoritma RL untuk belajar secara efisien dengan menyediakan sinyal reward yang konsisten dan otomatis berdasarkan masukan kamera robot.

Panduan ini menjelaskan cara melatih pengklasifikasi reward untuk implementasi reinforcement learning dengan human-in-the-loop di LeRobot. Pengklasifikasi reward belajar memprediksi nilai reward berdasarkan state, yang dapat digunakan dalam setup RL untuk melatih policy.

Catatan: Melatih pengklasifikasi reward bersifat opsional. Anda dapat memulai putaran pertama eksperimen RL dengan meng anotasi keberhasilan secara manual menggunakan perangkat gamepad atau keyboard Anda.

Implementasi reward classifier di lerobot/rewards/classifier/modeling_classifier.py menggunakan model visi pretrained untuk memproses gambar. Model ini dapat menghasilkan satu nilai untuk reward biner guna memprediksi kasus sukses/gagal, atau beberapa nilai untuk pengaturan multi-kelas.

Mengumpulkan Dataset untuk klasifikator reward

Sebelum pelatihan, Anda perlu mengumpulkan dataset dengan contoh berlabel. Mengatur mode: "record" di konfigurasi Anda dan menjalankan gym_manipulator.py mengaktifkan proses pengumpulan dataset observasi, aksi, dan reward.

Untuk mengumpulkan dataset, Anda perlu memodifikasi beberapa parameter dalam konfigurasi lingkungan berdasarkan HILSerlRobotEnvConfig.

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

Parameter Utama untuk Pengumpulan Data

  • mode: atur menjadi "record" untuk mengumpulkan dataset (di level root)
  • dataset.repo_id: "hf_username/dataset_name", nama dataset dan repo di hub
  • dataset.num_episodes_to_record: Jumlah episode yang akan direkam
  • env.processor.reset.terminate_on_success: Apakah episode akan diakhiri secara otomatis ketika keberhasilan terdeteksi (default: true)
  • env.fps: Jumlah frame per detik untuk direkam
  • dataset.push_to_hub: Apakah dataset akan didorong ke hub

Parameter env.processor.reset.terminate_on_success memungkinkan Anda untuk mengontrol perilaku terminasi episode. Ketika diatur ke false, episode akan terus berjalan bahkan setelah keberhasilan terdeteksi, sehingga Anda dapat mengumpulkan lebih banyak contoh positif dengan label reward=1. Hal ini sangat penting untuk melatih klasifikator reward karena menyediakan lebih banyak contoh keadaan sukses dalam dataset Anda. Ketika diatur ke true (default), episode akan berakhir segera setelah keberhasilan terdeteksi.

Penting: Untuk pelatihan reward classifier, atur terminate_on_success: false untuk mengumpulkan contoh positif yang cukup. Untuk pelatihan HIL-SERL reguler, biarkan sebagai true untuk mengaktifkan terminasi episode otomatis ketika tugas berhasil diselesaikan.

Bagian konfigurasi contoh untuk pengumpulan data:

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

Konfigurasi Klasifikator Reward

Klasifikator reward dikonfigurasi menggunakan lerobot/rewards/classifier/configuration_classifier.py. Berikut adalah parameter utamanya:

  • model_name: Arsitektur model dasar (misalnya, kami terutama menggunakan "helper2424/resnet10")
  • model_type: "cnn" atau "transformer"
  • num_cameras: Jumlah input kamera
  • num_classes: Jumlah kelas output (biasanya 2 untuk keberhasilan/kegagalan biner)
  • hidden_dim: Ukuran representasi tersembunyi
  • dropout_rate: Parameter regularisasi
  • learning_rate: Laju pembelajaran untuk optimizer

Contoh konfigurasi untuk melatih reward classifier. Simpan sebagai 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"
}

Melatih Klasifikator

Untuk melatih klasifikator, gunakan skrip train.py dengan konfigurasi Anda:

lerobot-train --config_path reward_classifier_train_config.json

Men-deploy dan Menguji Model

Untuk menggunakan klasifikator reward yang telah Anda latih, konfigurasikan HILSerlRobotEnvConfig untuk menggunakan model Anda:

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
)

atau setel argumen dalam file konfigurasi 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
      }
    }
  }
}

Jalankan gym_manipulator.py untuk menguji model.

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

Klasifikator hadiah akan secara otomatis memberikan hadiah berdasarkan masukan visual dari kamera robot.

Alur Kerja Contoh untuk melatih klasifikator reward

  1. Buat file konfigurasi: Buat file konfigurasi json yang diperlukan untuk reward classifier dan lingkungan: reward_classifier_train_config.json dari contoh di atas, dan rl/env_config.json yang telah diunduh.

  2. Kumpulkan dataset:

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

  3. Latih klasifikator:

    lerobot-train --config_path reward_classifier_train_config.json

  4. Uji klasifikator:

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

Pelatihan dengan Actor-Learner

Sistem LeRobot menggunakan arsitektur actor-learner terdistribusi untuk pelatihan. Arsitektur ini memisahkan interaksi robot dari proses pembelajaran, sehingga keduanya dapat berjalan secara bersamaan tanpa saling memblokir. Server actor menangani observasi dan aksi robot, lalu mengirimkan data interaksi ke server learner. Server learner melakukan penurunan gradien dan secara berkala memperbarui bobot kebijakan actor. Anda perlu memulai dua proses: learner dan actor.

Penyiapan Konfigurasi

Edit file konfigurasi pelatihan yang Anda unduh sebelumnya, rl/train_config.json (contoh tersedia di sini). Konfigurasi pelatihan ini didasarkan pada kelas utama TrainRLServerPipelineConfig di lerobot/rl/train_rl.py.

  1. Konfigurasikan pengaturan kebijakan (type="gaussian_actor", device, dll.)
  2. Konfigurasikan pengaturan algoritma di bawah blok algorithm tingkat atas (type="sac", learning rate, discount, dll., yang didefinisikan di lerobot/rl/algorithms/sac/configuration_sac.py).
  3. Set dataset ke dataset yang sudah dipotong
  4. Konfigurasi pengaturan lingkungan dengan parameter crop
  5. Periksa parameter lain yang terkait dengan Gaussian Actor di configuration_gaussian_actor.py.
  6. Verifikasi bahwa konfigurasi policy benar dengan input_features dan output_features yang tepat untuk tugas Anda.

Memulai Learner

Pertama, mulai proses server learner:

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

Pembelajar:

  • Menginisialisasi jaringan kebijakan
  • Menyiapkan buffer replay
  • Membuka server gRPC untuk berkomunikasi dengan aktor
  • Memproses transisi dan memperbarui kebijakan

Memulai Actor

Di terminal terpisah, jalankan proses actor dengan konfigurasi yang sama:

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

Aktor:

  • Menghubungkan ke learner melalui gRPC
  • Menginisialisasi lingkungan
  • Jalankan rollout dari kebijakan untuk mengumpulkan pengalaman
  • Mengirim transisi ke learner
  • Menerima parameter kebijakan yang diperbarui

Alur Pelatihan

Pelatihan berjalan secara otomatis:

  1. Actor mengeksekusi kebijakan di lingkungan
  2. Transisi dikumpulkan dan dikirim ke learner
  3. Learner memperbarui kebijakan berdasarkan transisi-transisi ini
  4. Parameter kebijakan yang diperbarui dikirim kembali ke aktor
  5. Proses berlanjut hingga batas langkah yang ditentukan tercapai

Manusia dalam Loop

  • Kunci untuk belajar secara efisien adalah adanya intervensi manusia untuk memberikan umpan balik korektif dan menyelesaikan tugas guna membantu pembelajaran kebijakan dan eksplorasi.
  • Untuk melakukan intervensi manusia, Anda dapat menekan tombol trigger kanan atas pada gamepad (atau tombol space pada keyboard). Hal ini akan menjeda aksi kebijakan dan memungkinkan Anda mengambil alih kendali.
  • Eksperimen yang berhasil adalah eksperimen di mana manusia harus melakukan intervensi di awal, namun kemudian mengurangi jumlah intervensi seiring dengan meningkatnya kinerja kebijakan. Anda dapat memantau tingkat intervensi di dasbor Trackio (trackio show --project <project>).

Figure shows the control mappings on a Logitech gamepad.

Contoh yang menunjukkan bagaimana intervensi manusia membantu memandu pembelajaran kebijakan seiring waktu

  • Gambar menunjukkan plot reward episodik terhadap langkah interaksi. Gambar menunjukkan efek intervensi manusia pada pembelajaran kebijakan.
  • Kurva oranye adalah eksperimen tanpa intervensi manusia. Sementara itu, kurva merah muda dan biru adalah eksperimen dengan intervensi manusia.
  • Kita dapat mengamati bahwa jumlah langkah di mana kebijakan mulai mencapai imbalan maksimum berkurang seperempat ketika intervensi manusia hadir.

Memantau dan Men-debug

Jika Anda telah mengatur trackio.enable menjadi true dalam konfigurasi Anda, Anda dapat memantau kemajuan pelatihan secara real-time melalui dasbor Trackio (trackio show --project <project>).

Panduan Intervensi Manusia

Proses pembelajaran sangat sensitif terhadap strategi intervensi. Diperlukan beberapa kali eksekusi untuk memahami cara melakukan intervensi secara efektif. Beberapa tips dan petunjuk:

  • Izikan kebijakan untuk mengeksplorasi selama beberapa episode di awal pelatihan.
  • Hindari intervensi dalam jangka waktu yang lama. Cobalah untuk melakukan intervensi dalam situasi tertentu untuk mengoreksi perilaku robot ketika ia menyimpang dari jalur yang benar.
  • Setelah kebijakan mulai berhasil menyelesaikan tugas, meskipun belum sempurna, Anda dapat membatasi intervensi Anda menjadi tindakan cepat dan sederhana seperti perintah menggenggam yang sederhana.

Perilaku idealnya adalah tingkat intervensi Anda harus menurun secara bertahap selama pelatihan, seperti yang ditunjukkan pada gambar di bawah.

Intervention rate

Grafik laju intervensi selama proses pelatihan pada tugas mengambil dan mengangkat kubus

Hyperparameter utama untuk disetel

Beberapa nilai konfigurasi memiliki dampak yang tidak proporsional terhadap stabilitas dan kecepatan pelatihan:

  • temperature_init (algorithm.temperature_init) – suhu entropi awal dalam SAC. Nilai yang lebih tinggi mendorong eksplorasi lebih banyak; nilai yang lebih rendah membuat kebijakan lebih deterministik di awal. Titik awal yang baik adalah 1e-2. Kami mengamati bahwa menyetelnya terlalu tinggi dapat membuat intervensi manusia tidak efektif dan memperlambat pembelajaran.
  • policy_parameters_push_frequency (policy.actor_learner_config.policy_parameters_push_frequency) – interval dalam detik antara dua pendorongan bobot dari learner ke actor. Nilainya secara default adalah 4 s. Turunkan menjadi 1-2 s untuk menyediakan bobot yang lebih segar (dengan biaya lalu lintas jaringan yang lebih besar); naikkan hanya jika koneksi Anda lambat, karena hal ini akan mengurangi efisiensi sampel.
  • storage_device (policy.storage_device) – perangkat tempat learner menyimpan parameter kebijakan. Jika Anda memiliki memori GPU yang tersedia, atur ini ke "cuda" (bukan default "cpu"). Menyimpan bobot di GPU menghilangkan overhead transfer CPU→GPU dan dapat secara signifikan meningkatkan jumlah pembaruan learner per detik.

Selamat 🎉, Anda telah menyelesaikan tutorial ini!

Jika Anda memiliki pertanyaan atau membutuhkan bantuan, silakan hubungi kami di Discord.

Sitasi paper:

@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

←Bawa Perangkat Keras Anda Sendiri Latih RL dalam Simulasi→