Hugging Face's logo

LeRobot documentation

Reachy 2

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Reachy 2

Reachy 2 es un robot humanoide de código abierto creado por Pollen Robotics, diseñado específicamente para el desarrollo de IA encarnada y aplicaciones en el mundo real. Consulta el sitio web de Pollen Robotics o accede a la documentación de Reachy 2 para obtener más información sobre la plataforma.

Teleopere Reachy 2

Actualmente, hay dos formas de teleoperar Reachy 2:

  • La teleoperación por VR de Pollen Robotics (no incluida en LeRobot).
  • Teleoperación de robot a robot (usar un Reachy 2 para controlar otro).

Simulación de Reachy 2

(Solo Linux) Puedes ejecutar Reachy 2 en simulación (Gazebo o MuJoCo) utilizando la imagen de Docker proporcionada.

  1. Instale Docker Engine.
  2. Ejecutar (para MuJoCo):
docker run --rm -it \
  --name reachy \
  --privileged \
  --network host \
  --ipc host \
  --device-cgroup-rule='c 189:* rwm' \
  --group-add audio \
  -e ROS_DOMAIN_ID="$ROS_DOMAIN_ID" \
  -e DISPLAY="$DISPLAY" \
  -e RCUTILS_CONSOLE_OUTPUT_FORMAT="[{severity}]: {message}" \
  -e REACHY2_CORE_SERVICE_FAKE="${REACHY2_CORE_SERVICE_FAKE:-true}" \
  -v /dev:/dev \
  -v "$HOME/.reachy_config":/home/reachy/.reachy_config_override \
  -v "$HOME/.reachy.log":/home/reachy/.ros/log \
  -v /usr/lib/x86_64-linux-gnu:/opt/host-libs \
  --entrypoint /package/launch.sh \
  pollenrobotics/reachy2_core:1.7.5.9_deploy \
  start_rviz:=true start_sdk_server:=true mujoco:=true

Si MuJoCo se ejecuta lentamente (frecuencia de simulación baja), agregue -e LD_LIBRARY_PATH="/opt/host-libs:$LD_LIBRARY_PATH" \ al comando anterior para mejorar el rendimiento:

docker run --rm -it \
  --name reachy \
  --privileged \
  --network host \
  --ipc host \
  --device-cgroup-rule='c 189:* rwm' \
  --group-add audio \
  -e ROS_DOMAIN_ID="$ROS_DOMAIN_ID" \
  -e DISPLAY="$DISPLAY" \
  -e RCUTILS_CONSOLE_OUTPUT_FORMAT="[{severity}]: {message}" \
  -e REACHY2_CORE_SERVICE_FAKE="${REACHY2_CORE_SERVICE_FAKE:-true}" \
  -e LD_LIBRARY_PATH="/opt/host-libs:$LD_LIBRARY_PATH" \
  -v /dev:/dev \
  -v "$HOME/.reachy_config":/home/reachy/.reachy_config_override \
  -v "$HOME/.reachy.log":/home/reachy/.ros/log \
  -v /usr/lib/x86_64-linux-gnu:/opt/host-libs \
  --entrypoint /package/launch.sh \
  pollenrobotics/reachy2_core:1.7.5.9_deploy \
  start_rviz:=true start_sdk_server:=true mujoco:=true

Configuración

Prerrequisitos

  • En tu robot, comprueba que las imágenes de servicio cumplen las versiones mínimas:
    • reachy2-core >= 1.7.5.2
    • webrtc >= 2.0.1.1

Luego, si deseas usar teleoperación con VR:

Recomendamos usar dos computadoras: una para la teleoperación (se requiere Windows) y otra para grabar con LeRobot.

Instalar LeRobot

Siga las instrucciones de instalación para instalar LeRobot.

Instale LeRobot con las dependencias de Reachy 2:

pip install -e ".[reachy2]"

Paso 1: Grabación

Obtener la dirección IP de Reachy 2

Antes de comenzar la teleoperación y la grabación de datos, busque la dirección IP del robot. Recomendamos encarecidamente conectar todos los dispositivos (PC y robot) mediante Ethernet.

Grabación del lanzamiento

Use el comando lerobot-record de LeRobot para gestionar las sesiones de grabación. El flujo de trabajo pollen_data_acquisition_server documentado anteriormente aquí ya no está disponible.

Al usar la aplicación de teleoperación VR de Reachy 2, elija “Standard session”. La aplicación VR controla el movimiento del robot, mientras que lerobot-record gestiona el conjunto de datos y inicia y detiene los episodios.

Grabar con lerobot-record

Reachy 2 es totalmente compatible con las funciones de grabación de LeRobot.

Ejemplo: iniciar una grabación sin la base móvil: Primero, añade reachy2 y reachy2_teleoperator a las importaciones del script de grabación. Luego, puedes usar el siguiente comando:

lerobot-record \
    --robot.type=reachy2 \
    --robot.ip_address=192.168.0.200 \
    --robot.id=r2-0000 \
    --robot.use_external_commands=true \
    --robot.with_mobile_base=false \
    --teleop.type=reachy2_teleoperator \
    --teleop.ip_address=192.168.0.200 \
    --teleop.with_mobile_base=false \
    --robot.with_torso_camera=true \
    --dataset.repo_id=pollen_robotics/record_test \
    --dataset.single_task="Reachy 2 recording test" \
    --dataset.num_episodes=1 \
    --dataset.episode_time_s=5 \
    --dataset.fps=15 \
    --dataset.push_to_hub=true \
    --dataset.private=true \
    --dataset.streaming_encoding=true \
    --dataset.encoder_threads=2 \
    # --dataset.rgb_encoder.vcodec=auto \
    --display_data=true

