DM0.5: VLA open-source para implantar políticas de robótica em uma 4090

O DM0.5 é o modelo Vision-Language-Action (VLA) open-source mais forte que você pode implantar hoje: 4B de parâmetros, licença Apache-2.0, 1º lugar no benchmark RoboDojo (simulação e mundo real) e ajustável em uma única RTX 4090 em cerca de 18 horas. Este guia cobre o fluxo completo com o repositório OpenDM — configuração do Docker, serviço de inferência, registro de dataset e SFT — para que você saia do git clone até um endpoint de política de robô funcionando em uma tarde.

Por que isso importa

Modelos fundacionais de robótica abertos são raros; modelos abertos que superam a concorrência fechada são ainda mais raros. A Dexmal lançou os pesos do DM0.5 (Hugging Face, ModelScope) e o código (GitHub, Apache-2.0) logo depois que o modelo alcançou o topo do RoboDojo, um benchmark neutro de simulação e mundo real conduzido por um consórcio acadêmico sem fins lucrativos. No RoboChallenge Table 30 v2, ele pontua 54.42 (43% de sucesso) contra 31.48 do Pi0.5 (14,3%), e atinge 99,0% no LIBERO. O leaderboard é secundário — o sinal real é que um modelo de 4B consegue isso com uma GPU para inferência e uma 4090 para fine-tuning. Isso muda quem pode construir sobre modelos fundacionais de robótica.

O que é o DM0.5

O DM0.5 é o VLA embodied-native de segunda geração da Dexmal, treinado do zero com 150.000 horas de dados: 50.000 horas de manipulação de robôs reais em alta precisão, mais 100.000 horas de vídeo egocêntrico, com 1M de m² de dados de reconstrução de cenas para reduzir o gap sim-to-real. Quatro decisões de arquitetura se destacam:

Camada de abstração de contexto — memória nativa de até 60 segundos (a maioria dos VLAs mantém menos de 10), para que tarefas longas de múltiplas etapas não percam o estado.
Chain-of-thought embodied — o modelo decompõe uma instrução em subtarefas, planeja a ordem e então executa, em vez de mapear pixels para ações de uma só vez.
Camada de alinhamento de trajetória — aprende a regularidade do movimento em vez de alvos ponto a ponto, o que torna possível a transferência entre diferentes corpos robóticos (cross-embodiment).
Divisão Sys1/Sys2 — controle reativo rápido somado ao planejamento deliberado, robusto contra tremores de câmera e interrupções humanas.

Ele também permite video prompting: mostre ao modelo um clipe com uma demonstração humana e ele executa a tarefa diretamente, sem necessidade de linguagem. Benchmarks vs Pi0.5: LIBERO 99,0% vs 96,9%, RoboTwin2.0 clean 93,6% vs 82,7%, VLA-Arena L0 89,0% vs 64,3%. A inferência roda em cerca de 90ms em uma 4090 e 50ms em uma H100.

Configuração do ambiente: Docker ou local

O repositório recomenda Docker primeiro — ele evita incompatibilidades de versão entre CUDA/PyTorch/flash-attn. Requisitos: Ubuntu 20.04/22.04, driver NVIDIA, Docker, NVIDIA Container Toolkit.

git clone https://github.com/dexmal/opendm.git
cd opendm

docker run -it --rm --gpus all --network host \
  --name opendm --shm-size=16g \
  -v "$PWD":/app/opendm -w /app/opendm \
  dexmal/opendm:latest /bin/bash

# dentro do container
conda activate opendm
pip install -e .

Prefere instalação local? Use um ambiente Conda com Python 3.10, PyTorch do índice cu128 e flash-attn:

conda create -n opendm python=3.10 -y
conda activate opendm
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu128
pip install ninja packaging
MAX_JOBS=2 pip install flash-attn --no-build-isolation
cd opendm && pip install -e .

Há também um backend de inferência rápida (pip install -e ".[fast-infer]") construído sobre TensorRT + Triton + PyTorch FlexAttention; pule-o a menos que precise de baixa latência de inicialização.

Executar a inferência

Baixe o checkpoint base DM05 e inicie o serviço HTTP (porta padrão 7891):

huggingface-cli download Dexmal/DM05 --local-dir ./checkpoints/DM05

script/dm05_launcher.sh \
  --exp opendm/exp/dm05_exp.py \
  --task inference \
  --model-config.model-name-or-path ./checkpoints/DM05 \
  --model-config.chunk-size 50 \
  --inference-config.output-action-dim 14 \
  --inference-config.image-prompts "Head" "Left wrist" "Right wrist" \
  --inference-config.port 7891

