Custo de Treinamento VLA: O Que Realmente Custa uma Execução de Ajuste Fino

A conta tem quatro linhas, e a GPU é a menor delas

Quando as pessoas perguntam quanto custa ajustar um modelo de visão-linguagem-ação para um SO-100, elas quase sempre se referem ao aluguel da GPU. Esse é o número que aparece como cobrança no cartão, então é o que parece real. É também, por uma ampla margem, o menor dos quatro números que decidem o custo real de uma política funcional.

Os tempos de treinamento abaixo vêm dos próprios artigos e repositórios dos cinco modelos, o custo de hardware da lista de materiais publicada, os números da plataforma dos catálogo de políticas e página de preços da AY-Robots. Onde a plataforma não ajuda, este artigo o indica.

Quanto custa realmente uma hora de GPU no mercado spot

Não há um preço único para uma hora de A100. Em um marketplace como vast.ai, cada host define sua própria taxa, e a execução de treinamento que você inicia cai na máquina que estiver barata e livre naquele segundo. A resposta honesta é uma distribuição. Aqui está, medida em 23 de agosto de 2026 às 13:44 UTC: placas completas únicas, sob demanda, filtradas por VRAM real.

# Live, full-card, single-GPU, on-demand offers from the vast.ai public bundle API.
# No account and no API key needed. gpu_ram is in MB, so an 80 GB card is >= 80000.
python3 - <<'PY'
import json, statistics, urllib.parse, urllib.request

def offers(name, min_ram):
    q = {"rentable": {"eq": True}, "num_gpus": {"eq": 1}, "gpu_name": {"eq": name},
         "order": [["dph_total", "asc"]], "limit": 500, "type": "on-demand"}
    url = "https://console.vast.ai/api/v0/bundles/?q=" + urllib.parse.quote(json.dumps(q))
    with urllib.request.urlopen(url, timeout=60) as r:
        return [o for o in json.load(r)["offers"]
                if o["gpu_frac"] == 1.0 and o["gpu_ram"] >= min_ram]

groups = {
    "RTX 4090 24 GB": (["RTX 4090"], 24000),
    "RTX 5090 32 GB": (["RTX 5090"], 30000),
    "A100 80 GB":     (["A100 PCIE", "A100 SXM4"], 80000),
    "H100 80 GB":     (["H100 SXM", "H100 PCIE"], 80000),
    "H100 NVL 94 GB": (["H100 NVL"], 90000),
}
for label, (names, min_ram) in groups.items():
    o = [x for n in names for x in offers(n, min_ram)]
    if not o:
        print(label, "no offers"); continue
    p = sorted(x["dph_total"] for x in o)
    b = sorted(x["min_bid"] for x in o if x.get("min_bid"))
    bid = f"{b[0]:.2f}" if b else "n/a"
    print(f'{label}: n={len(p)} | {p[0]:.2f} / {statistics.median(p):.2f} / {p[-1]:.2f}'
          f' USD/h | bid floor {bid}')
PY

Por que os modelos 3B não podem usar a placa barata

Uma hora de 4090 e uma hora de H100 80 GB diferem em aproximadamente seis vezes nas medianas acima. O que o força a usar a placa mais cara não é a velocidade, é a memória. openpi estabelece o mínimo para um Pi0.5 completo ajuste fino em 70 GB, e a NVIDIA recomenda 40 GB ou mais para o GR00T. Observe o que o número do GR00T não é. Sua configuração de ajuste fino congela o modelo de linguagem e o codificador visual por padrão (tune_llm e tune_visual são False, o projetor e o cabeçalho de difusão True), razão pela qual o catálogo lista aproximadamente 40 M de parâmetros treinados de um total de 3 B. Os 40 GB não são o estado do otimizador para pesos de 3 B, é o backbone congelado mais as ativações. Variantes de escopo reduzido exigem menos: o caminho LoRA do openpi requer 22.5 GB e menciona a 4090, e o fluxo de trabalho Isaac Lab Arena da NVIDIA lista uma opção de GPU única de 24 GB para o pós-treinamento do GR00T. A plataforma se baseia no mínimo que cada fornecedor publica para a configuração que realmente executa. O artigo sobre flow-matching do pi0 explica de onde vem essa correspondência de fluxo pegada.

Essa tabela é a razão pela qual a plataforma divide os cinco modelos em dois níveis. GR00T N1.7, GR00T N1.5 e Pi0.5 usam A100 80 GB ou H100 porque é isso que os fornecedores pedem. SmolVLA e ACT usam uma RTX 4090 ou qualquer placa de 24 GB porque isso é realmente suficiente.

