Qual Política VLA Você Deve Treinar em 2026?

Cinco políticas são treináveis em um braço da classe SO-100 hoje. Elas diferem por um fator de 24 na inferência latência, 37 na contagem de parâmetros e 12 no custo de uma execução, e se você pode enviar o resultado. Cinco cartões de modelo não resolverão isso: nenhum responde à pergunta que você tem, qual devo executar primeiro?

Cada número abaixo foi lido nos artigos, repositórios e cartões em agosto de 2026. Os números da plataforma vêm do catálogo de políticas AY-Robots; onde os dois discordam, ambos são mostrados.

A tabela de decisão

Os cinco candidatos

Todos os cinco são políticas: quadros de câmera, posições de junta e, para quatro deles, uma instrução de linguagem, mapeada para um conjunto de alvos de junta futuros. O que os separa é o quanto foi aprendido antes de você chegar.

GR00T N1.7

O atual modelo de visão-linguagem-ação da NVIDIA, com cerca de 3 bilhões de parâmetros, aproximadamente 40 milhões treinados durante ajuste fino. O repositório lista as diferenças em relação ao N1.6: backbone de um modelo Eagle fornecido para Cosmos-Reason2-2B no Qwen3-VL, camadas de difusão de 32 para 16, dimensões de estado e ação de 29 para 132, horizonte de ação de 16 para 40.

O que importa em um braço pequeno é o espaço de ação relativo do efetor final: o N1.7 prevê as diferenças em relação à pose atual, o que permite que 20 mil horas de vídeo humano EgoScale sejam transferidas para uma política de robô. Especificações na página do N1.7, procedimento no guia N1.7 no SO-100.

GR00T N1.5

Mesma escala de 3 B, backbone Eagle 2, SigLip2 e T5, cabeça DiT de flow-matching. Existe para estender um que você já possui. Duas coisas o tornam uma opção padrão ruim: os pesos carregam a licença não comercial unidirecional da NVIDIA, e as versões atuais do LeRobot removeram o suporte ao N1.5. Veja .

Pi0.5

O VLA de Physical Intelligence com VLA, tipo de política pi05. O artigo apresenta um VLM de 2 B inicializado a partir de PaliGemma mais um especialista em ação de 300 M, controlando o robô a 50 Hz; a configuração pi05 do LeRobot assume um bloco de 50 passos por padrão, um segundo nessa taxa. O ponto de venda são lugares nunca vistos: cerca de 400 horas de manipulação móvel em casas reais, e um estudo de escalonamento em 3, 12, 22, 53, 82 e 104 locais, onde o modelo de 104 locais correspondeu a um controle treinado nas próprias casas de teste.

Um limite, declarado no lerobot/pi05_base cartão: a porta transporta apenas o cabeçalho de ação correspondente ao fluxo. A previsão de subtarefas, a tokenização de ações e o RL não foram lançados upstream, e o openpi diz o mesmo sobre seu próprio repositório. A página do Pi0.5 e o guia do Pi0.5 no SO-100 têm o resto.

SmolVLA

450 M parâmetros, cerca de 100 M no especialista em ação, no SmolVLM-2 com o VLM congelado e apenas suas primeiras 16 camadas do modelo de linguagem usadas. O pré-treinamento foi feito com dados da comunidade: 481 conjuntos de dados, 10.6 M quadros, dos mesmos braços baratos que você usa. O único VLA aqui que cabe em uma placa de 24 GB, e o único com um piso de 30 episódios. Veja a página do SmolVLA.

ACT

Não é um modelo de base. O Action Chunking Transformer da ALOHA tem cerca de 80 M de parâmetros treinados do zero por tarefa, em 50 demonstrações a 50 Hz. O artigo relata seis tarefas bimanuais reais de aproximadamente dez minutos de demonstrações cada, com 80 a 90 por cento nos exemplos que destaca. A sua ideia, agrupamento de ações, está presente em todos os modelos desta página, e a sua ablação ainda mede o efeito melhor: em duas tarefas simuladas com o agrupamento temporal desativado, o sucesso aumenta de 1 por cento em k=1 para 44 por cento em k=100. A página do ACT tem o resto.

