# 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)).

O RoboTwin 2.0 é um **benchmark de manipulação com dois braços em larga escala** construído sobre o motor de física SAPIEN. Ele fornece um protocolo de avaliação padronizado para políticas robóticas bimanuais em 50 tarefas (conforme o `main` upstream), com forte randomização de domínio (desordem, iluminação, fundo, altura da mesa e instruções em linguagem natural).

- Artigo: [RoboTwin 2.0: Um Gerador de Dados Escalável e um Benchmark com Forte Randomização de Domínio para Manipulação Robótica Bimanual Robusta](https://arxiv.org/abs/2506.18088)
- GitHub: [RoboTwin-Platform/RoboTwin](https://github.com/RoboTwin-Platform/RoboTwin)
- Classificação: [robotwin-platform.github.io/leaderboard](https://robotwin-platform.github.io/leaderboard)
- Conjunto de dados: [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)

## Visão geral

| Propriedade      | Valor                                                    |
| ------------- | -------------------------------------------------------- |
| Tarefas         | 50 tarefas de manipulação com dois braços                           |
| Robô         | Aloha-AgileX bimanual (14 GDL, 7 por braço)                |
| Espaço de ações  | 14-dim espaço conjunto, contínuo em `[-1, 1]`              |
| Câmeras       | `head_camera`, `left_camera`, `right_camera`             |
| Simulador     | SAPIEN (não MuJoCo)                                      |
| Protocolo de avaliação | 100 episódios/tarefa, 50 demonstrações demo_clean          |
| Configurações de avaliação | **Fácil** (`demo_clean`) e **Difícil** (`demo_randomized`) |

## Tarefas disponíveis

O RoboTwin 2.0 inclui 50 tarefas de manipulação com braços duplos em seu diretório `envs/` no repositório de origem. A lista canônica é a tupla `ROBOTWIN_TASKS` em `src/lerobot/sim/integrations/robotwin.py`, espelhada literalmente do repositório de origem. Exemplos de tarefas:

| Tarefa                     | Nome da CLI                 | Categoria          |
| ------------------------ | ------------------------ | ----------------- |
| Bata no bloco com o martelo   | `beat_block_hammer`      | Uso de ferramentas          |
| Clique no sino / despertador | `click_bell`             | Impressão de precisão   |
| Blocos da pilha (2 / 3)     | `stack_blocks_two/three` | Empilhamento          |
| Empilhar tigelas (2 / 3)      | `stack_bowls_two/three`  | Empilhamento          |
| Bloco de passagem de bastão / microfone     | `handover_block`         | Coord. bimanual   |
| Leve a panela                 | `lift_pot`               | Levantamento bimanual     |
| Agite o frasco             | `shake_bottle`           | Movimento contínuo |
| Alternar              | `turn_switch`            | Objeto articulado   |
| Selo de carimbo               | `stamp_seal`             | Local de precisão   |
| Objeto de varredura              | `scan_object`            | Manipulação móvel.     |

Passe uma lista separada por vírgulas para `--env.task` para executar várias tarefas em uma única varredura de avaliação.

  `open_laptop` está atualmente quebrado no upstream (o `check_success()` dele usa `self.arm_tag`, que só é definido no caminho do expert scriptado `play_once()` e, portanto, não está disponível durante a avaliação normal da política). Evite-o até que o bug no upstream seja corrigido, ou aplique um patch na tarefa para definir `self.arm_tag = "left"` como padrão em `load_actors()`.

## Conjunto de dados

O conjunto de dados RoboTwin 2.0 está disponível no formato **LeRobot v3.0** no Hugging Face Hub:

```
lerobot/robotwin_unified
```

Ele contém mais de 100.000 trajetórias pré-coletadas em todas as 50 tarefas (79,6 GB, licença Apache 2.0). Não é necessária conversão de formato — ele já está no esquema LeRobot v3.0 correto, com observações em vídeo e rótulos de ação.

Você pode carregá-lo diretamente com a biblioteca HF Datasets:

```python
from datasets import load_dataset

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

## Instalação

RoboTwin 2.0 requer **Linux** com uma GPU NVIDIA (SAPIEN renderiza com Vulkan). Seus planejadores, CuRobo e pytorch3d, compilam código CUDA contra o torch 2.7.1, que não corresponde ao torch do LeRobot, portanto o RoboTwin é executado em seu próprio ambiente atrás do `lerobot-env-server` e o lado da política apenas precisa do LeRobot.

### Imagem servida (recomendado)

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

A primeira execução compila o estágio `robotwin_native` do `docker/Dockerfile.sim` (cerca de 20 minutos, principalmente pytorch3d e CuRobo). Em uma máquina pequena, compile a imagem você mesmo primeiro com memória limitada; o servidor a reutilizará em seguida:

```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 .
```

onde `8.6` é a capacidade de computação da sua GPU. Adicione `--env.server.endpoint=tcp/127.0.0.1:7448` aos comandos de avaliação abaixo.

### Ambiente nativo

Para executar o servidor sem Docker, reproduza o estágio `robotwin_native` do `docker/Dockerfile.sim` em um ambiente virtual separado, que é a receita testada: o CUDA 12.8 `nvcc`, torch 2.7.1, o commit e os assets fixados do RoboTwin, CuRobo v0.7.8, e os patches de mplib e SAPIEN do RoboTwin. Em seguida, instale o LeRobot com `--no-deps` mais `docker/sim/requirements.txt`, e remova `--docker=true` do comando acima (veja [Simulação: local ou servida](./simulation)).

## Avaliação

### Avaliação padrão (recomendado)

Avalie uma política em uma única tarefa com o protocolo oficial (100 episódios):

```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
```

### Verificação rápida de tarefa única

```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
```

### Varredura multi-tarefa

Avalie em várias tarefas em uma única execução:

```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
```

### Benchmark completo (todas as 50 tarefas)

```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` é omitido intencionalmente acima devido ao bug de `self.arm_tag` no upstream (veja a seção **Tarefas disponíveis**). Adicione-o novamente assim que a correção no upstream for aplicada.

## Configuração da câmera

Por padrão, todas as três câmeras são incluídas:

| Chave da câmera     | Descrição                    |
| -------------- | ------------------------------ |
| `head_camera`  | Visão superior montada no torso    |
| `left_camera`  | Câmera de pulso no braço esquerdo  |
| `right_camera` | Câmera de pulso do braço direito |

Para usar um subconjunto de câmeras, substitua `--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
```

## Referência de configuração de ambiente

Principais parâmetros para `RoboTwinEnvConfig`:

| Parâmetro            | Padrão                                  | Descrição                        |
| -------------------- | ---------------------------------------- | ---------------------------------- |
| `task`               | `"beat_block_hammer"`                    | Nome(s) de tarefa(s) separados por vírgula       |
| `fps`                | `25`                                     | FPS da simulação                     |
| `episode_length`     | `1200`                                   | Máximo de etapas por episódio              |
| `obs_type`           | `"pixels_agent_pos"`                     | `"pixels"` ou `"pixels_agent_pos"` |
| `camera_names`       | `"head_camera,left_camera,right_camera"` | Câmeras ativas separadas por vírgulas     |
| `observation_height` | `240`                                    | Altura em pixels da câmera                |
| `observation_width`  | `320`                                    | Largura do pixel da câmera                 |

## Envio para o ranking

Os resultados podem ser enviados para o [RoboTwin 2.0 leaderboard](https://robotwin-platform.github.io/leaderboard). O protocolo oficial exige:

- Treinamento com 50 `demo_clean` demonstrações por tarefa
- Avaliando 100 episódios por tarefa
- Relatando a taxa de sucesso separadamente para as configurações **Fácil** (`demo_clean`) e **Difícil** (`demo_randomized`)

Para as instruções de envio, consulte a [documentação do RoboTwin 2.0](https://robotwin-platform.github.io/doc/).

