RoboColosseum

RoboColosseum é um benchmark distribuído do mundo real para avaliar políticas de robôs de uso geral em robôs físicos implantados em ambientes não controlados. As avaliações são executadas em configurações padronizadas: humanóides Unitree G1, YAM bimanual, braços Franka na configuração DROID e SO-101. Cada execução de avaliação, incluindo falhas, é publicada no Hugging Face Hub no formato LeRobot.

Esta página explica como preparar uma política do LeRobot para suas duas trilhas de avaliação e como conectá-la aos robôs do RoboColosseum. Para que uma política seja avaliada, inscreva-se no site do RoboColosseum.

• Artigo: RoboColosseum: Evaluating Physical Intelligence at Scale In-The-Wild
• GitHub: RoboColosseum/RoboColosseum
• Site do projeto: robocolosseum.ai
• Classificação: robocolosseum.ai/leaderboard
• Conjunto de dados: coleção de conjuntos de dados RoboColosseum

Visão geral

Configuração física

Cada site utiliza a mesma configuração de hardware para uma encarnação. Da esquerda para a direita na figura: Bimanual YAM, SO-101, Franka na configuração DROID e Unitree G1. Os nomes das câmeras são as chaves observation.images.* nos conjuntos de dados da trilha Fine-tune.

As estações SO-101 e Bimanual YAM também incluem um laptop com GPU RTX 5090 e uma estação de energia portátil de 700 W. A inferência da política é executada localmente nesse laptop ou remotamente por meio de um endpoint hospedado em um servidor.

Tarefas disponíveis

A Trilha de Fine-tuning possui 20 tarefas, 5 por embodiment. Cada tarefa é um dataset LeRobot v3.0 separado no Hub, gravado com 100 episódios:

As instruções do Open Track são redigidas por um avaliador no momento.

Conjunto de dados

Baixe todos os 20 conjuntos de dados da Trilha de Fine-tuning para ./data/RoboColosseum, uma pasta por tarefa. O conjunto completo tem cerca de 35 GB: SO-101 1,4 GB, Franka 4,6 GB, Bimanual YAM 5,9 GB e Unitree G1 22,7 GB.

for task in so101-cube-drawer so101-remove-screwdriver so101-stack-bowls so101-stack-cubes so101-upright-bottle \
            droid-close-laptop droid-mug-on-coaster droid-open-drawer droid-put-marker-pen droid-towel-in-basket \
            yam-cups yam-drawer yam-dustpan yam-microwave yam-tray \
            g1-carry-box g1-fold-towel g1-hang-keys g1-load-clothes-washing-machine g1-plate-into-rack; do
  hf download "RoboColosseum/${task}" --repo-type dataset --local-dir "./data/RoboColosseum/${task}"
done

Para baixar apenas algumas tarefas, mantenha apenas esses nomes na lista. Cada pasta é um dataset LeRobot autossuficiente. Carregue um passando sua pasta como root:

from lerobot.datasets import LeRobotDataset

dataset = LeRobotDataset(
    "RoboColosseum/so101-stack-bowls",
    root="./data/RoboColosseum/so101-stack-bowls",
)

Sem root, o conjunto de dados é baixado do Hub no primeiro uso.

Instalação

Instale o Policy Server no computador que executa seu modelo:

git clone https://github.com/RoboColosseum/robocolosseum-policy-server.git
cd robocolosseum-policy-server
uv sync --extra demo

Sites de robôs instalam o Robot Client no computador conectado ao robô, onde <robot_type> é so101, franka ou yam:

git clone https://github.com/RoboColosseum/robocolosseum-client.git
cd robocolosseum-client
uv sync --extra <robot_type>

