Guía del flujo de trabajo de entrenamiento en robots reales de HIL-SERL

En este tutorial recorrerás el flujo de trabajo completo de Human-in-the-Loop Sample-Efficient Reinforcement Learning (HIL-SERL) usando LeRobot. Dominarás el entrenamiento de una política con RL en un robot real en solo unas pocas horas.

HIL-SERL es un algoritmo de aprendizaje por refuerzo eficiente en muestras que combina demostraciones humanas con aprendizaje en línea e intervenciones humanas. El enfoque parte de un pequeño conjunto de demostraciones humanas, las utiliza para entrenar un clasificador de recompensa y luego emplea una arquitectura actor-aprendiz donde los humanos pueden intervenir durante la ejecución de la política para guiar la exploración y corregir comportamientos inseguros. En este tutorial, utilizarás un mando de videojuegos para proporcionar intervenciones y controlar el robot durante el proceso de aprendizaje.

Combina tres ingredientes clave:

1. Demonstraciones offline y clasificador de recompensa: un puñado de episodios de teleoperación humana más un detector de éxito basado en visión le dan a la política un punto de partida moldeado.

2. Bucle de actor/aprendiz en el robot con intervenciones humanas: un aprendiz distribuido de Soft Actor Critic (SAC) actualiza la política mientras un actor explora en el robot físico; el humano puede intervenir en cualquier momento para corregir un comportamiento peligroso o improductivo.

3. Herramientas de seguridad y eficiencia: los límites de articulaciones/efector final (EE), el preprocesamiento de la región de interés (ROI) recortada y el monitoreo con Trackio mantienen los datos útiles y el hardware seguro.

Juntos, estos elementos permiten que HIL-SERL alcance un éxito de tarea casi perfecto y tiempos de ciclo más rápidos que las líneas base basadas únicamente en imitación.

Flujo de trabajo de HIL-SERL, Luo et al. 2024

Esta guía proporciona instrucciones paso a paso para entrenar una política de robot utilizando la implementación de HilSerl de LeRobot para entrenar en un robot real.

¿Qué necesito?

• Un gamepad (recomendado) o un teclado para controlar el robot
• Una GPU de Nvidia
• Un robot real con un brazo seguidor y un brazo líder (opcional si usas el teclado o el mando de juegos)
• Un archivo URDF del robot para el paquete de cinemática (consulte lerobot/model/kinematics.py)

¿Qué tipo de tareas puedo entrenar?

Se puede usar HIL-SERL para entrenar en una variedad de tareas de manipulación. Algunas recomendaciones:

• Comienza con una tarea sencilla para entender cómo funciona el sistema.
  • Empujar el cubo a una región objetivo
  • Elegir y levantar el cubo con el agarre
• Evite tareas con horizontes extremadamente largos. Céntrese en tareas que se puedan completar en 5-10 segundos.
• Una vez que tengas una buena idea de cómo funciona el sistema, puedes intentar tareas más complejas y horizontes más largos.
  • Elegir y colocar cubo
  • Tareas bimanuales para recoger objetos con dos brazos
  • Tareas de transferencia para pasar objetos de un brazo a otro
  • ¡Dale caña!

Instalar LeRobot con HIL-SERL

Para instalar LeRobot con HIL-SERL, necesitas instalar el extra hilserl.

pip install -e ".[hilserl]"

Flujo de trabajo de entrenamiento de robots reales

Comprensión de la configuración

El proceso de entrenamiento comienza con la configuración adecuada para el entorno HILSERl. La clase de configuración principal es GymManipulatorConfig en lerobot/rl/gym_manipulator.py, que contiene HILSerlRobotEnvConfig (definida en lerobot/envs/configs.py) y DatasetConfig anidadas. La configuración se organiza en subconfiguraciones anidadas y enfocadas:

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

Arquitectura de la pipeline del procesador

HIL-SERL utiliza una arquitectura de pipeline de procesadores modular que procesa las observaciones y acciones del robot a través de una serie de pasos componibles. El pipeline se divide en dos componentes principales:

Pipeline del procesador de entorno

El procesador de entorno (env_processor) gestiona las observaciones entrantes y el estado del entorno:

