Hugging Face's logo

LeRobot documentation

HIL-SERL Gerçek Robot Eğitim İş Akışı Kılavuzu

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v0.7.0).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

HIL-SERL Gerçek Robot Eğitim İş Akışı Kılavuzu

Bu eğitimde, LeRobot kullanarak tam Human-in-the-Loop Sample-Efficient Reinforcement Learning (HIL-SERL) iş akışını adım adım inceleyeceksiniz. Birkaç saat içinde gerçek bir robot üzerinde RL ile politika eğitimi yapmayı öğreneceksiniz.

HIL-SERL, insan gösterimlerini çevrimiçi öğrenme ve insan müdahaleleriyle birleştiren örnek verimli bir pekiştirmeli öğrenme algoritmasıdır. Yaklaşım, küçük bir insan gösterimi kümesinden başlar, bunları bir ödül sınıflandırıcısı eğitmek için kullanır ve ardından insanların politika yürütme sırasında müdahale ederek keşfi yönlendirmesine ve güvensiz davranışları düzeltmesine olanak tanıyan bir aktör-öğrenici mimarisini devreye alır. Bu öğreticide, öğrenme süreci sırasında müdahalelerde bulunmak ve robotu kontrol etmek için bir oyun kolu kullanacaksınız.

Üç temel bileşeni bir araya getirir:

  1. Çevrimdışı gösterimler ve ödül sınıflandırıcısı: Birkaç insan teleop epizodu ve görü tabanlı bir başarı algılayıcı, politika için şekillendirilmiş bir başlangıç noktası sağlar.

  2. İnsan müdahaleleriyle robot üzerinde aktör/öğrenici döngüsü: dağıtık Soft Actor Critic (SAC) öğrenicisi politika güncellerken aktör fiziksel robot üzerinde keşif yapar; insan, tehlikeli veya verimsiz davranışları düzeltmek için her an devreye girebilir.

  3. Güvenlik ve verimlilik araçları: eklem/son uç (EE) sınırları, kırpma ilgi alanı (ROI) ön işleme ve Trackio izleme, verilerin kullanılabilir kalmasını ve donanımın güvenli olmasını sağlar.

Bu unsurlar birlikte, HIL-SERL'in yalnızca taklitle öğrenme tabanlı yöntemlere göre neredeyse mükemmel görev başarısına ve daha hızlı döngü sürelerine ulaşmasını sağlar.

HIL-SERL workflow

HIL-SERL iş akışı, Luo ve ark. 2024

Bu kılavuz, gerçek bir robot üzerinde eğitim yapmak için LeRobot’un HilSerl uygulamasını kullanan bir robot politikası eğitmek için adım adım talimatlar sağlar.

Neye ihtiyacım var?

  • Robotu kontrol etmek için bir oyun kolu (önerilen) veya klavye
  • Bir Nvidia GPU
  • Bir takipçi ve lider kolu olan gerçek bir robot (klavye veya oyun kolu kullanıyorsanız isteğe bağlıdır)
  • Kine matik paketi için robotun URDF dosyası (lerobot/model/kinematics.py dosyasını kontrol edin)

Hangi tür görevleri eğitebilirim?

HIL-SERL, çeşitli manipülasyon görevlerinde eğitim için kullanılabilir. Bazı öneriler:

  • Sistemin nasıl çalıştığını anlamak için basit bir görevle başlayın.
    • Küpü hedef bölgeye itin
    • Küpü kavrayıcıyla seç ve kaldır
  • Aşırı uzun ufuklu görevlerden kaçının. 5-10 saniyede tamamlanabilen görevlere odaklanın.
  • Sistemin nasıl çalıştığını iyi anladıktan sonra, daha karmaşık görevleri ve daha uzun zaman ufuklarını deneyebilirsiniz.
    • Küpü seç ve yerleştir
    • İki kolla nesneleri almak için çift elle görevler
    • Nesneleri bir koldan diğerine aktarmak için devir görevleri
    • Abartıya kaç!

LeRobot'u HIL-SERL ile yükleyin

LeRobot'u HIL-SERL ile kurmak için hilserl ekini kurmanız gerekir.