Tempo de execução real de cada um dos cinco modelos

O tempo de execução é a outra metade do custo: 2.00 USD por hora é irrelevante se o trabalho for de 40 minutos e ruinoso se for de 40 horas. Estes são os padrões que a AY-Robots realmente envia para o treinador, com a janela de execução e o custo para cada nível.

De onde vêm essas janelas de execução a montante

• SmolVLA: a documentação do lerobot afirma que 20.000 passos levam aproximadamente 4 horas em uma única A100. A plataforma executa os mesmos 20.000 passos na camada mais barata de 24 GB, daí uma janela em vez de 4 horas fixas.
• ACT: o artigo original do ALOHA relata cerca de 5 horas em uma única RTX 2080 Ti de 11 GB para um modelo de 80M parâmetros. Uma 4090 é várias gerações mais nova, mas a plataforma orça 100.000 passos, então a janela se encaixa no mesmo lugar.
• GR00T: o fluxo de trabalho de referência da NVIDIA para a geração N1.6 cita aproximadamente 4 a 8 horas para 20.000 passos com batch 24 em oito placas L40S, e 2 a 3 horas para 30.000 passos com batch 16 em uma única Ada 6000. O ajuste fino de um VLA de 3B em uma única placa em poucas horas é normal, não otimista.
• Pi0.5: a openpi não publica um valor de tempo real, mas publica o limite mínimo de 70 GB para um ajuste fino completo, o que define a placa e, portanto, a taxa.

Vale a pena refletir sobre o valor que você não está pagando. O artigo GR00T N1 relata aproximadamente 50.000 horas de GPU H100 para pré-treinar o modelo de 2.2B, em um cluster de até 1024 GPUs, com um tamanho de batch de pré-treinamento de 16.384 para 200.000 passos de gradiente. Com o custo de 1.34 a 2.34 USD por hora medido acima, isso representa algo em torno de 67.000 a 117.000 USD em computação alugada. O artigo SmolVLA estima seu projeto em aproximadamente 30.000 horas de GPU em 481 conjuntos de dados da comunidade, 22.9K episódios e 10.6M frames. Você herda tudo isso pelo preço de um download; seus 8 USD compram os últimos 20.000 passos. Por que os VLAs são construídos dessa forma aborda essa divisão.

O braço: um custo único que anula a conta da GPU

Uma execução de treinamento custa menos que o almoço. O robô não. É por isso que o SO-100 importa: é o braço mais barato que toda a cadeia de ferramentas de aprendizagem por imitação realmente suporta.

A lista de materiais upstream no repositório SO-ARM100 é mais granular e vale a pena verificar para a sua região: a sua lista Peças Para Dois Braços totaliza 229.88 USD ou 226.30 EUR para uma configuração líder mais seguidor, e a sua lista Peças para Um Braço Seguidor totaliza 121.94 USD ou 124.30 EUR. Seis servos STS3215 a 13.89 USD cada são 83.34 desse 121.94, então os servos são o braço. A 1 a 3 USD por execução SmolVLA ou ACT, um par de braços vale entre 77 e 230 execuções de treinamento. Se ainda estiver a escolher, SO-100 versus SO-101 é a comparação que importa, porque os dois são suficientemente próximos para que a decisão seja sobre disponibilidade e não sobre capacidade.

Horas humanas: a linha que ninguém coloca na planilha

Este é o número que vira a discussão de custos de cabeça para baixo. Gravar demonstrações é uma pessoa movendo um braço robótico, um episódio por vez, em tempo real. Não há como processar em lote nem alugar por segundo. O conjunto de dados LeRobot gravador vem com padrões que facilitam a aritmética, todos os três confirmados em DatasetRecordConfig: 60 segundos por episódio, 60 segundos para redefinir a cena, 50 episódios. A coluna de dinheiro abaixo assume 15 USD por uma hora do tempo de alguém, o que é uma suposição e não um número da plataforma. Substitua pela sua própria taxa; a proporção é o ponto.

1. 1
   Grave o conjunto de dados com os padrões pelos quais você será realmente cobrado

   Esta é a versão lerobot 0.6.1, a versão no PyPI a partir de 3 de agosto de 2026. Observe o formato da CLI: a gravação é executada através do ponto de entrada do console lerobot-record (lerobot.scripts.lerobot_record), não o antigo caminho do módulo python -m lerobot.scripts.record. AY-Robots visa a versão 0.5.1, e o wheel 0.5.1 declara os mesmos pontos de entrada lerobot-record e lerobot-train, então o formato abaixo é estável em ambos. As três flags de tempo são os padrões upstream, então este é também o comando que a aritmética na próxima tabela assume.

   bash

   lerobot-record \
       --robot.type=so100_follower \
       --robot.port=/dev/ttyACM0 \
       --robot.id=my_follower_arm \
       --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30} }" \
       --teleop.type=so100_leader \
       --teleop.port=/dev/ttyACM1 \
       --teleop.id=my_leader_arm \
       --dataset.repo_id=${HF_USER}/pick-place-cube \
       --dataset.num_episodes=50 \
       --dataset.episode_time_s=60 \
       --dataset.reset_time_s=60 \
       --dataset.single_task="Grab the black cube and put it in the bin"