O que os benchmarks realmente dizem

LIBERO é o único benchmark sobre o qual três destes cinco relatam: tarefas condicionadas por linguagem em um Franka Panda simulado, dividido nas quatro suítes abaixo, com dez tarefas cada. A NVIDIA executou 200 testes por suíte.

SimplerEnv mostra a dispersão, o que LIBERO não faz. NVIDIA compara N1.7 com N1.6, o mais próximo publicamente de um "delta geracional".

A linha Bridge é a útil: 5.7 pontos ganhos em média enquanto put_eggplant_in_basket perdeu 36 e put_eggplant_in_sink caiu de 33 para 2. Uma nova geração move a distribuição em vez de erguê-la, então se sua tarefa se encontra onde N1.7 regrediu, a média não diz nada.

Dos cinco, apenas o artigo SmolVLA relata um braço da classe SO-100: 78.3 por cento para SmolVLA e 61.7 para Pi0 em três tarefas, ambos multi-tarefa, contra 48.3 para ACT treinado em tarefa única, o que não é comparável. O emparelhamento limpo é ambos em tarefa única em SO-101 pick-and-place: 90 contra 70 em distribuição, 50 contra 40 fora dela. Compare em ACT contra SmolVLA e Pi0.5 contra SmolVLA, ou navegue a arena.

Latência e custo decidem a implantação

Latência de inferência é a restrição que as pessoas descobrem por último e se arrependem primeiro. Uma política cinco pontos melhor em um benchmark, mas meio segundo por etapa de ação, parece pior na sua mesa: a dinâmica de contato não espera.

Uma ressalva: o valor do GR00T diverge da placa da NVIDIA, que mede 4 etapas de denoising e uma câmera a 85.8 ms em uma H100 no modo eager, 48.6 ms com torch.compile, 27.9 ms através do TensorRT completo. Os 152 ms aqui são um valor de pilha completa com sobrecarga de serviço e mais de uma câmera, não uma passagem direta (forward pass).

Uma maneira de ganhar tempo sem mudar o modelo: o artigo do SmolVLA mede a execução síncrona, onde a política termina um bloco antes de prever o próximo, em comparação com a assíncrona, onde a previsão se sobrepõe à execução. O sucesso é similar, 78.3 contra 73.3, mas o mesmo pick-and-place leva 9.7 segundos em vez de 13.75, e em uma janela fixa o robô gerencia 19 ciclos em vez de 9.

Licenças, verificadas porque ninguém as verifica

A linha Pi0.5 requer atenção. A documentação LeRobot pi05 declara Apache 2.0 consistente com openpi, enquanto o cartão do Hub para lerobot/pi05_base contém license: gemma. Ambos estão ativos. GR00T N1.7 tem uma versão mais branda: o README do Isaac-GR00T menciona de passagem que N1.7 é totalmente licenciável comercialmente sob Apache 2.0, enquanto sua própria seção de licença e o cartão do modelo colocam apenas o código sob Apache 2.0 e os pesos sob a NVIDIA Open Model License.

Os padrões que você realmente executará

Cada formulário de treinador vem com um padrão, e eles não são arbitrários. Os do ACT são próprios do LeRobot: batch 8, lr 1e-5, 100000 passos de treinamento, tamanho do chunk 100, correspondendo ao ACTConfig upstream e k=100 do artigo ACT. Uma coluna abaixo é uma armadilha.

O controle que importa mais do que a escolha do modelo

É o bloco de ação. Blocos mais longos proporcionam movimento mais suave e menos erros cumulativos, mas a política é comprometida enquanto o bloco executa, então ela reage tardiamente a qualquer coisa que se move: confiante em um cubo estático, inútil em um que rola. Se ele ultrapassar, encurtar a porção executada é melhor do que retreinar e é gratuito. Uma junta que para antes do tempo é um problema diferente; veja .

