RoboTwin 2.0

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
• GitHub : RoboTwin-Platform/RoboTwin
• Classement : robotwin-platform.github.io/leaderboard
• Jeu de données : lerobot/robotwin_unified

Aperçu

Tâches disponibles

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

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` is currently broken upstream (its `check_success()` uses `self.arm_tag`, which is only set inside the scripted-expert `play_once()` path and therefore unavailable during normal policy eval). Avoid it until the upstream bug is fixed, or patch the task to default `self.arm_tag = "left"` in `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 :

from datasets import load_dataset

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

Installation

L'intégration RoboTwin actuelle est cassée et n'est pas prise en charge avec la pile PyTorch 2.15 par défaut de LeRobot. Son job CI de benchmark est temporairement désactivé. Les instructions ci-dessous décrivent la configuration legacy ; elles ne constituent pas une recette d'installation fonctionnelle pour les dépendances par défaut actuelles. Les correctifs de compatibilité et l'isolation des dépendances du simulateur sont reportés à PR #4888.

RoboTwin 2.0 nécessite Linux avec un GPU NVIDIA (CUDA 12.1 recommandé). L’installation prend environ 20 minutes.

1. Créer un environnement conda

conda create -n robotwin python=3.12 -y
conda activate robotwin

2. Installer LeRobot

git clone https://github.com/huggingface/lerobot.git
cd lerobot
pip install -e "."

3. Installer RoboTwin 2.0

git clone https://github.com/RoboTwin-Platform/RoboTwin.git
cd RoboTwin
bash script/_install.sh
bash script/_download_assets.sh

Le script d'installation gère toutes les dépendances Python, y compris SAPIEN, CuRobo, mplib et pytorch3d.

If the automated install fails, install manually:

Copié

pip install -r requirements.txt
pip install "git+https://github.com/facebookresearch/pytorch3d.git@stable"
cd envs && git clone https://github.com/NVlabs/curobo.git && cd curobo
pip install -e . --no-build-isolation

Appliquez ensuite le correctif requis pour mplib : dans mplib/planner.py, ligne 807, supprimez or collide de la condition.

4. Ajouter RoboTwin à PYTHONPATH

Les modules de tâches RoboTwin doivent être importables par LeRobot. Depuis le répertoire RoboTwin/ :

export PYTHONPATH="${PYTHONPATH}:$(pwd)"

Ajoutez ceci à votre profil de shell pour le rendre permanent.

Évaluation

Évaluation standard (recommandée)

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

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

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 :

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)

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` is intentionally omitted above because of the upstream `self.arm_tag` bug (see the **Available tasks** section). Re-add it once the upstream fix lands.

Configuration de la caméra

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

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

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 :

Soumission au classement

Les résultats peuvent être soumis au classement RoboTwin 2.0. 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.