Como Treinar SmolVLA em uma GPU de 24 GB (lerobot 0.6.1)

A maioria das pessoas que querem um modelo de ação de linguagem visual em um braço real param na linha de hardware. GR00T N1.7 e Pi0.5 têm cerca de três bilhões de parâmetros cada e exigem uma A100 de 80 GB ou uma H100. Se o que você possui é um PC gamer com uma RTX 4090, esse é o fim da linha. SmolVLA é a exceção: 450 M parâmetros, dentro do LeRobot, construído para ajuste fino em uma placa de consumidor e para servir a partir de uma CPU.

Primeiro, a rota manual: instale o lerobot, puxe o lerobot/smolvla_base checkpoint, execute o comando real, leia a execução enquanto ela acontece. Depois, a rota da plataforma, e onde ela não ajuda.

O que é SmolVLA, em números que você pode verificar

SmolVLA é uma correspondência de fluxo política acoplada a um pequeno modelo de linguagem visual. A arquitetura base é SmolVLM2-500M-Video-Instruct; o artigo mantém apenas as primeiras 16 camadas de seu modelo de linguagem, limita cada quadro de câmera a 64 tokens visuais com um embaralhamento de pixels (pixel shuffle) em vez de mosaico de imagem (image tiling), e intercala atenção cruzada com uma camada de autoatenção a cada segundo bloco. O custo de inferência foi uma restrição de design, não uma reflexão tardia.

Os benchmarks são a razão pela qual as pessoas se preocupam com um modelo de 450 M. No LIBERO, ele tem uma média de 87.3 por cento contra 76.5 para OpenVLA de 7 B e 86.0 para um Pi0 pré-treinado em robótica de 3.3 B; no Meta-World, 57.3 contra 47.9. Em hardware SO-100 real, o treinamento multi-tarefa resulta em 75 por cento em pegar e colocar, 90 em empilhar, 70 em classificar, com média de 78.3, onde ACT treinado por tarefa teve uma média de 48.3. As mesmas linhas estão ao lado de cada VLA publicado na entrada da arena SmolVLA e na comparação ACT contra SmolVLA.

Por que uma placa de 24 GB é a escolha certa para a primeira execução

LeRobot fornece um guia de dimensionamento de computação, a página mais útil no repositório para isso. Ele agrupa políticas por tamanho de backbone e fornece um envelope de VRAM por grupo, medido com tamanho de lote 8 e AdamW, o padrão do lerobot. O estado do otimizador sozinho adiciona de 30 a 100 por cento sobre uma passagem direta e reversa simples, então estes não são valores apenas de pesos.

De dez a dezesseis gigabytes com lote 8 é o argumento: uma placa de 24 GB comporta isso mais o dataloader. AY-Robots executa SmolVLA na RTX 4090 ou em qualquer placa de 24 GB, mínimo de 30 episódios, LeRobot v3.0 de dados, 245 ms por passo de ação. Alugado, isso representa de 2 a 5 horas a 0.30 a 0.60 USD por hora, cerca de 1 a 3 USD por ajuste fino execução, contra 4 a 12 USD na camada de 80 GB que GR00T e Pi0.5 exigem (preços). Uma execução falha de SmolVLA é um café; uma execução falha de GR00T, um almoço.

Passo 0: o conjunto de dados decide a execução, não as flags

Nada abaixo importa se a gravação for ruim. A página LeRobot SmolVLA é direta: o conjunto de dados de referência tinha 50 episódios em 5 posições de cubo, 10 por posição, e a mesma tarefa com 25 episódios teve um desempenho ruim. A repetição por variação generaliza, a contagem bruta de episódios não. Nunca gravou um? Comece em grave seu primeiro conjunto de dados, com o cliente de desktop, que escreve o formato LeRobot a partir de uma sessão de teleoperação, ou pegue um emprestado do diretório de conjuntos de dados.

• Pelo menos 30 episódios em AY-Robots, cerca de 50 para a receita de referência do LeRobot.
• Cada variação esperada na implantação, repetida várias vezes.
• Uma string de tarefa, escrita de forma idêntica no momento da gravação e da implantação. O modelo é condicionado a esse texto.
• Câmeras fixas. Uma câmera movida entre a gravação e a implantação é a razão mais comum para uma curva de perda limpa resultar em um braço imóvel.
• Uma variação reservada na qual você nunca treinou, para ter algo honesto para testar.