pip install -e ".[hilserl]"

Gerçek Robot Eğitim İş Akışı

Yapılandırmayı Anlama

Eğitim süreci, HILSERl ortamı için uygun yapılandırma ile başlar. Ana yapılandırma sınıfı, iç içe geçmiş HILSerlRobotEnvConfig (lerobot/envs/configs.py içinde tanımlı) ve DatasetConfig içeren lerobot/rl/gym_manipulator.py dosyasındaki GymManipulatorConfig'dir. Yapılandırma, odaklanmış iç içe alt yapılandırmalar halinde düzenlenmiştir:

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

İşleyici Hattı Mimarisi

HIL-SERL, robot gözlemlerini ve eylemlerini bir deri birleştirilebilir adım üzerinden işleyen modüler bir işlemci hattı mimarisi kullanır. Hat, iki ana bileşene ayrılmıştır:

Ortam İşleyici Hattı

Ortam işleyicisi (env_processor) gelen gözlemleri ve ortam durumunu işler:

  1. VanillaObservationProcessorStep: Ham robot gözlemlerini standartlaştırılmış biçime dönüştürür
  2. JointVelocityProcessorStep (isteğe bağlı): Gözlemlere eklem hızı bilgisi ekler
  3. MotorCurrentProcessorStep (isteğe bağlı): Gözlemlere motor akım okumalarını ekler
  4. ForwardKinematicsJointsToEE (isteğe bağlı): Eklem konumlarından uç efektor duruşunu hesaplar
  5. ImageCropResizeProcessorStep (isteğe bağlı): Kamera görüntülerini kırpıp yeniden boyutlandırır
  6. TimeLimitProcessorStep (isteğe bağlı): Bölüm süre sınırlarını uygular
  7. GripperPenaltyProcessorStep (isteğe bağlı): Uygun olmayan gripper kullanımına ceza uygular
  8. RewardClassifierProcessorStep (isteğe bağlı): Görüntü modelleri kullanılarak otomatik ödül algılama
  9. AddBatchDimensionProcessorStep: Verileri sinir ağı işleme için toplu (batch) formata dönüştürür
  10. DeviceProcessorStep: Verileri belirtilen hesaplama cihazına (CPU/GPU) taşır

Eylem İşleyici Hattı

Eylem işleyicisi (action_processor) giden eylemleri ve insan müdahalelerini yönetir:

  1. AddTeleopActionAsComplimentaryDataStep: Kayıt için teleoperatör eylemlerini yakalar
  2. AddTeleopEventsAsInfoStep: Müdahale olaylarını ve bölüm kontrol sinyallerini kaydeder
  3. InterventionActionProcessorStep: İnsan müdahalelerini ve bölüm sonlandırmasını işler
  4. Inverse Kinematics Pipeline (etkinleştirildiğinde):
    • MapDeltaActionToRobotActionStep: Delta eylemlerini robot eylemi biçimine dönüştürür
    • EEReferenceAndDelta: Uç efektor referans ve delta hareketlerini hesaplar
    • EEBoundsAndSafety: Çalışma alanı güvenlik sınırlarını uygular
    • InverseKinematicsEEToJoints: Son uç eylemlerini eklem hedeflerine dönüştürür
    • GripperVelocityToJoint: Gripper kontrol komutlarını işler

Yapılandırma Örnekleri

Temel Gözlem İşleme:

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

Görüntü İşleme:

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

Ters Kinetik Kurulumu:

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

Gelişmiş Gözlem İşleme

HIL-SERL çerçevesi, politika öğrenmesini iyileştirebilecek ek gözlem işleme özelliklerini destekler:

Ortak Hız İşleme

Politikaya hareket bilgisi sağlamak için ortak hız tahminini etkinleştirin:

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

Bu işlemci:

  • Art arda gelen eklem konumu okumaları arasındaki sonlu farkları kullanarak eklem hızlarını tahmin eder
  • Gözlem durum vektörüne hız bilgisi ekler
  • Dinamik görevler için hareket farkındalığı gerektiren politikalar için faydalı

Motor Akım İşleme

