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

O Reachy 2 é um robô humanoide de código aberto desenvolvido pela Pollen Robotics, projetado especificamente para o desenvolvimento de IA encarnada e aplicações no mundo real. Confira o site da Pollen Robotics ou acesse a documentação do Reachy 2 para mais informações sobre a plataforma!

Teleopere o Reachy 2

Atualmente, existem duas formas de teleoperar o Reachy 2:

  • Teleoperação por VR da Pollen Robotics (não incluída no LeRobot).
  • Teleoperação de robô para robô (use um Reachy 2 para controlar outro).

Simulação do Reachy 2

(somente Linux) Você pode executar o Reachy 2 em simulação (Gazebo ou MuJoCo) usando a imagem Docker fornecida.

  1. Instale o Docker Engine.
  2. Executar (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

Se o MuJoCo executar lentamente (baixa frequência de simulação), acrescente -e LD_LIBRARY_PATH="/opt/host-libs:$LD_LIBRARY_PATH" \ ao comando anterior para melhorar o desempenho:

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

Configuração

Pré-requisitos

  • No seu robô, verifique se as imagens de serviço atendem às versões mínimas:
    • reachy2-core >= 1.7.5.2
    • webrtc >= 2.0.1.1

Em seguida, se você quiser usar teleoperação com VR:

Recomendamos o uso de dois computadores: um para teleoperação (requer Windows) e outro para gravação com LeRobot.

Instalar LeRobot

Siga as instruções de instalação para instalar o LeRobot.

Instale o LeRobot com as dependências do Reachy 2:

pip install -e ".[reachy2]"

Etapa 1: Gravação

Obter o endereço IP do Reachy 2

Antes de iniciar a teleoperação e a gravação de dados, localize o endereço IP do robô. Recomendamos fortemente conectar todos os dispositivos (PC e robô) via Ethernet.

Gravação do lançamento

Use o comando lerobot-record do LeRobot para gerenciar sessões de gravação. O fluxo de trabalho pollen_data_acquisition_server documentado anteriormente aqui não está mais disponível.

Ao usar o aplicativo de teleoperação em VR do Reachy 2, escolha “Standard session”. O aplicativo de VR controla o movimento do robô, enquanto o lerobot-record gerencia o conjunto de dados e inicia e encerra os episódios.

Gravar com lerobot-record

O Reachy 2 é totalmente suportado pelos recursos de gravação do LeRobot.

Exemplo: iniciar uma gravação sem a base móvel: Primeiro, adicione reachy2 e reachy2_teleoperator às importações do script de gravação. Em seguida, você pode usar o seguinte 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

Opções Específicas

Visão geral da configuração estendida (incluindo todas as opções):

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 se LeRobot robot.send_action() envia comandos para o robô. Obrigatório definir como false ao usar o aplicativo de teleoperação por VR, pois o aplicativo já envia comandos.

--teleop.use_present_position

Determine se o teleoperador lê o objetivo ou a posição atual do robô. Deve ser definido como true se um Reachy 2 compliant for usado para controlar outro.

Use as partes relevantes

Em nossos testes iniciais, gravar todos os articulações quando apenas algumas estão em movimento pode reduzir a qualidade do modelo com certas políticas. Para evitar isso, você pode excluir partes específicas da gravação e reprodução usando:

--robot.with_<part>=false

com <part> sendo um dos seguintes: mobile_base, l_arm, r_arm",neck,antennas`. Ele determina se a parte correspondente é registrada nas observações. True se não definido.

Por padrão, todas as partes são gravadas.

O mesmo mecanismo por parte também está disponível em reachy2_teleoperator.

--teleop.with\_<part>

com <part> sendo um dos seguintes: mobile_base, l_arm, r_arm",neck,antennas`. Determine se a parte correspondente está registrada nas ações. Verdadeiro se não definido.

Importante: Em uma sessão, as partes habilitadas devem corresponder tanto no robô quanto no teleoperador. Por exemplo, se o robô for executado com --robot.with_mobile_base=false, o teleoperador deve desabilitar a mesma parte --teleoperator.with_mobile_base=false.

Use as câmeras relevantes

Você pode fazer o mesmo para câmeras. Ative ou desative cada câmera com parâmetros padrão usando:

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

Por padrão, nenhuma câmera é gravada, todos os argumentos de câmera são definidos como false. Se desejar, você pode usar parâmetros personalizados de width e height para as câmeras do Reachy 2 usando o argumento --robot.camera_width & --robot.camera_height:

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

Isso alterará a resolução de todas as 3 câmeras padrão do robô (ativadas pelos argumentos bool acima).

Se desejar, você pode adicionar câmeras adicionais, além das do robô, da maneira usual, com:

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

Etapa 2: Replay

Certifique-se de que o robô está configurado com as mesmas partes que o conjunto de dados:

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

Etapa 3: Treinar

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

Etapa 4: Avaliar

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

Seções que foram movidas:

[ (Opcional, mas recomendado) Instale pollen_data_acquisition_server ]

[ Opção 1: Usando o servidor de aquisição de dados do Pollen (recomendado para teleoperação em RV) ]

[ Opção 2: Usando lerobot.record ]

Update on GitHub

←Hope Jr Unitree G1→