Both need Python 3.10 or newer and [uv](https://docs.astral.sh/uv/). The Robot Client also needs FFmpeg to export recordings. On SO-101, the Robot Client drives the arm with LeRobot's `so101_follower` driver, which needs Python 3.12: follow the Client's [SO-101 guide](https://github.com/RoboColosseum/robocolosseum-client/blob/main/docs/so101.md) instead.

Avaliação

As avaliações são executadas nos robôs do RoboColosseum. Depois que você aplica, a equipe do RoboColosseum conecta sua política de uma das duas formas: você hospeda um Policy Server em sua própria máquina de inferência, ou você entrega um checkpoint que eles servem em uma máquina ao lado do robô.

Os testes Open Track usam dois programas:

Sirva sua política

No checkout do Policy Server, crie a configuração e defina a URL do Router e o token do Policy Server que você recebe da equipe do RoboColosseum:

cp configs/policy.yaml.example configs/policy.yaml

url: wss://router.example.com:8443
token: pol_replace_with_token_from_router_ui

Verifique a conexão sem enviar ações. Quando o Router corresponde um Robot Client ao seu servidor, a instrução da tarefa, o estado das juntas e da garra e as imagens da câmera são exibidos (as imagens são abertas em janelas do OpenCV, portanto isso requer um display gráfico):

uv run --extra demo python examples/test_policy.py --no-enable-action

Em seguida, conecte seu modelo ao Policy Server SDK. Salve isso como serve_policy.py na raiz do repositório:

from colosseum_policy_server import ColosseumPolicySDK
from your_policy import load_model  # Replace with your own model loader.


def main():
    model = load_model()

    with ColosseumPolicySDK.from_yaml("configs/policy.yaml") as sdk:
        print("Connected to Router. Waiting for observations...", flush=True)
        while True:
            obs = sdk.get_obs()
            actions = model.infer(obs)
            sdk.send_action(actions, observation=obs)


if __name__ == "__main__":
    main()

model.infer(obs) converte a observação (obs.instruction, obs.state.head_image, obs.state.left_image, obs.state.right_image, obs.state.joints, obs.state.gripper) para as entradas do seu modelo e retorna um array NumPy de forma (horizon, action_dim) no espaço de ações acordado com o Client. Por padrão, isso é joint_position a 15 Hz com no máximo 16 passos por chunk. Inicie o servidor e mantenha-o em execução enquanto os avaliadores usam sua política:

uv run python serve_policy.py

Configurar um robô

No checkout do Robot Client, crie a configuração e edite-a para o seu robô:

cp configs/robot.yaml.example configs/robot.yaml

Em seguida, inicie o Client:

.venv/bin/colosseum-robot configs/robot.yaml

Siga as instruções para inserir uma instrução ou selecionar uma tarefa, execute a tentativa e envie a avaliação. Cada tentativa é registrada e exportada no formato LeRobot.

Código de avaliação do ajuste fino

O código de ajuste fino e avaliação usado para cada encarnação na Trilha de Ajuste Fino é público: SO-101, Franka (DROID), Bimanual YAM e Unitree G1.

Treinamento

Trilha de ajuste fino

Treine em um conjunto de dados de tarefa baixado com --dataset.root:

lerobot-train \
  --dataset.repo_id=RoboColosseum/so101-stack-bowls \
  --dataset.root=./data/RoboColosseum/so101-stack-bowls \
  --policy.type=<policy_type> \
  --policy.repo_id=${HF_USER}/<policy_type>_robocolosseum_so101-stack-bowls \
  --output_dir=./outputs/<policy_type>_robocolosseum_so101-stack-bowls

A configuração exata da política, o mapeamento de câmeras, a representação de ações e a receita de treinamento dependem da política que está sendo adaptada. Se a sua política espera nomes de câmeras diferentes, mapeie-os com --rename_map.

Nota: as baselines G0.5 e LingBot-VLA 2.0 foram ajustadas com seu código original, GalaxeaVLA @ 89f2322 e lingbot-vla-v2 @ be969b8.

Abrir Track

O Open Track avalia um checkpoint congelado em tarefas do mundo real. Nenhum treinamento é realizado nos dados de avaliação do RoboColosseum Open Track.

Se sua política ainda não suporta a incorporação-alvo, primeiro adapte-a em dados públicos de robôs para essa incorporação e, em seguida, congele o checkpoint resultante antes da avaliação. Conjuntos de dados públicos de inicialização recomendados:

allenai/MolmoAct2-SO100_101-Dataset lista os conjuntos de dados LeRobot SO-100 e SO-101 usados para treinar o MolmoAct2, com anotações de linguagem por episódio. Baixe a lista dos repositórios de origem com:

hf download allenai/MolmoAct2-SO100_101-Dataset repo_list.json \
  --repo-type dataset \
  --local-dir ./data/molmoact2_so100_101

Cada entrada em repo_list.json é um ID de dataset do Hub prefixado com lerobot: (por exemplo, lerobot:<user>/<dataset>). Selecione os datasets compatíveis com SO-100 / SO-101 da lista e treine com eles. Muitos deles usam o formato LeRobot v2.1: converta-os para v3.0 antes de carregá-los (veja Usando LeRobotDataset).

O DROID é disponibilizado no formato RLDS. Converta-o para um dataset LeRobot seguindo o exemplo do DROID em Porting Large Datasets e, em seguida, treine no dataset convertido com lerobot-train.

O conjunto de dados Bimanual YAM funciona diretamente com lerobot-train:

lerobot-train \
  --dataset.repo_id=allenai/MolmoAct2-BimanualYAM-Dataset \
  --policy.type=<policy_type> \
  --policy.repo_id=${HF_USER}/<policy_type>_bimanual_yam \
  --output_dir=./outputs/<policy_type>_bimanual_yam

A etapa de bootstrap apenas torna a política compatível com a incorporação-alvo. O checkpoint submetido à Open Track permanece congelado durante a avaliação.

Envio para o ranking

As pontuações são publicadas no RoboColosseum leaderboard. Para ter uma política avaliada, inscreva-se no site do RoboColosseum. O protocolo para cada trilha:

• Trilha de ajuste fino: cada política é ajustada com base nas mesmas 100 demonstrações de uma tarefa e, em seguida, realiza 25 tentativas. Os sucessos completos e o progresso em marcos são reportados.
• Trilha aberta: os avaliadores veem duas políticas anonimizadas tentando a mesma instrução no mesmo robô e na mesma cena, e escolhem a execução melhor ou declaram um empate. As avaliações são ajustadas a partir de todas as comparações naquele robô e exibidas com sua incerteza.