Temas kuvvetlerini ve yük koşullarını tespit etmek için motor akımlarını izleyin:

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

Bu işlemci:

  • Robotun kontrol sisteminden motor akım değerlerini okur
  • Gözlem durum vektörüne mevcut ölçümleri ekler
  • Temas olaylarını, nesne ağırlıklarını ve mekanik direnci tespit etmeye yardımcı olur
  • Temas yoğun manipülasyon görevleri için faydalı

Birleşik Gözlem İşleme

Birden fazla gözlem işleme özelliğini aynı anda etkinleştirebilirsiniz:

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

Not: Ek gözlem özelliklerinin etkinleştirilmesi durum uzayı boyutunu artırır; bu da politika ağı mimarinizin ayarlanmasını ve potansiyel olarak daha fazla eğitim verisi toplanmasını gerektirebilir.

Robot Çalışma Alanı Sınırlarını Bulma

Gösterimlerin toplanmasından önce, robotunuz için uygun çalışma sınırlarını belirlemeniz gerekir.

Bu, gerçek robot üzerinde öğrenme problemini iki şekilde basitleştirmeye yardımcı olur: 1) robotun çalışma alanını, görevi çözen ve gereksiz veya güvensiz keşifleri önleyen belirli bir bölgeyle sınırlayarak ve 2) eklemler uzayı yerine uç efektor uzayında eğitim yapmaya olanak tanıyarak. Deneysel olarak, manipülasyonda pekiştirmeli öğrenme için eklemler uzayında öğrenme genellikle daha zor bir problemdir - bazı görevler eklemler uzayında öğrenilmesi neredeyse imkânsızken, eylem uzayı uç efektor koordinatlarına dönüştürüldüğünde öğrenilebilir hale gelir.

lerobot-find-joint-limits kullanımı

Bu betik, robotunuzun uç efektoru için güvenli çalışma sınırlarını bulmanıza yardımcı olur. Bir takipçi ve bir lider kola sahip olduğunuzda, bu betiği eğitim sırasında uygulanacak takipçi kol sınırlarını bulmak için kullanabilirsiniz. Eylem uzayını sınırlamak, ajanın gereksiz keşif faaliyetlerini azaltır ve güvenliği garanti eder.

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 zorunludur: robotunuzun URDF dosyasına işaret eder ve betik, uç efektor konumunu hesaplamak için bu dosyayı kullanır. SO-100/SO-101 için SO-ARM100 deposunu git clone https://github.com/TheRobotStudio/SO-ARM100.git ile klonlayın; URDF dosyası daha sonra SO-ARM100/Simulation/SO101/so101_new_calib.urdf konumunda bulunur.

İş akışı

  1. Betik çalıştırın ve robotu, görevi çözen alanda hareket ettirin

  2. Betik, uç eleman konumlarının minimum ve maksimum değerlerini ile eklem açılarını kaydeder ve bunları konsola yazdırır, örneğin:

    # 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. Bu değerleri, lerobot/envs/configs.py içindeki InverseKinematicsConfig (bkz.) altında, env.processor.inverse_kinematics.end_effector_bounds konumundaki ortam yapılandırmanızda kullanın.

Örnek Yapılandırma

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

Gösterimlerin Toplanması

Sınırlar tanımlandığına göre, eğitim için gösterimleri güvenle toplayabilirsiniz. RL eğitimini off-policy algoritma ile yapmak, öğrenme sürecinin verimliliğini artırmak amacıyla toplanan çevrimdışı veri setlerini kullanmamızı sağlar.

Kayıt Modunun Yapılandırılması

Bu kılavuz için örnek yapılandırma dosyaları, Hub'daki lerobot/config_examples veri setinde yer alır. Ortam ve eğitim yapılandırmalarını çalışma dizininize indirin:

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

