Reachy 2

Reachy 2 est un robot humanoïde open source développé par Pollen Robotics, conçu spécifiquement pour le développement de l’IA incarnée et des applications réelles. Consultez le site web de Pollen Robotics ou accédez à la documentation de Reachy 2 pour plus d’informations sur la plateforme !

Télépiloter Reachy 2

Actuellement, il existe deux façons de téléopérer Reachy 2 :

• La téléopération VR de Pollen Robotics (non incluse dans LeRobot).
• Téléopération robot-à-robot (utiliser un Reachy 2 pour contrôler un autre).

Simulation de Reachy 2

(Linux uniquement) Vous pouvez exécuter Reachy 2 en simulation (Gazebo ou MuJoCo) à l'aide de l'image Docker fournie.

1. Installer Docker Engine.
2. Exécuter (pour 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 s’exécute lentement (fréquence de simulation faible), ajoutez -e LD_LIBRARY_PATH="/opt/host-libs:$LD_LIBRARY_PATH" \ à la commande précédente pour améliorer les performances :

Copié

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

Configuration

Prérequis

• Sur votre robot, vérifiez que les images de service sont aux versions minimales suivantes :
  • reachy2-core >= 1.7.5.2
  • webrtc >= 2.0.1.1

Ensuite, si vous souhaitez utiliser la téléopération VR :

• Installez l'application de téléopération Reachy 2. Utilisez la version >=v1.2.0

Nous recommandons d’utiliser deux ordinateurs : l’un pour la téléopération (Windows requis) et l’autre pour l’enregistrement avec LeRobot.

Installer LeRobot

Suivez les instructions d'installation pour installer LeRobot.

Installer LeRobot avec les dépendances Reachy 2 :

pip install -e ".[reachy2]"

Étape 1 : Enregistrement

Obtenir l'adresse IP de Reachy 2

Avant de commencer la téléopération et l’enregistrement des données, trouvez l’adresse IP du robot. Nous recommandons vivement de connecter tous les appareils (PC et robot) via Ethernet.

Enregistrement de la présentation

Utilisez la commande lerobot-record de LeRobot pour gérer les sessions d’enregistrement. Le flux de travail pollen_data_acquisition_server documenté précédemment ici n’est plus disponible.

Lors de l’utilisation de l’application de téléopération VR Reachy 2, choisissez « Standard session ». L’application VR contrôle le mouvement du robot, tandis que lerobot-record gère le jeu de données et démarre et arrête les épisodes.

Enregistrer avec lerobot-record

Reachy 2 est entièrement pris en charge par les fonctionnalités d’enregistrement de LeRobot.

Exemple : démarrer un enregistrement sans la base mobile : Ajoutez d'abord reachy2 et reachy2_teleoperator aux imports du script d'enregistrement. Vous pouvez ensuite utiliser la commande suivante :

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

Options spécifiques

Aperçu de la configuration étendue (toutes les options incluses) :

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

Détermine si LeRobot robot.send_action() envoie des commandes au robot. Doit être défini sur false lors de l'utilisation de l'application de téléopération VR, car l'application envoie déjà des commandes.

--teleop.use_present_position

Déterminer si le téléopérateur lit l'objectif ou la position actuelle du robot. Doit être défini sur true si un Reachy 2 conforme est utilisé pour en contrôler un autre.

Utilisez les parties pertinentes

Selon nos tests initiaux, l’enregistrement de tous les articulations alors que seules certaines sont en mouvement peut réduire la qualité du modèle avec certaines politiques. Pour éviter cela, vous pouvez exclure des parties spécifiques de l’enregistrement et de la lecture à l’aide de :

--robot.with_<part>=false

avec <part> étant l’un des éléments suivants : mobile_base, l_arm, r_arm",neck,antennas`. Il détermine si la partie correspondante est enregistrée dans les observations. Vrai si non défini.

Par défaut, toutes les parties sont enregistrées.

Le même mécanisme par partie est également disponible dans reachy2_teleoperator.

--teleop.with\_<part>

avec <part> étant l'un des éléments suivants : mobile_base, l_arm, r_arm",neck,antennas`. Détermine si la partie correspondante est enregistrée dans les actions. Vrai si non défini.

Important : au sein d'une session donnée, les parties activées doivent correspondre entre le robot et le téléopérateur. Par exemple, si le robot est exécuté avec --robot.with_mobile_base=false, le téléopérateur doit désactiver la même partie --teleoperator.with_mobile_base=false.

Utilisez les caméras pertinentes

Vous pouvez faire de même pour les caméras. Activez ou désactivez chaque caméra avec les paramètres par défaut en utilisant :

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

Par défaut, aucune caméra n'est enregistrée, tous les arguments de caméra sont définis sur false. Si vous le souhaitez, vous pouvez utiliser des paramètres width et height personnalisés pour les caméras de Reachy 2 à l'aide de l'argument --robot.camera_width & --robot.camera_height :

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

Cela modifiera la résolution des trois caméras robot par défaut (activées par les arguments booléens ci-dessus).

Si vous le souhaitez, vous pouvez ajouter des caméras supplémentaires autres que celles du robot comme d'habitude avec :

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

Étape 2 : Relecture

Assurez-vous que le robot est configuré avec les mêmes pièces que le jeu de données :

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

Étape 3 : Entraînement

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

Étape 4 : Évaluer

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

Sections déplacées :

[ (Facultatif mais recommandé) Installer pollen_data_acquisition_server ]

[ Option 1 : utilisation du serveur d’acquisition de données Pollen (recommandé pour la téléopération VR) ]

[ Option 2 : utiliser lerobot.record ]