2. 2
   Veja o que você gravou antes de alugar um único minuto de GPU

   Inspecionar um conjunto de dados custa zero USD por hora. Descobrir o mesmo problema a partir de uma curva de perda custa 2.00 USD por hora no nível H100 e informa você com quatro horas de atraso. Envie o conjunto de dados e revise-o no visualizador LeRobot, ou navegue pelo diretório de conjuntos de dados da AY-Robots.

   bash

   # the recorder pushes to the Hub by default; disable with --dataset.push_to_hub=False
   echo https://huggingface.co/datasets/${HF_USER}/pick-place-cube
   
   # then open https://huggingface.co/spaces/lerobot/visualize_dataset
   # and scrub through episodes: are both camera streams alive on every episode?
   # is the gripper actually closing? does the arm sit at a joint limit?

3. 3
   Treine e certifique-se de que o checkpoint sobreviva ao pod

   Uma máquina alugada é temporária por definição, então grave os checkpoints em algum lugar durável durante a execução. Duas flags decidem se você mantém o que pagou. --save_freq tem como padrão 20.000 passos, então uma execução padrão de 20.000 passos do SmolVLA grava seu primeiro checkpoint quando a execução já terminou; diminua-o antes de alugar qualquer coisa que possa ser interrompida. --save_checkpoint_to_hub requer --policy.repo_id e não existe no lerobot 0.5.1, então nessa versão você copia o diretório de saída da máquina por conta própria. O tamanho do lote abaixo é o exemplo da documentação upstream; o formulário AY-Robots envia 2 para SmolVLA e grava no armazenamento de objetos à medida que os checkpoints aparecem.

   bash

   lerobot-train \
       --policy.path=lerobot/smolvla_base \
       --dataset.repo_id=${HF_USER}/pick-place-cube \
       --batch_size=64 \
       --steps=20000 \
       --save_freq=2000 \
       --output_dir=outputs/train/my_smolvla \
       --job_name=my_smolvla_training \
       --policy.device=cuda \
       --policy.repo_id=${HF_USER}/my_smolvla \
       --save_checkpoint_to_hub=true

Compare a coluna da direita com os 1 a 12 USD que a execução custa. A essa taxa assumida, um conjunto de dados de 50 episódios custa de duas a sete vezes mais para gravar do que para treinar, antes da calibração, configuração da câmera e dos episódios que você descarta. É por isso que tem um valor monetário direto. O guia lerobot sugere pelo menos 50 episódios com 10 por localização de objeto; a documentação do SmolVLA relata que uma versão de 25 episódios da mesma tarefa não foi suficiente.

Onde o dinheiro realmente desaparece

1. Execuções em dados que nunca funcionariam

Uma execução GR00T de 20.000 passos em um conjunto de dados com dois fluxos de câmera trocados custa o mesmo que uma em um conjunto de dados limpo, leva o mesmo tempo e produz uma curva de perda que parece boa. A falha aparece no braço, horas depois. são cobrados por hora e o diagnóstico é cobrado em dias. Dois sintomas que valem a pena memorizar: geralmente significa que as observações não contêm o que a tarefa precisa, e significa que o conjunto de dados tinha menos variação do que você pensava.

2. Pagando preços de modelo de fundação para uma tarefa de câmera fixa

ACT tem aproximadamente 80M parâmetros e foi projetado para treinar do zero com 50 demonstrações de uma tarefa. GR00T N1.7 tem aproximadamente 3B com um backbone pré-treinado. Para uma câmera fixa, uma mesa fixa e um objeto, o modelo de 80M frequentemente funciona, executa a cerca de 20 ms por etapa de ação em vez de 152 ms, e custa de 1 a 3 USD por execução em vez de 4 a 12. Gaste 3 USD para descobrir se o modelo barato funciona antes de gastar 12 USD no caro. ACT contra SmolVLA e GR00T N1.7 contra Pi0.5 mostram onde cada um deixa de ser a resposta certa; a arena de modelos tem 85 modelos e 332 resultados de benchmark.