• ACT: ACTConfig assume chunk_size 100 e n_action_steps 100 por padrão. O agrupamento temporal está desativado e requer n_action_steps 1.
• GR00T N1.7: o horizonte interno passou de 16 para 40, mas o exemplo SO-101 do LeRobot ainda executa --policy.chunk_size=16 --policy.n_action_steps=16. A flag de rollout foi renomeada para --execution-horizon.
• Pi0.5: um bloco de 50 passos, dos quais a receita LIBERO do LeRobot executa 10 via --policy.n_action_steps=10; com --policy.pretrained_path ele volta para 50 se você omitir a flag.
• SmolVLA: blocos de 50 ações, ambos os controles expostos.

Como testar todos os cinco em uma tarde

A resposta mais barata não é mais leitura. Gaste cerca de 15 USD e deixe o braço te dizer: grave uma vez, treine o modelo barato primeiro, escale depois que ele provar que os dados são sólidos. A estrutura supera o volume, o objetivo da e o .

1. 1
   Grave 50 episódios uma vez

   Cinquenta libera o caminho para GR00T, Pi0.5 e ACT, e 30 para SmolVLA. Repita cada variação em vez de dispersar: 50 episódios em 5 posições de cubo treinadas onde 25 não foram. Veja grave seu primeiro conjunto de dados.

   bash

   lerobot-record \
     --robot.type=so100_follower \
     --robot.port=/dev/ttyACM1 \
     --robot.id=my_follower_arm \
     --teleop.type=so100_leader \
     --teleop.port=/dev/ttyACM0 \
     --teleop.id=my_leader_arm \
     --dataset.repo_id=${HF_USER}/pick-place-50 \
     --dataset.num_episodes=50 \
     --dataset.single_task="Put the lego brick into the box"

2. 2
   Treine o ACT primeiro, porque ele não pode mentir para você

   Sem pesos pré-treinados, então se ele realizar a tarefa, seu conjunto de dados contém a tarefa. Se o ACT estagnar, corrija os dados. 1 a 3 USD, 2 a 5 horas em uma placa de 24 GB.

   bash

   lerobot-train \
     --dataset.repo_id=${HF_USER}/pick-place-50 \
     --policy.type=act \
     --policy.device=cuda \
     --batch_size=8 \
     --steps=100000 \
     --seed=1000 \
     --output_dir=outputs/train/act_pickplace \
     --job_name=act_pickplace

3. 3
   Execute SmolVLA no mesmo conjunto de dados, inalterado

   Mesmos dados, mesmo braço, 450 M parâmetros em vez de 80 M, mais condicionamento de linguagem. LeRobot estima uma execução de 20K passos em aproximadamente 4 horas em uma A100. Isso é o que lhe diz se o pré-treinamento traz algum benefício.

   bash

   lerobot-train \
     --policy.path=lerobot/smolvla_base \
     --dataset.repo_id=${HF_USER}/pick-place-50 \
     --batch_size=64 \
     --steps=20000 \
     --policy.device=cuda \
     --output_dir=outputs/train/smolvla_pickplace \
     --job_name=smolvla_pickplace

4. 4
   Converta para v2.1 antes de usar GR00T

   GR00T lê uma variação do formato LeRobot v2 mais um meta/modality.json extra que mapeia como os arrays concatenados de estado e ação se dividem em campos nomeados. Um conjunto de dados v3.0 trava esse carregador, porque o v3.0 empacota muitos episódios em arquivos compartilhados onde o v2 escrevia um por episódio. Isaac-GR00T fornece o auxiliar de downgrade como scripts/lerobot_conversion/convert_v3_to_v2.py; a página de rejeição v3 é o caminho rápido.

   text

   # GR00T expects this layout, not the v3.0 file-based one
   my_dataset/
     meta/
       info.json
       episodes.jsonl      # episode index and lengths
       tasks.jsonl         # language task descriptions
       modality.json       # GR00T-specific: state/action/video key mapping
     data/chunk-000/       # parquet, state and action per timestep
     videos/chunk-000/     # one mp4 per episode