Bunlar, aşağıdaki komutlarda kullanılan yollar olan rl/env_config.json ve rl/train_config.json dosyalarına kaydedilir. Demoları kaydetmek için rl/env_config.json dosyasını düzenleyin:

  1. Kök seviyede mode değerini "record" olarak ayarlayın
  2. dataset bölümünde veri setiniz için benzersiz bir repo_id belirtin (ör. “username/task_name”)
  3. dataset bölümünde num_episodes_to_record değerini toplamak istediğiniz gösterim sayısına ayarlayın
  4. Başlangıçta env.processor.image_preprocessing.crop_params_dict değerini {} olarak ayarlayın (kesim alanları daha sonra belirlenecek).
  5. env bölümünde env.robot, env.teleop ve diğer donanım ayarlarını yapılandırın

Örnek yapılandırma bölümü:

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

Teleoperasyon Cihazı Kullanma

Robotunuzla birlikte, görevinize ait veri setlerini toplamak ve çevrimiçi eğitim sırasında müdahalelerde bulunmak için robotu kontrol etmek üzere bir teleoperasyon cihazına ihtiyacınız olacaktır. Oyun kolu, klavye veya robotun lider kolunu kullanmanızı destekliyoruz.

HIL-Serl, robotun uç efektor (end-effector) uzayında eylemleri öğrenir. Bu nedenle, teleoperasyon uç efektörün x, y, z yer değiştirmelerini kontrol eder.

Uç efektor dönüşümü, env.processor.inverse_kinematics (InverseKinematicsConfig) ve env.processor.gripper / env.processor.max_gripper_pos altında yapılandırılan işlemci hattı (InverseKinematicsRLStep, EEBoundsAndSafety, EEReferenceAndDelta, GripperVelocityToJoint) tarafından uygulanır. Uç efektor uzayıyla ilgili varsayılanlar şunlardır:

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, teleoperasyon cihazını tanımlar. Kullanılabilir teleoperatörlerin listesini lerobot/teleoperators içinde kontrol edebilirsiniz.

Oyun Kumandasının Kurulumu

Oyun kolu, robotu ve bölüm durumunu kontrol etmek için çok pratik bir yöntem sunar.

Oyun kolu kurulumu için control_mode değerini "gamepad" olarak ayarlamalı ve yapılandırma dosyasında teleop bölümünü tanımlamalısınız.

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

Figure shows the control mappings on a Logitech gamepad.

Robot kontrolü ve bölüm yönetimi için oyun kolu düğme eşlemesi

SO101 liderinin yapılandırılması

SO101 lider kolu, keşif sırasında takipçi kolun hareketini izleyebilmesini sağlayan azaltılmış dişlilere sahiptir. Bu nedenle, dişlisiz SO100'e kıyasla devralma işlemi çok daha akıcıdır.

SO101 liderini kurmak için yapılandırma dosyasında control_mode değerini "leader" olarak ayarlamanız ve teleop bölümünü tanımlamanız gerekir.

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

Bölümün başarı/başarısızlık durumunu etiketlemek için, başarı için s, başarısızlık için esc tuşlarına basmanız gerekmektedir. Çevrimiçi eğitim sırasında, politikayı devralmak için space tuşuna basın ve kontrolü politikaya geri vermek için tekrar space tuşuna basın.

Video: SO101 leader teleoperation

SO101 lider teleoperasyon örneği, lider takipçiyi izler, müdahale etmek için `space` tuşuna basın

Demonstrasyon Kaydetme

Yukarıda düzenlediğiniz ortam yapılandırmasıyla kayıt sürecini başlatın:

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

Kayıt sırasında:

  1. Robot, yapılandırma dosyasında tanımlanan başlangıç konumuna, env.processor.reset.fixed_reset_joint_positions, sıfırlanacaktır.
  2. Görevi başarıyla tamamlayın
  3. Bölüm, “success” düğmesine bastığınızda 1 ödülle sona erer
  4. Süre sınırı aşıldığında veya başarısızlık düğmesine basıldığında, bölüm 0 ödülüyle sona erer
  5. “rerecord” düğmesine basarak bir bölümü yeniden kaydedebilirsiniz
  6. Süreç otomatik olarak bir sonraki bölüme geçer
  7. Tüm bölümler kaydedildikten sonra veri seti Hugging Face Hub'a itilir (isteğe bağlı) ve yerel olarak kaydedilir

