lerobot/docs/source/reachy2.mdx

# Reachy 2

## Teleoperate Reachy 2

Currently, two ways of teleoperating Reachy 2 are available:

- teleoperation through Pollen Robotics VR teleoperation, which is not included in LeRobot.
- teleoperation using a Reachy 2 robot to control another one

We will work on other teleoperators directly included soon!

## Setup

### Prerequisites

- On your robot, check the services images are meeting the minimal versions:
  - **reachy2-core >= 1.7.5.2**
  - **webrtc >= 2.0.1.1**

Then, if you want to use VR teleoperation:

- Install [Reachy 2 teleoperation application](https://docs.pollen-robotics.com/teleoperation/teleoperation-introduction/discover-teleoperation/).
  The teleoperation version must be **>=v1.2.0**

We advise to have one computer running the teleoperation (requires Windows), while another one is running the recording session with LeRobot.

### Install LeRobot

Follow the [installation instructions](https://github.com/huggingface/lerobot#installation) to install LeRobot.

Install LeRobot with Reachy 2 dependencies (reachy2-sdk is required):

```bash
pip install -e ".[reachy2]"
```

### Get Reachy 2 IP address

Before starting teleoperation and data recording, you need to find the [robot IP address](https://docs.pollen-robotics.com/getting-started/setup-reachy2/connect-reachy2/).
We strongly advise to get all your devices (computer, robot) plugged through ethernet cables.

### (Optional but recommended) Install pollen_data_acquisition_server

The installation of the data acquisition server depends on the way you decide to manage your recording sessions for Reachy 2.
The easier way in currently to use this server, so that you can control the session directly from the VR teleoperation application.

> This step is meant for VR teleoperation only

In your LeRobot environment, install the server from source:

```bash
git clone https://github.com/pollen-robotics/pollen_data_acquisition_server.git
cd pollen_data_acquisition_server
pip install -e .
```

Find the [pollen_data_acquisition_server documentation here](https://github.com/pollen-robotics/pollen_data_acquisition_server).

## Step 1: Recording

There are two ways of managing recording sessions using the teleoperation application for Reachy 2:

- using the included data acquisition server for Reachy 2 (recommended for VR teleoperation): the teleoperation application does manage the session management, requesting LeRobot to start or stop an episode, in addition to controlling the robot's movements.
- using the LeRobot record script: LeRobot is in charge of the session management, and decides when to start and stop an episode. If using the VR teleoperation application, the application is only used to control the robot's movements.

### Option 1: Using Pollen data acquisition server (recommended)

Make sure you have installed pollen_data_acquisition_server, as explained in the Setup section.

Launch the data acquisition server to be able to manage your session directly from the teleoperation application:

```bash
python -m pollen_data_acquisition_server.server
```

Then get into the teleoperation application and choose "Data acquisition session".
You can finally setup your session by following the screens displayed.

### Option 2: Using lerobot.record

Reachy 2 is supported as the other robots by the record features.
If you chose this option but still want to use the VR teleoperation application, choose "Standard session" in the app.

Here is an example of a record command, without mobile base:

```bash
python -m 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 \
    --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 \
    --display_data=true
```

#### Specific Options

An extended setup for Reachy 2 would look like:

```bash
python -m 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.disable_torque_on_disconnect=false \
    --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 \
    --display_data=true
```

##### `--robot.use_external_commands`

Determine whether LeRobot robot.send_action() sends commands to the robot.
**Must** be set to false while using the VR teleoperation application, as the app already sends commands.

##### `--teleop.use_present_position`

Determine whether the teleoperator reads the goal or present position of the robot.
Must be set to true if a compliant Reachy 2 is used to control another one.

##### Use the relevant parts

From our first tests, we saw that recording all the joints with some policies while only some of them are moving does reduce the quality of the models.
That is why you can choose not to record / replay a part using the argument `--robot.with_{part}=false`,
with part being one of : "mobile_base", "l_arm", "r_arm", "neck", "antennas".
By default, all parts are recorded.

`--robot.with_{part}` _(with part being one of : "mobile_base", "l_arm", "r_arm", "neck", "antennas")_
Determine whether the corresponding part is recorded in the observations. True if not set.

The same has been done for reachy2_teleoperator.

`--teleop.with_{part}` _(with part being one of : "mobile_base", "l_arm", "r_arm", "neck", "antennas")_
Determine whether the corresponding part is recorded in the actions. True if not set.

> Note that for a session, the robot and teleoperator used parts must match.

##### Use the relevant cameras

You can do the same for the cameras, where only the teleop cameras are recording by default, setting the arguments:
`--robot.with_left_teleop_camera`, `--robot.with_right_teleop_camera` and `--robot.with_torso_camera` to true or false.

## Step 2: Replay

Make sure the robot is configured with the same parts as the dataset:

```bash
python -m 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
    --display_data=true
```

## Step 3: Train

```bash
python -m lerobot.scripts.train \
  --dataset.repo_id=pollen_robotics/record_test \
  --policy.type=act \
  --output_dir=outputs/train/reachy2_test \
  --job_name=reachy2 \
  --policy.device=mps \
  --wandb.enable=true \
  --policy.repo_id=pollen_robotics/record_test_policy
```

### Step 4: Evaluate

```bash
python -m lerobot.record \
  --robot.type=reachy2 \
  --robot.ip_address=192.168.0.200 \
  --display_data=false \
  --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
```