5. 5
   Escale para GR00T N1.7 apenas se os dois primeiros deixaram algo a desejar

   Através da CLI da NVIDIA, mostrada aqui, ou do tipo de política groot do LeRobot. A NVIDIA recomenda 40 GB ou mais de VRAM para fine-tuning, 16 GB para inferência. Em caso de OOM, consulte a página de OOM.

   bash

   CUDA_VISIBLE_DEVICES=0 uv run python \
     gr00t/experiment/launch_finetune.py \
     --base-model-path nvidia/GR00T-N1.7-3B \
     --dataset-path demo_data/cube_to_bowl_5 \
     --embodiment-tag NEW_EMBODIMENT \
     --modality-config-path examples/SO100/so100_config.py \
     --num-gpus 1 \
     --output-dir /tmp/test_finetune \
     --max-steps 2000 \
     --global-batch-size 32 \
     --dataloader-num-workers 4

Duas maneiras de executar essa triagem

# 1. LeRobot: ACT, SmolVLA, Pi0.5 and GR00T N1.7 via --policy.type=groot
pip install "lerobot[smolvla]"
pip install "lerobot[pi]"
pip install "lerobot[groot]"

# 2. GR00T reference implementation and benchmark examples
git clone https://github.com/NVIDIA/Isaac-GR00T

# 3. Physical Intelligence reference implementation
git clone --recurse-submodules https://github.com/Physical-Intelligence/openpi

Modelo de fundação ou do zero

A verdadeira questão não é qual modelo 3 B escolher. É se deve usar um VLA pré-treinado, dado que o ACT aprendeu seis tarefas bimanuais reais a partir de cerca de dez minutos de demonstrações cada, com 80 M parâmetros e nada pré-treinado.

O caso de reprodução de uma execução antiga

Perseguir um checkpoint de 2025 faz a escolha do modelo por você e transforma o problema em fixação de versão: o LeRobot atual rejeita N1.5, então você fixa lerobot==0.5.1. Sem campo de seed e com 5 a 6 por cento de variância entre as execuções, a reprodução é aproximada por construção. O guia N1.5 no SO-100 e a página da política N1.5 têm o lado da plataforma.

Reduzido a dois? ACT contra GR00T N1.7 e GR00T N1.7 contra SmolVLA. As linhas brutas estão nas entradas da arena: GR00T N1.7, Pi0.5, SmolVLA e ACT.

Onde esta plataforma não o ajuda

• Não consegue tornar a inferência remota rápida. O ciclo de 20 a 485 ms pertence ao modelo; as viagens de ida e volta pela internet somam-se a isso.
• Não consegue fazer o fine-tuning de GR00T ou Pi0.5 no seu próprio hardware. Ambos são apenas na nuvem aqui; apenas SmolVLA e ACT correm localmente.
• Não consegue corrigir um conjunto de dados. A perda diminui, mas a política não faz nada é um problema de dados, uma política que só funciona numa configuração é um problema de cobertura.
• Não consegue tornar as execuções de GR00T reproduzíveis: a configuração upstream não tem um campo de seed.

Escolhendo um e seguindo em frente

Um padrão: grave 50 episódios, treine ACT por 1 a 3 USD para provar o conjunto de dados, depois SmolVLA nos mesmos dados. Por menos de 6 USD no total, e eles respondem à pergunta que importa: se o pré-treinamento ajuda aqui, ou se o gargalo são os dados. Escale para GR00T N1.7 para tarefas multi-passo com muito contato, para Pi0.5 quando a cena muda.

Visita guiada à plataforma: treine sua primeira política, depois execute sua primeira política. Os documentos de treinamento e documentos de conjunto de dados cobrem forma e formato; a página do SO-100 e o guia completo do SO-100 cobrem construção e calibração. Contexto: a visão geral de VLA e o artigo de flow-matching do Pi0. O que realmente aumentará sua taxa de sucesso é o guia de qualidade de dados.