# RoboTwin 2.0

  The commands below run the simulator locally. To keep its dependencies away from your policy's, serve it instead with `lerobot-env-server --config_path=docker/sim/configs/robotwin.yaml --sim.task= --docker=true`, where `` is the command's `--env.task`, and add `--env.server.endpoint=tcp/127.0.0.1:7448` to the command. A server runs the task it was started with (see [Simulation: local or served](./simulation)).

RoboTwin 2.0 est un **benchmark de manipulation à double bras à grande échelle** construit sur le moteur physique SAPIEN. Il fournit un protocole d'évaluation standardisé pour les politiques robotiques bimanuelles sur 50 tâches (à ce jour, en amont de `main`) avec une forte randomisation de domaine (désordre, éclairage, arrière-plan, hauteur de la table et instructions en langage naturel).

- Article : [RoboTwin 2.0 : un générateur de données et un benchmark évolutifs avec une randomisation de domaine forte pour une manipulation robotique bimanuelle robuste](https://arxiv.org/abs/2506.18088)
- GitHub : [RoboTwin-Platform/RoboTwin](https://github.com/RoboTwin-Platform/RoboTwin)
- Classement : [robotwin-platform.github.io/leaderboard](https://robotwin-platform.github.io/leaderboard)
- Jeu de données : [lerobot/robotwin_unified](https://huggingface.co/datasets/lerobot/robotwin_unified)

![RoboTwin 2.0 benchmark overview](https://www.aitntnews.com/pictures/2025/7/8/9a7f79cb-5ba9-11f0-8581-fa163e47d677.png)

## Aperçu

| Propriété      | Valeur                                                    |
| ------------- | -------------------------------------------------------- |
| Tâches         | 50 tâches de manipulation à deux bras                           |
| Robot         | Aloha-AgileX bimanual (14 DDL, 7 par bras)                |
| Espace d'actions  | Espace articulé 14 dimensions, continu dans `[-1, 1]`              |
| Caméras       | `head_camera`, `left_camera`, `right_camera`             |
| Simulateur     | SAPIEN (et non MuJoCo)                                      |
| Protocole d'évaluation | 100 épisodes/tâche, 50 démonstrations demo_clean          |
| Paramètres d'évaluation | **Facile** (`demo_clean`) et **Difficile** (`demo_randomized`) |

## Tâches disponibles

RoboTwin 2.0 fournit 50 tâches de manipulation à double bras dans son répertoire `envs/` en amont. La liste canonique est le tuple `ROBOTWIN_TASKS` dans `src/lerobot/sim/integrations/robotwin.py`, reproduit à l'identique depuis le dépôt en amont. Exemples de tâches :

| Tâche                     | Nom de la CLI                 | Catégorie          |
| ------------------------ | ------------------------ | ----------------- |
| Battre le bloc au marteau   | `beat_block_hammer`      | Utilisation d'outils          |
| Cliquez sur la cloche / l'horloge | `click_bell`             | Presse de précision   |
| Empiler des blocs (2 / 3)     | `stack_blocks_two/three` | Empilement          |
| Empiler les bols (2 / 3)      | `stack_bowls_two/three`  | Empilement          |
| Bloc de passation / micro     | `handover_block`         | Coordination bimanuelle   |
| Soulever le pot                 | `lift_pot`               | Levage bimanuel     |
| Agiter le flacon             | `shake_bottle`           | Mouvement continu |
| Basculer l'interrupteur              | `turn_switch`            | Objet articulé   |
| Sceau               | `stamp_seal`             | Emplacement de la précision   |
| Objet à scanner              | `scan_object`            | Manipulation mobile.     |

Passez une liste séparée par des virgules à `--env.task` pour exécuter plusieurs tâches dans un seul balayage d'évaluation.

  `open_laptop` est actuellement cassé en amont (son `check_success()` utilise `self.arm_tag`, qui n’est défini que dans le chemin d’expert scripté `play_once()` et n’est donc pas disponible lors de l’évaluation normale de la politique). Évitez-le jusqu’à ce que le bug en amont soit corrigé, ou appliquez un correctif à la tâche pour définir par défaut `self.arm_tag = "left"` dans `load_actors()`.

## Jeu de données

Le jeu de données RoboTwin 2.0 est disponible au format **LeRobot v3.0** sur le Hugging Face Hub :

```
lerobot/robotwin_unified
```

Il contient plus de 100 000 trajectoires précollectées pour les 50 tâches (79,6 Go, licence Apache 2.0). Aucune conversion de format n'est nécessaire — il est déjà au schéma LeRobot v3.0 correct, avec des observations vidéo et des étiquettes d'action.

Vous pouvez le charger directement avec la bibliothèque HF Datasets :

```python
from datasets import load_dataset

ds = load_dataset("lerobot/robotwin_unified", split="train")
```

## Installation

RoboTwin 2.0 nécessite **Linux** avec un GPU NVIDIA (SAPIEN utilise Vulkan pour le rendu). Ses planificateurs, CuRobo et pytorch3d, compilent du code CUDA pour torch 2.7.1, ce qui ne correspond pas à la version de torch de LeRobot. Par conséquent, RoboTwin s'exécute dans son propre environnement derrière `lerobot-env-server`, et le côté politique n'a besoin que de LeRobot.

### Image servie (recommandé)

```bash
lerobot-env-server --config_path=docker/sim/configs/robotwin.yaml --sim.task=beat_block_hammer --docker=true
```

La première exécution construit l’étape `robotwin_native` de `docker/Dockerfile.sim` (environ 20 minutes, principalement pytorch3d et CuRobo). Sur une petite machine, construisez d’abord l’image vous-même avec une mémoire limitée ; le serveur la réutilisera ensuite :

```bash
docker build -f docker/Dockerfile.sim --build-arg SIM=robotwin \
  --build-arg MAX_JOBS=1 --build-arg CUROBO_CUDA_ARCHS=8.6 -t lerobot-sim-robotwin:local .
```

où `8.6` est la capacité de calcul de votre GPU. Ajoutez `--env.server.endpoint=tcp/127.0.0.1:7448` aux commandes d'évaluation ci-dessous.

### Environnement natif

Pour exécuter le serveur sans Docker, reproduisez l'étape `robotwin_native` de `docker/Dockerfile.sim` dans un environnement virtuel séparé, qui est la recette testée : le `nvcc` CUDA 12.8, torch 2.7.1, le commit et les assets RoboTwin épinglés, CuRobo v0.7.8, ainsi que les correctifs mplib et SAPIEN de RoboTwin. Installez ensuite LeRobot avec `--no-deps` plus `docker/sim/requirements.txt`, et retirez `--docker=true` de la commande ci-dessus (voir [Simulation : locale ou servie](./simulation)).

## Évaluation

### Évaluation standard (recommandée)

Évaluer une politique sur une tâche unique avec le protocole officiel (100 épisodes) :

```bash
lerobot-eval \
  --policy.path="your-hf-policy-id" \
  --env.type=robotwin \
  --env.task=beat_block_hammer \
  --eval.batch_size=1 \
  --eval.n_episodes=100
```

### Vérification rapide de tâche unique

```bash
lerobot-eval \
  --policy.path="your-hf-policy-id" \
  --env.type=robotwin \
  --env.task=beat_block_hammer \
  --eval.batch_size=1 \
  --eval.n_episodes=5
```

### Balayage multi-tâches

Évaluer sur plusieurs tâches en une seule exécution :

```bash
lerobot-eval \
  --policy.path="your-hf-policy-id" \
  --env.type=robotwin \
  --env.task=beat_block_hammer,click_bell,handover_block,stack_blocks_two \
  --eval.batch_size=1 \
  --eval.n_episodes=100
```

### Benchmarks complets (les 50 tâches)

```bash
lerobot-eval \
  --policy.path="your-hf-policy-id" \
  --env.type=robotwin \
  --env.task=adjust_bottle,beat_block_hammer,blocks_ranking_rgb,blocks_ranking_size,click_alarmclock,click_bell,dump_bin_bigbin,grab_roller,handover_block,handover_mic,hanging_mug,lift_pot,move_can_pot,move_pillbottle_pad,move_playingcard_away,move_stapler_pad,open_microwave,pick_diverse_bottles,pick_dual_bottles,place_a2b_left,place_a2b_right,place_bread_basket,place_bread_skillet,place_burger_fries,place_can_basket,place_cans_plasticbox,place_container_plate,place_dual_shoes,place_empty_cup,place_fan,place_mouse_pad,place_object_basket,place_object_scale,place_object_stand,place_phone_stand,place_shoe,press_stapler,put_bottles_dustbin,put_object_cabinet,rotate_qrcode,scan_object,shake_bottle,shake_bottle_horizontally,stack_blocks_three,stack_blocks_two,stack_bowls_three,stack_bowls_two,stamp_seal,turn_switch \
  --eval.batch_size=1 \
  --eval.n_episodes=100
```

  `open_laptop` est volontairement omis ci-dessus en raison du bug amont `self.arm_tag` (voir la section **Tâches disponibles**). Réintégrez-le une fois que le correctif amont sera disponible.

## Configuration de la caméra

Par défaut, les trois caméras sont incluses :

| Touche caméra     | Description                    |
| -------------- | ------------------------------ |
| `head_camera`  | Vue de dessus fixée au torse    |
| `left_camera`  | Caméra de poignet du bras gauche  |
| `right_camera` | Caméra de poignet du bras droit |

Pour utiliser un sous-ensemble de caméras, écrasez `--env.camera_names` :

```bash
lerobot-eval \
  --policy.path="your-hf-policy-id" \
  --env.type=robotwin \
  --env.task=beat_block_hammer \
  --env.camera_names="head_camera,left_camera" \
  --eval.batch_size=1 \
  --eval.n_episodes=10
```

## Référence de configuration de l'environnement

Paramètres clés de `RoboTwinEnvConfig` :

| Paramètre            | Par défaut                                  | Description                        |
| -------------------- | ---------------------------------------- | ---------------------------------- |
| `task`               | `"beat_block_hammer"`                    | Nom(s) de tâche(s) séparé(s) par des virgules       |
| `fps`                | `25`                                     | FPS de simulation                     |
| `episode_length`     | `1200`                                   | Nombre maximal d'étapes par épisode              |
| `obs_type`           | `"pixels_agent_pos"`                     | `"pixels"` ou `"pixels_agent_pos"` |
| `camera_names`       | `"head_camera,left_camera,right_camera"` | Caméras actives séparées par des virgules     |
| `observation_height` | `240`                                    | Hauteur en pixels de la caméra                |
| `observation_width`  | `320`                                    | Largeur des pixels de la caméra                 |

## Soumission au classement

Les résultats peuvent être soumis au [classement RoboTwin 2.0](https://robotwin-platform.github.io/leaderboard). Le protocole officiel exige :

- Entraînement sur 50 `demo_clean` démonstrations par tâche
- Évaluation de 100 épisodes par tâche
- Taux de réussite signalé séparément pour les configurations **Easy** (`demo_clean`) et **Hard** (`demo_randomized`)

Pour les instructions de soumission, reportez-vous à la [documentation RoboTwin 2.0](https://robotwin-platform.github.io/doc/).