Veri Setini İşleme

Gösterimlerin toplanmasının ardından, bunları işleyerek optimal kamera kırpma alanlarını belirleyin. Pekiştirmeli öğrenme, arka plan dikkat dağıtıcılarına karşı hassastır; bu nedenle görüntüleri ilgili çalışma alanına kırpmanız önemlidir.

Görsel RL algoritmaları doğrudan piksel girdilerinden öğrenir ve bu da onları alakasız görsel bilgilere karşı savunmasız kılar. Değişen aydınlatma, gölgeler, hareket eden insanlar veya çalışma alanının dışındaki nesneler gibi arka plan öğeleri öğrenme sürecini karıştırabilir. İyi bir ROI seçimi şunları sağlamalıdır:

  • Görevin gerçekleştiği temel çalışma alanını dahil edin
  • Robotun uç efektorunu ve görevde yer alan tüm nesneleri yakalayın
  • Gereksiz arka plan öğelerini ve dikkat dağıtıcı unsurları hariç tutun

Not: Kesme parametrelerini zaten biliyorsanız, bu adımı atlayıp kayıt sırasında yapılandırma dosyasında crop_params_dict değerini doğrudan ayarlayabilirsiniz.

Hasat Parametrelerinin Belirlenmesi

Kamera görüntülerinizde ilgi alanlarını etkileşimli olarak seçmek için crop_dataset_roi.py betiğini kullanın:

python -m lerobot.rl.crop_dataset_roi --repo-id username/pick_lift_cube
  1. Her kamera görünümü için betik, ilk kareyi görüntüler
  2. İlgili çalışma alanı etrafına bir dikdörtgen çizin
  3. Seçimi onaylamak için ‘c’ tuşuna basın
  4. Tüm kamera görünümleri için tekrarlayın
  5. Betik, kırpma parametrelerini çıktılar ve yeni kırpılmış bir veri seti oluşturur

Örnek çıktı:

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

İlgili bölgeleri seçmek için etkileşimli kırpma aracı

Yapılandırmanın Güncellenmesi

Eğitim yapılandırmanıza bu kırpma parametrelerini ekleyin:

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

Önerilen görüntü çözünürlüğü

Çoğu görü tabanlı politika, 128×128 (varsayılan) veya 64×64 piksel kare girişlerde doğrulanmıştır. Bu nedenle, GPU belleği ve bant genişliğini tasarruflu kullanmanız gerekiyorsa resize_size parametresini [64, 64] olarak, aksi halde [128, 128] olarak ayarlamanızı öneririz. Diğer çözünürlükler mümkündür ancak kapsamlı bir şekilde test edilmemiştir.

Ödül Sınıflandırıcısı Eğitimi

Ödül sınıflandırıcısı, ödül atamasını otomatikleştirerek ve bölüm başarısını otomatik olarak tespit ederek HIL-SERL iş akışında önemli bir rol oynar. Her zaman adımı için ödül işlevlerini manuel olarak tanımlamak veya insan geri bildirimine güvenmek yerine, ödül sınıflandırıcısı görsel gözlemlerden başarı/başarısızlığı tahmin etmeyi öğrenir. Bu, robotun kamera girdilerine dayalı tutarlı ve otomatik ödül sinyalleri sağlayarak RL algoritmasının verimli bir şekilde öğrenmesini sağlar.

Bu kılavuz, LeRobot'un insan-döngüde (human-in-the-loop) pekiştirmeli öğrenme uygulaması için bir ödül sınıflandırıcısı eğitmenin nasıl yapılacağını açıklar. Ödül sınıflandırıcılar, bir durum verildiğinde ödül değerini tahmin etmeyi öğrenir ve bu, bir RL kurulumunda politika eğitmek için kullanılabilir.

Not: Ödül sınıflandırıcısı eğitmek isteğe bağlıdır. RL deneylerinin ilk turunu, başarıyı oyun kumandanız veya klavye cihazınızla manuel olarak işaretleyerek başlatabilirsiniz.