1. VanillaObservationProcessorStep: Convierte las observaciones crudas del robot a un formato estandarizado
2. JointVelocityProcessorStep (opcional): Añade información de velocidad articular a las observaciones
3. MotorCurrentProcessorStep (opcional): Añade lecturas de corriente del motor a las observaciones
4. ForwardKinematicsJointsToEE (opcional): Calcula la pose del efector final a partir de las posiciones de las articulaciones
5. ImageCropResizeProcessorStep (opcional): recorta y redimensiona las imágenes de la cámara
6. TimeLimitProcessorStep (opcional): Impone límites de tiempo a los episodios
7. GripperPenaltyProcessorStep (opcional): aplica penalizaciones por un uso inadecuado del agarre
8. RewardClassifierProcessorStep (opcional): Detección automática de recompensas mediante modelos de visión
9. AddBatchDimensionProcessorStep: Convierte los datos al formato de lote para el procesamiento de redes neuronales
10. DeviceProcessorStep: Mueve los datos al dispositivo de cálculo especificado (CPU/GPU)

Pipeline del procesador de acciones

El procesador de acciones (action_processor) gestiona las acciones salientes y las intervenciones humanas:

1. AddTeleopActionAsComplimentaryDataStep: Captura las acciones del teleoperador para su registro
2. AddTeleopEventsAsInfoStep: Registra eventos de intervención y señales de control de episodio
3. InterventionActionProcessorStep: Gestiona las intervenciones humanas y la terminación de episodios
4. Inverse Kinematics Pipeline (cuando está habilitado:
   • MapDeltaActionToRobotActionStep: Convierte las acciones delta al formato de acción del robot
   • EEReferenceAndDelta: Calcula los movimientos de referencia y delta del efector final
   • EEBoundsAndSafety: Aplica los límites de seguridad del espacio de trabajo
   • InverseKinematicsEEToJoints: Convierte las acciones del efector final en objetivos de articulaciones
   • GripperVelocityToJoint: maneja los comandos de control del agarre

Ejemplos de configuración

Procesamiento básico de observaciones:

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

Procesamiento de imágenes:

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

Configuración de la cinemática inversa:

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

Procesamiento avanzado de observaciones

El marco HIL-SERL admite funciones adicionales de procesamiento de observaciones que pueden mejorar el aprendizaje de la política:

Procesamiento de velocidad conjunta

Habilite la estimación conjunta de velocidad para proporcionar a la política información sobre el movimiento:

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

Este procesador:

• Estima las velocidades articulares mediante diferencias finitas entre lecturas consecutivas de la posición de las articulaciones
• Añade información de velocidad al vector de estado de la observación
• Útil para políticas que necesitan conciencia del movimiento para tareas dinámicas

Procesamiento actual del motor

Monitoree las corrientes del motor para detectar fuerzas de contacto y condiciones de carga:

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

Este procesador:

• Lee los valores de corriente del motor desde el sistema de control del robot
• Añade las mediciones actuales al vector de estado de observación
• Ayuda a detectar eventos de contacto, pesos de objetos y resistencia mecánica
• Útil para tareas de manipulación con abundante contacto

Procesamiento de observaciones combinadas

Puede habilitar varias funciones de procesamiento de observaciones simultáneamente:

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

Nota: Habilitar características de observación adicionales aumenta la dimensionalidad del espacio de estados, lo que puede requerir ajustar la arquitectura de la red de política y, potencialmente, recopilar más datos de entrenamiento.

Encontrar los límites del espacio de trabajo del robot

Antes de recopilar demostraciones, debe determinar los límites operativos adecuados para su robot.

Esto ayuda a simplificar el problema de aprender en el robot real de dos maneras: 1) limitando el espacio operativo del robot a una región específica que resuelve la tarea y evita la exploración innecesaria o insegura, y 2) permitiendo el entrenamiento en el espacio del efector final en lugar del espacio de articulaciones. Empíricamente, aprender en el espacio de articulaciones para el aprendizaje por refuerzo en manipulación suele ser un problema más difícil: algunas tareas son casi imposibles de aprender en el espacio de articulaciones, pero se vuelven aprendibles cuando el espacio de acciones se transforma a coordenadas del efector final.

Uso de lerobot-find-joint-limits

Este script le ayuda a encontrar los límites operativos seguros para el efector final de su robot. Dado que tiene un brazo seguidor y un brazo líder, puede usar el script para encontrar los límites del brazo seguidor que se aplicarán durante el entrenamiento. Limitar el espacio de acciones reducirá la exploración redundante del agente y garantizará la seguridad.

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 es obligatorio: apunta al archivo URDF de tu robot, que el script utiliza para calcular la posición del efector final. Para el SO-100/SO-101, clona el repositorio SO-ARM100 con git clone https://github.com/TheRobotStudio/SO-ARM100.git; el URDF estará entonces en SO-ARM100/Simulation/SO101/so101_new_calib.urdf.