Opciones específicas

Resumen de la configuración extendida (incluidas todas las opciones):

lerobot-record \
    --robot.type=reachy2 \
    --robot.ip_address=192.168.0.200 \
    --robot.use_external_commands=true \
    --robot.with_mobile_base=true \
    --robot.with_l_arm=true \
    --robot.with_r_arm=true \
    --robot.with_neck=true \
    --robot.with_antennas=true \
    --robot.with_left_teleop_camera=true \
    --robot.with_right_teleop_camera=true \
    --robot.with_torso_camera=false \
    --robot.camera_width=640 \
    --robot.camera_height=480 \
    --robot.disable_torque_on_disconnect=false \
    --robot.max_relative_target=5.0 \
    --teleop.type=reachy2_teleoperator \
    --teleop.ip_address=192.168.0.200 \
    --teleop.use_present_position=false \
    --teleop.with_mobile_base=false \
    --teleop.with_l_arm=true \
    --teleop.with_r_arm=true \
    --teleop.with_neck=true \
    --teleop.with_antennas=true \
    --dataset.repo_id=pollen_robotics/record_test \
    --dataset.single_task="Reachy 2 recording test" \
    --dataset.num_episodes=1 \
    --dataset.episode_time_s=5 \
    --dataset.fps=15 \
    --dataset.push_to_hub=true \
    --dataset.private=true \
    --dataset.streaming_encoding=true \
    --dataset.encoder_threads=2 \
    # --dataset.rgb_encoder.vcodec=auto \
    --display_data=true
--robot.use_external_commands

Determine si LeRobot robot.send_action() envía comandos al robot. Debe establecerse en false mientras se utiliza la aplicación de teleoperación con VR, ya que la aplicación ya envía comandos.

--teleop.use_present_position

Determine si el teleoperador lee el objetivo o la posición actual del robot. Debe establecerse en true si se utiliza un Reachy 2 conforme para controlar otro.

Utilice las partes relevantes

En nuestras pruebas iniciales, grabar todos los articulaciones cuando solo se mueven algunas puede reducir la calidad del modelo con ciertas políticas. Para evitarlo, puedes excluir partes específicas de la grabación y la reproducción usando:

--robot.with_<part>=false

donde <part> es uno de: mobile_base, l_arm, r_arm",neck,antennas`. Determina si la parte correspondiente se registra en las observaciones. True si no se establece.

Por defecto, se registran todas las partes.

El mismo mecanismo por parte también está disponible en reachy2_teleoperator.

--teleop.with\_<part>

donde <part> es uno de: mobile_base, l_arm, r_arm",neck,antennas`. Determina si la parte correspondiente está registrada en las acciones. True si no se establece.

Importante: En una sesión dada, las partes habilitadas deben coincidir tanto en el robot como en el teleoperador. Por ejemplo, si el robot se ejecuta con --robot.with_mobile_base=false, el teleoperador debe deshabilitar la misma parte --teleoperator.with_mobile_base=false.

Utilice las cámaras pertinentes

Puedes hacer lo mismo con las cámaras. Activa o desactiva cada cámara con los parámetros predeterminados usando:

--robot.with_left_teleop_camera=<true|false> \
--robot.with_right_teleop_camera=<true|false> \
--robot.with_torso_camera=<true|false>

Por defecto, no se registra ninguna cámara y todos los argumentos de cámara se establecen en false. Si lo deseas, puedes usar parámetros personalizados de width y height para las cámaras de Reachy 2 mediante el argumento --robot.camera_width & --robot.camera_height:

--robot.camera_width=1920 \
--robot.camera_height=1080

Esto cambiará la resolución de las 3 cámaras de robot predeterminadas (habilitadas por los argumentos bool anteriores).

Si lo deseas, puedes añadir cámaras adicionales además de las del robot de la manera habitual con:

--robot.cameras="{ extra: {type: opencv, index_or_path: 42, width: 640, height: 480, fps: 30}}" \

Paso 2: Reproducir

Asegúrate de que el robot esté configurado con las mismas piezas que el conjunto de datos:

lerobot-replay \
    --robot.type=reachy2 \
    --robot.ip_address=192.168.0.200 \
    --robot.use_external_commands=false \
    --robot.with_mobile_base=false \
    --dataset.repo_id=pollen_robotics/record_test \
    --dataset.episode=0

Paso 3: Entrenar

lerobot-train \
  --dataset.repo_id=pollen_robotics/record_test \
  --policy.type=act \
  --output_dir=outputs/train/reachy2_test \
  --job_name=reachy2 \
  --policy.device=mps \
  --trackio.enable=true \
  --policy.repo_id=pollen_robotics/record_test_policy

Paso 4: Evaluar

lerobot-eval \
  --robot.type=reachy2 \
  --robot.ip_address=192.168.0.200 \
  --dataset.repo_id=pollen_robotics/eval_record_test \
  --dataset.single_task="Evaluate reachy2 policy" \
  --dataset.num_episodes=10 \
  --policy.path=outputs/train/reachy2_test/checkpoints/last/pretrained_model

Secciones que se movieron:

[ (Opcional pero recomendado) Instalar pollen_data_acquisition_server ]

[ Opción 1: Usar el servidor de adquisición de datos de Pollen (recomendado para teleoperación en RV) ]

[ Opción 2: Usando lerobot.record ]

Update on GitHub

←Hope Jr Unitree G1→