3. A GPU que você esqueceu

O erro mais barato de prevenir e o mais comum de cometer. Uma instância iniciada numa sexta-feira para depurar algo é cobrada durante o fim de semana à mesma taxa de uma execução real.

Na AY-Robots, essa falha é eliminada para inferência: os pods provisionados pela API de inferência carregam um watchdog de ociosidade e se autodestroem após um período de inatividade. Se você alugar a placa por conta própria, esse watchdog é o seu lembrete no calendário.

4. Pagar duas vezes pela mesma resposta

O ponto de entrada de fine-tuning do GR00T é uma CLI tyro que não expõe nenhuma seed. Isso não é uma limitação da plataforma, é a ferramenta upstream: não há campo de seed em gr00t/configs/finetune_config.py, e as próprias dicas de treinamento do repositório alertam que as execuções variam de 5 a 6 por cento porque as aumentações de imagem não são determinísticas. lerobot padroniza a seed 1000 em 0.5.1 e 0.6.1, então as execuções de ACT, SmolVLA e Pi0.5 podem pelo menos ser reexecutadas a partir da mesma inicialização e ordem de dados. Isso não é uma promessa de pesos bit-idênticos em uma GPU, mas é a diferença entre uma reexecução e um novo experimento. Se uma execução de GR00T produzir uma política que funciona e você não manteve o ponto de verificação, você paga o preço total por um resultado que pode diferir em mais do que a diferença que você estava buscando. Há uma segunda maneira de perder um ponto de verificação pelo qual você pagou: a CLI padroniza para --save-total-limit 5, documentado como o número máximo de pontos de verificação mantidos antes que os mais antigos sejam excluídos. O armazenamento custa centavos; uma reexecução custa de 4 a 12 USD e seis horas.

Fazendo você mesmo versus deixando a plataforma alugar a placa

# GR00T N1.7, single GPU, Isaac-GR00T as of August 2026.
# Note the entry point: gr00t/experiment/launch_finetune.py, a tyro CLI.
# scripts/gr00t_finetune.py does not exist in this repository; tutorials that
# still reference it are stale. The per-embodiment walkthrough is
# getting_started/finetune_new_embodiment.md.
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 ./so100-checkpoints \
    --max-steps 20000 \
    --global-batch-size 32 \
    --dataloader-num-workers 4

# v3.0 dataset? Convert it down first or the loader will crash. The helper
# has its own pyproject and must be installed in its own environment:
cd scripts/lerobot_conversion
uv venv && source .venv/bin/activate
uv pip install -e .
python convert_v3_to_v2.py --repo-id <DATASET_REPO_ID>

O que a plataforma cobra e como ela escolhe a placa

A lógica é propositadamente simples. Cada modelo no catálogo, declara um nível de GPU; o backend pega a VRAM necessária e aluga uma placa correspondente no mesmo mercado spot medido acima. É por isso que o custo cotado é um intervalo, não um preço. GR00T e Pi0.5 são apenas para nuvem aqui por causa dos limites mínimos de 40 GB e 70 GB. SmolVLA e ACT também rodam localmente na sua própria placa de 24 GB, onde o custo da nuvem é zero e a eletricidade é seu problema.

Um ajuste merece um aviso. A acumulação de gradiente realmente se aplica a ambas as variantes do GR00T, então aumentá-la compra um lote efetivo maior na mesma placa. Para Pi0.5 e SmolVLA, não se aplica de forma alguma: lerobot 0.5.1 não tem opção de acumulação de gradiente em sua configuração de treinamento, então definir o campo para 16 não custa nada e não compra nada. Se um trabalho em fila nunca inicia, a página de trabalho travado na fila cobre o que verificar; se o conjunto de dados for rejeitado antes do início da execução, é quase sempre o problema de formato v3.0.

Um orçamento detalhado para uma primeira política funcional

Todas as quatro linhas juntas, começando do zero. O total da GPU assume de 3 a 5 execuções: a primeira prova que o pipeline funciona, a segunda expõe um problema de dados, a terceira ou quarta é a que você mantém.

O padrão se mantém para este tamanho de robô: o processamento é um erro de arredondamento, o hardware é um custo único real, as horas humanas são a despesa recorrente. Para testar a parte de treinamento antes de comprar qualquer coisa, os pontos de entrada sem hardware permitem comparar modelos e alugar uma GPU sem um braço, e o braço ao vivo é um SO-100 físico que você pode controlar no navegador sem necessidade de cadastro. Para todo o pipeline de ponta a ponta, o guia completo do SO-100 cobre a configuração, teleoperação e o treinamento, e treine sua primeira política é a versão resumida.