# v2.1 -> v3.0: aggregates per-episode files into shards and writes the episode offsets
python -m lerobot.scripts.convert_dataset_v21_to_v30 --repo-id=${HF_USER}/so100_pick_place

Mais sobre isso em como coletar dados de treinamento VLA de alta qualidade. A versão resumida: 30 a 50 episódios limpos de uma tarefa com variação deliberada superam 200 episódios desleixados de três, por uma margem que nenhum hiperparâmetro consegue fechar.

Instalar lerobot 0.6.1

# LeRobot needs Python 3.12 or newer as of 0.6.x
conda create -y -n lerobot python=3.12
conda activate lerobot

# TorchCodec decodes the dataset videos and wants ffmpeg
conda install ffmpeg -c conda-forge

# Base package is deliberately thin; extras pull the rest
pip install 'lerobot[smolvla,training,core_scripts]'

# Sanity check: prints the lerobot version, the GPU torch sees, and the console scripts you got
lerobot-info

A instalação base do lerobot é leve e restringe dependências pesadas por trás de extras: smolvla adiciona transformers, num2words e accelerate, training a pilha de dados e wandb, core_scripts as dependências de hardware e visualização. No Linux, o caminho de instalação também decide o seu wheel CUDA: o padrão PyPI é um wheel cu130 com um driver mínimo de 580.65, então em um driver mais antigo instale o torch do índice cu128 primeiro, depois o lerobot.

A execução do treinamento, comando por comando

1. 1
   Autenticar-se no Hub

   O checkpoint base vem do Hub, e seu conjunto de dados provavelmente também.

   bash

   hf auth login

2. 2
   Leia as opções uma vez

   Cada campo da configuração do pipeline e da política é um flag. Dê uma olhada antes de se aprofundar no código-fonte.

   bash

   lerobot-train --help

3. 3
   Iniciar o fine-tune

   O exemplo da documentação executa um batch de 64 em uma única A100; o próprio guia de computação para A100 de 40 GB usa batch 16, e 8 é o equivalente para 24 GB. Nenhum flag de agendador aqui de propósito, veja abaixo.

   bash

   lerobot-train \
     --policy.path=lerobot/smolvla_base \
     --dataset.repo_id=${HF_USER}/so100_pick_place \
     --batch_size=8 \
     --steps=20000 \
     --save_freq=2000 \
     --log_freq=200 \
     --seed=1000 \
     --output_dir=outputs/train/smolvla_pick_place \
     --job_name=smolvla_pick_place \
     --policy.device=cuda \
     --wandb.enable=true

4. 4
   Leia a linha de log, não apenas a perda

   A cada --log_freq passos, o lerobot imprime loss, grdn, lr, updt_s, data_s, smp/s e, em CUDA, mem_gb. mem_gb indica se o batch cabe, lr se o agendamento está decaindo, e data_s se aproximando de updt_s significa que o dataloader é o gargalo, não a GPU.

   bash

   # if data_s creeps toward updt_s
   lerobot-train ... --num_workers=8

5. 5
   Colete checkpoints que você pode comparar

   save_freq tem como padrão 20000, então uma execução de 20000 passos deixa um checkpoint e nada para comparar. Defina 2000. Enviar para o Hub requer --policy.repo_id.

   bash

   --save_freq=2000 \
   --policy.repo_id=${HF_USER}/smolvla_pick_place \
   --save_checkpoint_to_hub=true

6. 6
   Retomar se a máquina falhar

   Aponte --config_path para o train_config.json ao lado do checkpoint. O lerobot se recusa a iniciar em um output_dir existente a menos que você esteja retomando, então você não pode sobrescrever uma execução por acidente.

   bash

   lerobot-train \
     --config_path=<path to the saved train_config.json> \
     --resume=true

Os flags que realmente mudam o resultado

Os padrões que você herda se não alterar nada

Uma política de configuração no lerobot carrega seu próprio otimizador e predefinição de agendador, e a menos que você defina use_policy_training_preset=false essas predefinições prevalecem. Metade das perguntas que as pessoas fazem sobre o treinamento do SmolVLA são respondidas por um padrão que elas não sabiam que existia.