Flujo de trabajo

1. Ejecuta el script y mueve el robot a través del espacio que resuelve la tarea

2. El script registrará las posiciones mínimas y máximas del efector final y los ángulos de las articulaciones, y los imprimirá en la consola, por ejemplo:

   Copiado

   # 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. Usa estos valores en tu configuración de entorno bajo env.processor.inverse_kinematics.end_effector_bounds (consulta InverseKinematicsConfig en lerobot/envs/configs.py)

Configuración de ejemplo

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

Recopilación de demostraciones

Con los límites definidos, puedes recopilar de forma segura demostraciones para el entrenamiento. Entrenar RL con un algoritmo off-policy nos permite utilizar conjuntos de datos offline recopilados con el fin de mejorar la eficiencia del proceso de aprendizaje.

Configuración del modo de grabación

Los archivos de configuración de ejemplo para esta guía se encuentran en el conjunto de datos lerobot/config_examples en el Hub. Descarga las configuraciones del entorno y del entrenamiento en tu directorio de trabajo:

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

Esto los guarda en rl/env_config.json y rl/train_config.json, las rutas utilizadas en los comandos siguientes. Edita rl/env_config.json para grabar demostraciones:

1. Establezca mode en "record" en el nivel raíz
2. Especifique un repo_id único para su conjunto de datos en la sección dataset (p. ej., “username/task_name”)
3. Establezca num_episodes_to_record en la sección dataset al número de demostraciones que desea recopilar
4. Establezca env.processor.image_preprocessing.crop_params_dict en {} inicialmente (determinaremos los recortes más adelante)
5. Configura env.robot, env.teleop y otros ajustes de hardware en la sección env

Sección de configuración de ejemplo:

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

Uso de un dispositivo de teleoperación

Junto con tu robot, necesitarás un dispositivo de teleoperación para controlarlo a fin de recopilar conjuntos de datos de tu tarea y realizar intervenciones durante el entrenamiento en línea. Admitimos el uso de un mando de videojuegos, un teclado o el brazo líder del robot.

HIL-Serl aprende acciones en el espacio del efector final del robot. Por lo tanto, la teleoperación controlará los desplazamientos x, y, z del efector final.

La transformación del efector final se aplica mediante la línea de procesamiento (InverseKinematicsRLStep, EEBoundsAndSafety, EEReferenceAndDelta, GripperVelocityToJoint) configurada bajo env.processor.inverse_kinematics (InverseKinematicsConfig) y env.processor.gripper / env.processor.max_gripper_pos. Los valores predeterminados relacionados con el espacio del efector final son:

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

El Teleoperator define el dispositivo de teleoperación. Puede consultar la lista de teleoperadores disponibles en lerobot/teleoperators.

Configuración del Gamepad

El gamepad ofrece una forma muy práctica de controlar el robot y el estado del episodio.

Para configurar el gamepad, debe establecer control_mode en "gamepad" y definir la sección teleop en el archivo de configuración.

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

Mapeo de botones del mando para el control del robot y la gestión de episodios

Configuración del líder SO101

El brazo líder del SO101 tiene engranajes reducidos que le permiten moverse y seguir al brazo seguidor durante la exploración. Por lo tanto, la toma de control es mucho más fluida que en el SO100, que no tiene engranajes.

Para configurar el líder SO101, debe establecer control_mode en "leader" y definir la sección teleop en el archivo de configuración.

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

Para anotar el éxito o el fracaso del episodio, deberás usar el teclado para presionar s para éxito y esc para fracaso. Durante el entrenamiento en línea, presiona space para tomar el control de la política y space de nuevo para devolver el control a la política.

Grabación de demostraciones

Inicie el proceso de grabación con la configuración de entorno que editó anteriormente:

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

Durante la grabación:

1. El robot se restablecerá en la posición inicial definida en el archivo de configuración env.processor.reset.fixed_reset_joint_positions
2. Completa la tarea con éxito
3. El episodio termina con una recompensa de 1 cuando presionas el botón “success”
4. Si se alcanza el límite de tiempo o se presiona el botón de fallo, el episodio termina con una recompensa de 0
5. Puede volver a grabar un episodio presionando el botón “rerecord”
6. El proceso continúa automáticamente con el siguiente episodio
7. Después de registrar todos los episodios, el conjunto de datos se sube al Hugging Face Hub (opcional) y se guarda localmente