lerobot/rewards/classifier/modeling_classifier.py içindeki ödül sınıflandırıcısı uygulaması, görüntüleri işlemek için önceden eğitilmiş bir görme modeli kullanır. Başarı/başarısızlık durumlarını tahmin etmek için ikili ödüllerde tek bir değer veya çok sınıflı ayarlamalarda birden fazla değer üretebilir.

Ödül sınıflandırıcısı için veri seti toplama

Eğitimden önce, etiketli örnekler içeren bir veri seti toplamanız gerekir. Yapılandırmanızda mode: "record" ayarını yapıp gym_manipulator.py dosyasını çalıştırdığınızda, gözlemler, eylemler ve ödüller içeren bir veri seti toplama süreci başlatılır.

Bir veri seti toplamak için, HILSerlRobotEnvConfig tabanlı olarak ortam yapılandırmasındaki bazı parametreleri değiştirmeniz gerekir.

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

Veri Toplama İçin Temel Parametreler

  • mode: bir veri seti toplamak için (kök seviyede) "record" olarak ayarlayın
  • dataset.repo_id: "hf_username/dataset_name", hub'daki veri setinin ve repozituarın adı
  • dataset.num_episodes_to_record: Kaydedilecek bölüm sayısı
  • env.processor.reset.terminate_on_success: Başarı algılandığında bölümlerin otomatik olarak sonlandırılıp sonlandırılmayacağı (varsayılan: true)
  • env.fps: Kaydedilecek saniye başına kare sayısı
  • dataset.push_to_hub: Veri setinin hub'a gönderilip gönderilmeyeceği

env.processor.reset.terminate_on_success parametresi, bölüm sonlandırma davranışını kontrol etmenizi sağlar. false olarak ayarlandığında, başarı algılansa bile bölümler devam eder; bu da ödül=1 etiketiyle daha fazla pozitif örnek toplamanıza olanak tanır. Bu, veri setinizde daha fazla başarı durumu örneği sağladığı için ödül sınıflandırıcılarını eğitmek açısından kritiktir. true olarak ayarlandığında (varsayılan), bölümler başarı algılandığında derhal sonlandırılır.

Önemli: Ödül sınıflandırıcı eğitimi için yeterli sayıda pozitif örnek toplanabilmesi adına terminate_on_success: false olarak ayarlayın. Normal HIL-SERL eğitimi için, görev başarıyla tamamlandığında otomatik bölüm sonlandırmasını etkinleştirmek üzere bu değeri true olarak bırakın.

Veri toplama için örnek yapılandırma bölümü:

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

Ödül Sınıflandırıcı Yapılandırması

Ödül sınıflandırıcısı lerobot/rewards/classifier/configuration_classifier.py kullanılarak yapılandırılır. İşte ana parametreler:

  • model_name: Temel model mimarisi (ör. çoğunlukla "helper2424/resnet10" kullanıyoruz)
  • model_type: "cnn" veya "transformer"
  • num_cameras: Kamera girişlerinin sayısı
  • num_classes: Çıktı sınıfı sayısı (genellikle ikili başarı/başarısızlık için 2)
  • hidden_dim: Gizli temsil boyutu
  • dropout_rate: Düzenleme parametresi
  • learning_rate: Optimizer için öğrenme oranı

Ödül sınıflandırıcısını eğitmek için örnek yapılandırma. Bunu reward_classifier_train_config.json olarak kaydedin:

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

Sınıflandırıcının Eğitimi

Sınıflandırıcıyı eğitmek için yapılandırmanızla train.py betiğini kullanın:

lerobot-train --config_path reward_classifier_train_config.json

Modelin Dağıtılması ve Test Edilmesi

Eğittiğiniz ödül sınıflandırıcısını kullanmak için, modelinizi kullanacak şekilde HILSerlRobotEnvConfig yapılandırmasını ayarlayı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
)

veya json yapılandırma dosyasındaki argümanı ayarlayın.

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

Modeli test etmek için gym_manipulator.py dosyasını çalıştırın.

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

Ödendendirme sınıflandırıcısı, robotun kameralarından gelen görsel girdiye dayanarak ödülleri otomatik olarak sağlayacaktır.