As duas linhas que surpreendem as pessoas são freeze_vision_encoder e train_expert_only, ambas verdadeiras. De fábrica, você treina aproximadamente 100 M parâmetros, não 450 M, e é por isso que cabe em 24 GB. A própria execução de referência do LeRobot em um cluster H100 de quatro GPUs inverte ambas para falso; em uma placa de 24 GB, isso transforma uma execução funcional em .

Quanto tempo a execução leva e quantos passos são suficientes

LeRobot publica âncoras de tempo real para cinco épocas em um conjunto de dados de aproximadamente 50 episódios, cerca de 45000 quadros a 30 fps. Valores de ordem de magnitude, dizem os documentos, mas eles são a diferença entre esperar uma hora e um dia.

Executando a política ajustada de volta no braço

lerobot-rollout \
  --strategy.type=base \
  --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}}" \
  --task="Grasp the cube and put it in the box." \
  --policy.path=${HF_USER}/smolvla_pick_place

Os 245 ms por passo de ação são fáceis de interpretar mal: a política emite chunk_size = 50 ações por passagem direta e executa n_action_steps = 50 delas, então a frequência com que se paga esse custo é definida por esses parâmetros, não pela frequência com que os servos recebem um comando. Isso é o que o agrupamento de ações proporciona, e por que um modelo de 245 ms pode acionar um braço de 30 Hz. O que resta é a latência de inferência no final do agrupamento.

Essa terceira linha é o que a maioria dos relatórios omite. A inferência assíncrona é cerca de 30 por cento mais rápida e praticamente dobra o rendimento em uma janela fixa, e o artigo considera as taxas de sucesso comparáveis, o que, em média, elas são. Por baixo, a classificação caiu de 70 para 50 por cento, enquanto o pegar e colocar ganhou 5. lerobot 0.6.1 carrega a outra alavanca no mesmo binário: --inference.type=rtc alterna a execução para o agrupamento em tempo real, que o próprio bloco de uso do script recomenda para os VLAs lentos, Pi0, Pi0.5 e SmolVLA.

Duas rotas para o mesmo checkpoint

pip install 'lerobot[smolvla,training,core_scripts]'
hf auth login

lerobot-train \
  --policy.path=lerobot/smolvla_base \
  --dataset.repo_id=${HF_USER}/so100_pick_place \
  --batch_size=8 --steps=20000 \
  --save_freq=2000 --seed=1000 \
  --output_dir=outputs/train/smolvla_pick_place \
  --job_name=smolvla_pick_place \
  --policy.device=cuda --wandb.enable=true

Quando SmolVLA é a escolha errada

O teste para saber se o SmolVLA foi a primeira execução certa não é se funcionou, mas se a falha lhe disse algo. Atingir 60 ou 70 por cento e um modelo maior é um próximo investimento razoável: os dados carregam sinal. Atingir 10 por cento e um modelo de 3 B provavelmente também atinge 10 por cento, o que você acabou de aprender por três dólares em vez de doze.

Vale a pena ler antes de gastar mais: Pi0.5 contra SmolVLA para mais capacidade com a mesma ideia, e GR00T N1.7 contra SmolVLA para a rota NVIDIA, ambos com camada de 80 GB a 4 a 12 USD por execução. A outra forma, ACT é a linha de base mais barata: 80 M parâmetros, 20 ms por passo de ação, sem condicionamento de linguagem. Todos os cinco estão em a página de políticas; a arena tem 85 modelos e 332 resultados de benchmark.

A lista de verificação antes de escalar qualquer coisa

1. O lr atingiu seu limite inferior de 2.5e-6? Abaixo de 30000 passos, o lerobot reescala o decaimento e informa isso na inicialização; acima disso, defina --policy.scheduler_decay_steps você mesmo.
2. Mais de um checkpoint, e episódios separados com --dataset.eval_split para que a perda de avaliação signifique algo.
3. A política se move? Uma perda em queda com um braço imóvel tem causas específicas: a perda cai, a política não faz nada.
4. Sobrevive a uma mudança de cenário? Se não: a política só funciona em uma configuração.
5. Você anotou a seed? O lerobot usa 1000 por padrão, então duas execuções intocadas permanecem comparáveis.
6. Só então: mais episódios, mais variação ou um modelo maior. Nessa ordem.

Para entender por que esses modelos existem e o que eles fazem com a entrada de linguagem, é o contexto; executa a montagem através da até a primeira execução de . Para o checkpoint finalizado, ; se o braço nunca aparecer, .