Este exemplo usa três fluxos de câmera e um espaço de estado/ação de 14 dimensões. Use /v1/infer para novas integrações (a API legada /process_frame está sendo descontinuada). Consulte o guia de inferência para perfis de robôs, campos de requisição e configuração do backend rápido.

Fazer fine-tuning com os dados do seu robô

Registre seu dataset primeiro, modelando a partir de opendm/dataset/demo.py:

# opendm/dataset/my_robot.py
from opendm.constants.robot import RobotStateDesc, RobotType
from opendm.dataset.register import register_dataset

MY_ROBOT_STATE_DESC = (
    [RobotStateDesc.JOINT] * 6 + [RobotStateDesc.GRIPPER]
    + [RobotStateDesc.JOINT] * 6 + [RobotStateDesc.GRIPPER]
)

register_dataset({
    "my_robot": {
        "jsonl_dir": "./assets/my_robot/",
        "image_dir": "./assets/my_robot/",
        "image_keys": ["images_1", "images_2", "images_3"],
        "image_prompts": ["Head", "Left wrist", "Right wrist"],
        "robot_type": RobotType.ALOHA,
        "state_desc": MY_ROBOT_STATE_DESC,
    },
})

Em seguida, execute o SFT. Oito GPUs são recomendados para o treinamento (uma GPU basta para inferência):

script/dm05_launcher.sh \
  --exp playground/dm05_sft_demo.py \
  --task train --nproc_per_node 8 \
  --data-config.dataset-name my_robot \
  --model-config.model-name-or-path ./checkpoints/DM05 \
  --model-config.chunk-size 50 \
  --trainer-config.num-train-steps 50000

Segundo a Dexmal, uma nova tarefa downstream pode ser ajustada ao nível de especialista em uma RTX 4090 em cerca de 18 horas — uma redução de 60% no custo em relação à geração anterior. O repositório inclui guias de benchmark completos (LIBERO, RoboTwin2.0, VLA-Arena, SO101 LoRA, RoboChallenge Table 30 v2) caso queira reproduzir os números você mesmo.

Dicas práticas

Comece com o dataset de demonstração embutido e o playground/dm05_sft_demo.py antes de usar os dados do seu próprio robô — valide primeiro o formato dos dados, as estatísticas de normalização e o ciclo completo de inferência.
Uma GPU é suficiente para servir a inferência; escale para 8 no treinamento. GPUs 4090 de consumo funcionam para ambos os casos.
Se você tem um braço fora do padrão, registre-o pela configuração de dataset — o DM0.5 já cobre ALOHA, ARX, UR, W1, Unitree G1 e outros, e o mesmo modelo base transfere entre diferentes corpos robóticos.
Para produção, ative o backend rápido e reserve tempo para a exportação ONNX única e a construção do engine TensorRT na primeira execução.
O modelo é robusto contra distúrbios de câmera e interrupções humanas, mas reteste esses modos de falha no seu próprio equipamento antes de implantar.

Para um contexto mais amplo sobre como levar modelos embodied para implantações reais, veja nosso artigo sobre o gargalo da produção em massa da IA embodied, e para ferramentas de ambientes de treinamento, confira o EnvHarness.

Recursos

Código: github.com/dexmal/opendm (Apache-2.0)
Pesos: Hugging Face Dexmal/DM05 | ModelScope
Blog técnico: dexmal.com/blog/dm0.5
Benchmark RoboDojo: github.com/RoboDojo-Benchmark/RoboDojo (arXiv:2607.04434)
MaaS: maas.dexmal.com

FAQ

P: Posso testar o DM0.5 sem ter um robô?
R: Sim. O repositório inclui benchmarks de simulação (LIBERO, RoboTwin2.0) que rodam em uma única GPU dentro da imagem Docker, então você pode avaliar o checkpoint antes de mexer no hardware.

P: Qual GPU preciso para fazer fine-tuning do DM0.5?
R: Uma RTX 4090 é suficiente — cerca de 18 horas para uma nova tarefa downstream em nível de especialista. Escale para 8 GPUs (A100/H100/H20) para treinamentos maiores.

P: O DM0.5 funciona com o meu braço robótico?
R: Ele vem com suporte multi-embodiment cobrindo ALOHA, ARX, UR, W1, Unitree G1 e outros. Para um braço novo, registre seu layout de juntas e garra em uma configuração de dataset e faça o fine-tuning.