Ödül sınıflandırıcısını eğitmek için örnek iş akışı

  1. Yapılandırma dosyalarını oluşturun: Ödül sınıflandırıcısı ve ortam için gerekli json yapılandırma dosyalarını oluşturun: yukarıdaki örnekteki reward_classifier_train_config.json ve indirilen rl/env_config.json.

  2. Bir veri seti toplayın:

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

  3. Sınıflandırıcıyı eğitin:

    lerobot-train --config_path reward_classifier_train_config.json

  4. Sınıflandırıcıyı test edin:

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

Actor-Learner ile Eğitim

LeRobot sistemi, eğitim için dağıtık bir actor-learner mimarisi kullanır. Bu mimari, robot etkileşimlerini öğrenme sürecinden ayırarak birbirini engellemeden eşzamanlı çalışabilmelerini sağlar. Actor sunucusu, robot gözlemlerini ve eylemlerini işler ve etkileşim verilerini learner sunucusuna gönderir. Learner sunucusu gradyan inişini gerçekleştirir ve actor'un politika ağırlıklarını periyodik olarak günceller. İki süreci başlatmanız gerekecektir: bir learner ve bir actor.

Yapılandırma Kurulumu

Daha önce indirdiğiniz eğitim yapılandırma dosyasını, rl/train_config.json dosyasını düzenleyin (örnek burada mevcuttur). Eğitim yapılandırması, lerobot/rl/train_rl.py içindeki ana TrainRLServerPipelineConfig sınıfına dayanmaktadır.

  1. Politika ayarlarını yapılandırın (type="gaussian_actor", device vb.)
  2. Algoritma ayarlarını üst düzey algorithm bloğu altında yapılandırın (type="sac", öğrenme oranları, iskonto vb., lerobot/rl/algorithms/sac/configuration_sac.py içinde tanımlanmıştır).
  3. dataset parametresini kırpılmış veri setinize ayarlayın
  4. Kırpma parametreleriyle ortam ayarlarını yapılandırın
  5. configuration_gaussian_actor.py dosyasındaki Gaussian Actor ile ilgili diğer parametrelere göz atın.
  6. Göreviniz için doğru input_features ve output_features değerlerine sahip policy yapılandırmasının doğru olduğunu doğrulayın.

Learner'ı Başlatma

Öncelikle, öğrenici sunucu sürecini başlatın:

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

Öğrenen:

  • Politik ağını başlatır
  • Yeniden oynama tamponlarını hazırlar
  • Aktörlerle iletişim kurmak için bir gRPC sunucusu açar
  • Geçişleri işler ve politikayı günceller

Actor'ı Başlatma

Ayrı bir terminalde, aynı yapılandırmayla actor sürecini başlatın:

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

Oyuncu:

  • gRPC üzerinden öğreniciye bağlanır
  • Ortamı başlatır
  • Deneyim toplamak için politikanın rollouts'larını çalıştırın
  • Geçişleri öğreniciye gönderir
  • Güncellenmiş politika parametrelerini alır

Eğitim Akışı

Eğitim otomatik olarak devam eder:

  1. Actor, politikayı ortamda uygular
  2. Geçişler toplanır ve öğreniciye gönderilir
  3. Öğrenen, bu geçişlere dayanarak politikayı günceller
  4. Güncellenmiş politika parametreleri aktöre geri gönderilir
  5. Süreç, belirtilen adım sınırına ulaşılana kadar devam eder

İnsan Döngüde

  • Verimli öğrenmenin anahtarı, politika öğrenmesine ve keşfe yardımcı olmak için düzeltici geri bildirim sağlamak ve görevi tamamlamak amacıyla insan müdahalelerine sahip olmaktır.
  • İnsan müdahalelerini gerçekleştirmek için oyun kumandasındaki sağ üst tetik düğmesine (veya klavyedeki space tuşuna) basabilirsiniz. Bu işlem, politika eylemlerini duraklatır ve kontrolü size devretmenizi sağlar.
  • Başarılı bir deney, insanın başlangıçta müdahale etmesi gerektiği ancak politika iyileştikçe müdahale miktarının azaldığı deneydir. Müdahale oranını Trackio panelinde izleyebilirsiniz (trackio show --project <project>).