Procesamiento del conjunto de datos

Después de recopilar las demostraciones, procéselas para determinar los recortes de cámara óptimos. El aprendizaje por refuerzo es sensible a las distracciones del fondo, por lo que es importante recortar las imágenes al área de trabajo relevante.

Los algoritmos de RL visual aprenden directamente de entradas de píxeles, lo que los hace vulnerables a la información visual irrelevante. Elementos de fondo como cambios de iluminación, sombras, personas en movimiento u objetos fuera del área de trabajo pueden confundir el proceso de aprendizaje. Una buena selección de ROI debe:

• Incluya solo el espacio de trabajo esencial donde se realiza la tarea
• Captura el efector final del robot y todos los objetos involucrados en la tarea
• Excluir elementos de fondo innecesarios y distracciones

Nota: Si ya conoces los parámetros de recorte, puedes omitir este paso y simplemente establecer crop_params_dict en el archivo de configuración durante la grabación.

Determinación de los parámetros de recorte

Utilice el script crop_dataset_roi.py para seleccionar regiones de interés de forma interactiva en sus imágenes de cámara:

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

1. Para cada vista de cámara, el script mostrará el primer fotograma
2. Dibuje un rectángulo alrededor del área relevante del espacio de trabajo
3. Pulsa ‘c’ para confirmar la selección
4. Repite para todas las vistas de la cámara
5. El script imprime los parámetros de recorte y crea un nuevo conjunto de datos recortado

Ejemplo de salida:

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

Herramienta interactiva de recorte para seleccionar regiones de interés

Actualización de la configuración

Agrega estos parámetros de recorte a tu configuración de entrenamiento:

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

Resolución de imagen recomendada

La mayoría de las políticas basadas en visión se han validado con entradas cuadradas de 128×128 (predeterminado) o 64×64 píxeles. Por lo tanto, recomendamos establecer el parámetro resize_size en [128, 128] – o en [64, 64] si necesitas ahorrar memoria y ancho de banda de la GPU. Otras resoluciones son posibles, pero no se han probado de manera exhaustiva.

Entrenamiento de un clasificador de recompensas

El clasificador de recompensas desempeña un papel importante en el flujo de trabajo de HIL-SERL al automatizar la asignación de recompensas y detectar automáticamente el éxito de un episodio. En lugar de definir funciones de recompensa manualmente o depender de la retroalimentación humana en cada paso de tiempo, el clasificador de recompensas aprende a predecir el éxito o el fracaso a partir de observaciones visuales. Esto permite que el algoritmo de RL aprenda de manera eficiente al proporcionar señales de recompensa consistentes y automatizadas basadas en las entradas de la cámara del robot.

Esta guía explica cómo entrenar un clasificador de recompensas para la implementación de aprendizaje por refuerzo con intervención humana de LeRobot. Los clasificadores de recompensas aprenden a predecir el valor de la recompensa dado un estado, lo que puede utilizarse en una configuración de RL para entrenar una política.

Nota: Entrenar un clasificador de recompensa es opcional. Puedes iniciar la primera ronda de experimentos de RL anotando el éxito manualmente con tu mandos o dispositivo de teclado.

La implementación del clasificador de recompensas en lerobot/rewards/classifier/modeling_classifier.py utiliza un modelo de visión preentrenado para procesar las imágenes. Puede generar un único valor para recompensas binarias que predigan casos de éxito/fallo, o varios valores para configuraciones de múltiples clases.

Recopilación de un conjunto de datos para el clasificador de recompensas

Antes de entrenar, necesitas recopilar un conjunto de datos con ejemplos etiquetados. Establecer mode: "record" en tu configuración y ejecutar gym_manipulator.py habilita el proceso de recopilación de un conjunto de datos de observaciones, acciones y recompensas.

Para recopilar un conjunto de datos, es necesario modificar algunos parámetros en la configuración del entorno basándose en HILSerlRobotEnvConfig.

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

Parámetros clave para la recopilación de datos

• mode: establécelo en "record" para recopilar un conjunto de datos (a nivel raíz)
• dataset.repo_id: "hf_username/dataset_name", nombre del conjunto de datos y del repositorio en el hub
• dataset.num_episodes_to_record: Número de episodios a registrar
• env.processor.reset.terminate_on_success: Si se terminan automáticamente los episodios cuando se detecta un éxito (valor predeterminado: true)
• env.fps: Número de fotogramas por segundo a grabar
• dataset.push_to_hub: Si se debe subir el conjunto de datos al hub