Figure shows the control mappings on a Logitech gamepad.

İnsan müdahalelerinin zaman içinde politika öğrenimini nasıl yönlendirdiğini gösteren örnek

  • Şekil, etkileşim adımına göre epizodik ödülün grafiğini göstermektedir. Şekil, insan müdahalelerinin politika öğrenimi üzerindeki etkisini göstermektedir.
  • Turuncu eğri, herhangi bir insan müdahalesi olmadan yapılan bir deneyi temsil eder. Pembe ve mavi eğriler ise insan müdahaleleri içeren deneyleri temsil eder.
  • İnsan müdahalelerinin varlığında, politikanın maksimum ödülü elde etmeye başladığı adım sayısının dörtte bir oranında azaldığını gözlemleyebiliriz.

İzleme ve Hata Ayıklama

Yapılandırmanızda trackio.enable değerini true olarak ayarladıysanız, eğitim ilerlemesini Trackio paneli üzerinden (trackio show --project <project>) gerçek zamanlı olarak izleyebilirsiniz.

İnsan Müdahaleleri Kılavuzu

Öğrenme süreci, müdahale stratejisine karşı son derece hassastır. Etkili bir şekilde müdahale etmenin nasıl yapılacağını anlamak birkaç deneme gerektirecektir. Birkaç ipucu ve öneri:

  • Eğitimin başlangıcında politikanın birkaç bölüm boyunca keşif yapmasına izin verin.
  • Uzun süreler boyunca müdahale etmemeye özen gösterin. Robotun yolundan sapması durumunda davranışını düzeltmek için duruma müdahale etmeye çalışın.
  • Politika görevi başarmaya başladığında, mükemmel olmasa bile, müdahalelerinizi basit ve hızlı eylemlere, örneğin basit kavrama komutlarına sınırlayabilirsiniz.

İdeal davranış, aşağıdaki şekilde gösterildiği gibi müdahale oranınızın eğitim sırasında kademeli olarak düşmesidir.

Intervention rate

Bir al ve kaldır küpü görevinde eğitim çalışması sırasında müdahale oranının grafiği

Ayarlanacak ana hiperparametreler

Bazı yapılandırma değerleri, eğitim kararlılığı ve hızı üzerinde orantısız bir etkiye sahiptir:

  • temperature_init (algorithm.temperature_init) – SAC'de başlangıç entropi sıcaklığı. Daha yüksek değerler daha fazla keşif teşvik eder; daha düşük değerler ise politikanın başlangıçta daha deterministik olmasını sağlar. İyi bir başlangıç noktası 1e-2'dir. Bu değerin çok yüksek ayarlanmasının insan müdahalelerini etkisiz hale getirebileceğini ve öğrenmeyi yavaşlatabileceğini gözlemledik.
  • policy_parameters_push_frequency (policy.actor_learner_config.policy_parameters_push_frequency) – learner'dan actor'a yapılan iki ağırlık itme işlemi arasındaki saniye cinsinden aralık. Varsayılan değer 4 s'tür. Daha taze ağırlıklar sağlamak için (daha fazla ağ trafiği maliyetiyle) 1-2 s'ye düşürün; yalnızca bağlantınız yavaşsa artırın, çünkü bu örnek verimliliğini azaltacaktır.
  • storage_device (policy.storage_device) – öğrenicinin politika parametrelerini sakladığı cihaz. Boş GPU belleğiniz varsa, bunu "cuda" olarak ayarlayın (varsayılan olan "cpu" yerine). Ağırlıkları GPU üzerinde tutmak, CPU→GPU aktarım maliyetini ortadan kaldırır ve saniyedeki öğrenici güncelleme sayısını önemli ölçüde artırabilir.

Tebrikler 🎉, bu öğreticiyi tamamladınız!

Herhangi bir sorunuz varsa veya yardıma ihtiyacınız varsa, lütfen Discord üzerinden bize ulaşın.

Makale alıntısı:

@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

←Kendi Donanımınızı Getirin Simülasyonda RL Eğitimi→