El parámetro env.processor.reset.terminate_on_success le permite controlar el comportamiento de terminación de los episodios. Cuando se establece en false, los episodios continúan incluso después de detectar el éxito, lo que le permite recopilar más ejemplos positivos con la etiqueta reward=1. Esto es crucial para entrenar clasificadores de recompensa, ya que proporciona más ejemplos de estados de éxito en su conjunto de datos. Cuando se establece en true (valor predeterminado), los episodios terminan inmediatamente al detectar el éxito.

Importante: Para el entrenamiento del clasificador de recompensa, establece terminate_on_success: false para recopilar suficientes ejemplos positivos. Para el entrenamiento regular de HIL-SERL, mantenlo como true para habilitar la terminación automática del episodio cuando la tarea se completa con éxito.

Sección de configuración de ejemplo para la recopilación de datos:

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

Configuración del clasificador de recompensas

El clasificador de recompensas se configura mediante lerobot/rewards/classifier/configuration_classifier.py. Estos son los parámetros clave:

• model_name: Arquitectura del modelo base (p. ej., principalmente usamos "helper2424/resnet10")
• model_type: "cnn" o "transformer"
• num_cameras: Número de entradas de cámara
• num_classes: Número de clases de salida (típicamente 2 para éxito/fracaso binario)
• hidden_dim: Tamaño de la representación oculta
• dropout_rate: Parámetro de regularización
• learning_rate: Tasa de aprendizaje para el optimizador

Ejemplo de configuración para entrenar el clasificador de recompensa. Guárdalo como 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"
}

Entrenamiento del clasificador

Para entrenar el clasificador, use el script train.py con su configuración:

lerobot-train --config_path reward_classifier_train_config.json

Despliegue y prueba del modelo

Para usar tu clasificador de recompensa entrenado, configura HILSerlRobotEnvConfig para que use tu modelo:

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
)

o establezca el argumento en el archivo de configuración 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
      }
    }
  }
}

Ejecuta gym_manipulator.py para probar el modelo.

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

El clasificador de recompensas proporcionará automáticamente recompensas basadas en la entrada visual de las cámaras del robot.

Flujo de trabajo de ejemplo para entrenar el clasificador de recompensas

1. Crear los archivos de configuración: Cree los archivos de configuración json necesarios para el clasificador de recompensa y el entorno: reward_classifier_train_config.json del ejemplo anterior, y el rl/env_config.json descargado.

2. Reunir un conjunto de datos:

   Copiado

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

3. Entrenar el clasificador:

   Copiado

   lerobot-train --config_path reward_classifier_train_config.json

4. Probar el clasificador:

   Copiado

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

Entrenamiento con Actor-Learner

El sistema LeRobot utiliza una arquitectura distribuida actor-aprendiz para el entrenamiento. Esta arquitectura desacopla las interacciones del robot del proceso de aprendizaje, permitiendo que se ejecuten de forma concurrente sin bloquearse mutuamente. El servidor actor gestiona las observaciones y acciones del robot, enviando los datos de interacción al servidor aprendiz. El servidor aprendiz realiza el descenso de gradiente y actualiza periódicamente los pesos de la política del actor. Deberás iniciar dos procesos: un aprendiz y un actor.

Configuración

Edit the training configuration file you downloaded earlier, rl/train_config.json (example available here). The training config is based on the main TrainRLServerPipelineConfig class in lerobot/rl/train_rl.py.

1. Configure los ajustes de la política (type="gaussian_actor", device, etc.)
2. Configure los ajustes del algoritmo en el bloque de nivel superior algorithm (type="sac", tasas de aprendizaje, descuento, etc., definidos en lerobot/rl/algorithms/sac/configuration_sac.py).
3. Establezca dataset en su conjunto de datos recortado
4. Configura los ajustes del entorno con parámetros de recorte
5. Compruebe los demás parámetros relacionados con el Actor gaussiano en configuration_gaussian_actor.py.
6. Verifique que la configuración policy sea correcta con los input_features y output_features adecuados para su tarea.

Iniciar el Learner

Primero, inicie el proceso del servidor de aprendizaje:

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

El aprendiz:

• Inicializa la red de política
• Prepara los buffers de repetición
• Abre un servidor gRPC para comunicarse con los actores
• Procesa las transiciones y actualiza la política

Iniciar el Actor

En una terminal separada, inicie el proceso actor con la misma configuración:

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

El actor:

• Se conecta al aprendiz a través de gRPC
• Inicializa el entorno
• Ejecutar despliegues de la política para recopilar experiencia
• Envía transiciones al aprendiz
• Recibe los parámetros de la política actualizados

Flujo de entrenamiento

El entrenamiento procede automáticamente:

1. El actor ejecuta la política en el entorno
2. Las transiciones se recopilan y se envían al aprendiz
3. El aprendiz actualiza la política en función de estas transiciones
4. Los parámetros de política actualizados se envían de vuelta al actor
5. El proceso continúa hasta alcanzar el límite de pasos especificado

Intervención humana

• La clave para aprender de manera eficiente es contar con intervenciones humanas que proporcionen retroalimentación correctiva y completen la tarea, a fin de ayudar al aprendizaje de la política y a la exploración.
• Para realizar intervenciones humanas, puede presionar el botón de disparo superior derecho en el mando (o la tecla space en el teclado). Esto pausará las acciones de la política y le permitirá tomar el control.
• Un experimento exitoso es aquel en el que el humano debe intervenir al inicio, pero luego reduce la cantidad de intervenciones a medida que la política mejora. Puedes monitorear la tasa de intervención en el panel de Trackio (trackio show --project <project>).

Ejemplo que muestra cómo las intervenciones humanas ayudan a guiar el aprendizaje de la política a lo largo del tiempo

• La figura muestra la representación gráfica de la recompensa episódica en función del paso de interacción. La figura muestra el efecto de las intervenciones humanas en el aprendizaje de la política.
• La curva naranja es un experimento sin intervenciones humanas. Mientras que las curvas rosa y azul son experimentos con intervenciones humanas.
• Podemos observar que el número de pasos en los que la política comienza a lograr la recompensa máxima se reduce a la cuarta parte cuando hay intervenciones humanas.

Monitoreo y depuración

Si tienes trackio.enable establecido en true en tu configuración, puedes monitorear el progreso del entrenamiento en tiempo real a través del panel de Trackio (trackio show --project <project>).

Guía de intervenciones humanas

El proceso de aprendizaje es muy sensible a la estrategia de intervención. Se necesitarán varias ejecuciones para entender cómo intervenir de manera efectiva. Algunos consejos y sugerencias:

• Permitir que la política explore durante unos pocos episodios al inicio del entrenamiento.
• Evite intervenir durante largos períodos de tiempo. Intente intervenir en la situación para corregir el comportamiento del robot cuando se desvíe del rumbo.
• Una vez que la política comience a lograr la tarea, aunque no sea perfecta, puede limitar sus intervenciones a acciones simples y rápidas, como comandos de agarre básicos.

El comportamiento ideal es que la tasa de intervención disminuya gradualmente durante el entrenamiento, como se muestra en la figura siguiente.

Gráfico de la tasa de intervención durante una ejecución de entrenamiento en una tarea de recoger y levantar un cubo

Hipervariables clave para ajustar

Algunos valores de configuración tienen un impacto desproporcionado en la estabilidad y la velocidad del entrenamiento:

• temperature_init (algorithm.temperature_init) – temperatura inicial de entropía en SAC. Valores más altos fomentan más exploración; valores más bajos hacen que la política sea más determinista al principio. Un buen punto de partida es 1e-2. Observamos que configurarlo demasiado alto puede hacer que las intervenciones humanas sean ineficaces y ralentizar el aprendizaje.
• policy_parameters_push_frequency (policy.actor_learner_config.policy_parameters_push_frequency) – intervalo en segundos entre dos envíos de pesos del learner al actor. El valor predeterminado es 4 s. Redúzcalo a 1-2 s para proporcionar pesos más recientes (a costa de más tráfico de red); aumente el valor solo si su conexión es lenta, ya que esto reducirá la eficiencia de las muestras.
• storage_device (policy.storage_device) – dispositivo en el que el learner mantiene los parámetros de la política. Si tienes memoria GPU libre, establece este valor en "cuda" (en lugar del valor predeterminado "cpu"). Mantener los pesos en la GPU elimina la sobrecarga de transferencia CPU→GPU y puede aumentar significativamente el número de actualizaciones del learner por segundo.

¡Felicidades 🎉, has completado este tutorial!

Si tienes alguna pregunta o necesitas ayuda, comunícate con nosotros en Discord.

Cita del artículo:

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