Modelos VLA Pequenos: TinyVLA, SmolVLA e o Caso Sub-1B

Quase todo modelo de visão-linguagem-ação sobre o qual se escreve assume uma placa de datacenter. OpenVLA tem 7 B de parâmetros. GR00T N1.7 e Pi0.5 têm cerca de 3 B e exigem uma A100 de 80 GB para ajuste fino. Se a placa na sua mesa for uma 4090, essa classe de modelo está fora de alcance.

Dois artigos argumentam que não é necessário. TinyVLA (arXiv 2409.12514, aceito pela IEEE Robotics and Automation Letters em fevereiro de 2025) constrói um VLA a partir de um backbone de 400 M a 1.3 B mais uma cabeça de ação de difusão. SmolVLA (arXiv 2506.01844, submetido em 2 de junho de 2025) é fornecido com 450 M de parâmetros, pesos abertos, dados abertos e um script que roda em uma única placa de consumidor. Aqui está o que ambos mediram e onde o argumento de menos de 1 B deixa de ser válido.

O que realmente conta como um VLA pequeno

A contagem de parâmetros em uma ficha de modelo não é um número único. Pode significar pesos totais, pesos carregados na inferência ou pesos que recebem gradientes durante . TinyVLA relata ambos, e a diferença é grande: TinyVLA-H tem 1.3 B no total, mas 143 M são treináveis, porque a torre de visão e a maior parte do modelo de linguagem permanecem congeladas enquanto os adaptadores LoRA e o cabeçalho de ação se movem. O artigo indica que a parcela treinável é de cerca de 5 por cento.

Duas linhas merecem discussão. com aproximadamente 80 M é menor do que todos os outros aqui, mas não possui modelo de linguagem, portanto não é um VLA: ele aprende uma tarefa e não pode ser instruído a fazer outra. com 27 M é condicionado através de um codificador de texto T5-Base, não um backbone LLM. Boas referências, mas nenhum deles oferece a capacidade de seguir instruções que o rótulo implica.

TinyVLA: a velocidade vem da cabeça, não do backbone

A leitura óbvia é que eles tornaram o modelo de linguagem menor, então ele ficou mais rápido. A ablação do artigo diz o contrário. A troca do backbone de 7 B do OpenVLA por um de aproximadamente 1 B reduziu a previsão por ação de 292 ms para 140 ms, um ganho de 2x. O TinyVLA-H, com uma contagem de parâmetros comparável, executa em 14 ms na mesma placa. Os outros 10x são da cabeça de ação.

O OpenVLA emite ações como tokens discretizados através da cabeça do modelo de linguagem, um por dimensão de ação, de forma autorregressiva. O TinyVLA anexa um decodificador de difusão que produz o bloco inteiro de uma só vez. A Tabela V apresenta a arquitetura do TinyVLA-H e troca apenas a cabeça, nas mesmas cinco tarefas de robôs reais. É a evidência mais clara em ambos os artigos para o argumento que as políticas de correspondência de fluxo criam, e a razão pela qual Pi0 se afastou da decodificação de tokens.

O que o TinyVLA pontuou

A linha bimanual tem uma explicação entediante que o próprio artigo oferece: OpenVLA é pré-treinado em Open X-Embodiment, que consiste inteiramente em dados de braço único, então um espaço de ação de dois braços está fora da distribuição e pontua zero. A linha de base da política de difusão supera o TinyVLA-H em duas dessas três tarefas. Contexto em o artigo sobre Open X-Embodiment.

O repositório TinyVLA, em agosto de 2026

O artigo é bom. O código é um lançamento de pesquisa. O repositório é github.com/liyaxuanliyaxuan/TinyVLA; seu README data o lançamento do código em 17 de fevereiro de 2025 e o último commit em 11 de março de 2025. Ótimo para reproduzir um artigo, um problema se você quisesse uma biblioteca mantida.

git clone https://github.com/liyaxuanliyaxuan/TinyVLA
conda create -n tinyvla python=3.10 -y
conda activate tinyvla
pip install --upgrade pip
pip install -r requirements.txt
cd policy_heads && pip install -e .
cd ../llava-pythia && pip install -e .

TinyVLA também não lê conjuntos de dados LeRobot. Seu formato é HDF5 estilo ACT: action, language_raw, e um grupo de observações com imagens multi-view, joint_positions, qpos e qvel. O repositório inclui data_utils/rlds_to_h5py.py para entrada RLDS, e cada tarefa é registrada manualmente em aloha_scripts/constants.py com seu dataset_dir, episode_len e camera_names. Se seus episódios vieram do lerobot ou do cliente de desktop, você é responsável pela conversão.

# scripts/train.sh, the real flags from the repository
ACTION_HEAD=droid_diffusion

deepspeed --master_port 29600 --num_gpus=8 --num_nodes=1 ./train_tinyvla.py \
  --deepspeed scripts/zero2.json \
  --lora_enable True \
  --lora_module 'vit llm' \
  --lora_r 64 \
  --lora_alpha 256 \
  --non_lora_lr 2e-5 \
  --task_name "example_task_config" \
  --model_name_or_path /path/to/pretrained_vlm \
  --freeze_vision_tower True \
  --freeze_backbone True \
  --bf16 True \
  --max_steps 10000 \
  --per_device_train_batch_size 32 \
  --gradient_accumulation_steps 1 \
  --learning_rate 2e-4 \
  --lr_scheduler_type "cosine" \
  --warmup_ratio 0.005 \
  --save_steps 1000 \
  --action_head_type $ACTION_HEAD \
  --use_state True \
  --window_size 6

• --num_gpus=8 assume um nó de oito placas. Defina-o como 1 e reduza o tamanho do lote bem abaixo de 32. Nenhuma variante de GPU única é fornecida upstream, então o comando não pode ser executado literalmente em uma 4090.
• --deepspeed scripts/zero2.json aponta para um arquivo que não está no diretório scripts de nível superior. As configurações do DeepSpeed são fornecidas em llava-pythia/scripts/zero2.json. Corrija o caminho antes da sua primeira execução.
• O README exige que o nome do diretório de saída contenha llava_pythia, mais lora se o LoRA estiver ativado.
• O backbone é um download separado: lesjie/Llava-Pythia-400M, -700M or -1.3B. Não há um único checkpoint base para o qual você aponta uma política da mesma forma que aponta para lerobot/smolvla_base.

SmolVLA: o modelo sub-1 B que você pode executar esta tarde

O SmolVLA apresenta o mesmo argumento dentro de uma biblioteca mantida. Ele possui 450 M parâmetros em um backbone SmolVLM2-500M-Video-Instruct, e a eficiência vem de configurações que você pode ler em configuration_smolvla.py, em vez de uma afirmação sobre ser pequeno.

O pré-treinamento utilizou 481 conjuntos de dados da comunidade LeRobot, 22.9 K episódios e 10.6 M frames em 4 GPUs, 200000 passos com um batch global de 256; o artigo estima o projeto total em cerca de 30 K horas de GPU. Um número a observar: o blog de lançamento do Hugging Face menciona 487 conjuntos de dados curados, enquanto a tabela do artigo indica 481. Usamos o número do artigo e sinalizamos a divergência.

Um acidente ajuda: a tabela Meta-World do artigo SmolVLA apresenta os próprios números publicados do TinyVLA como linha de base, então, pela primeira vez, ambos os modelos estão em uma única tabela, SmolVLA-0.45B em 57.3 contra TinyVLA-H em 31.6. Também relata que o treinamento do SmolVLA é cerca de 40 por cento mais rápido que o Pi0 com 6x menos memória. Tudo isso vem dos autores do SmolVLA; a entrada da arena vincula cada valor à sua fonte.

Onde o SmolVLA gasta seu tempo

A AY-Robots lista o SmolVLA em 245 ms por passo de ação e o ACT em 20 ms no catálogo de políticas. O TinyVLA relata 14 ms por previsão de ação. Esses números não são comparáveis, e tratá-los como se fossem é o erro mais comum neste tópico: alguns medem o tempo de uma passagem direta, outros dividem essa passagem por um bloco uma vez que o chunking de ações o amortiza.

• O SmolVLA emite 50 ações por passagem direta e executa todas as 50. A 30 fps que o artigo usa em robôs reais, uma inferência cobre cerca de 1.7 segundos de movimento.
• A inferência assíncrona calcula o próximo bloco enquanto o atual ainda está em execução: 9.7 s de conclusão média de tarefa contra 13.75 s síncronos, aproximadamente 30 por cento mais rápido, e 19 ciclos de pegar e colocar em uma janela fixa de 60 segundos contra 9.
• As taxas de sucesso foram comparáveis em vez de melhores, 78.3 síncronas contra 73.3 assíncronas. A assincronia compra throughput, não precisão.
• O chunking oculta a latência de computação, não a latência de rede, e torna a política menos reativa porque está comprometida com 50 ações.

Ajuste fino de SmolVLA em uma placa de consumidor

O caminho manual, no lerobot 0.6.1, a versão atual do PyPI em 23 de agosto de 2026. Tudo abaixo vem da documentação Hugging Face lerobot SmolVLA, obtida no mesmo dia; a versão guiada é mais suave.

1. 1
   Instalar o lerobot com o extra smolvla

   As dependências do SmolVLA são um extra opcional, não fazem parte da instalação base. Instalar sem elas e depois questionar por que o tipo de política é desconhecido é uma perda comum de meia hora.

   bash

   git clone https://github.com/huggingface/lerobot.git
   cd lerobot
   pip install -e ".[smolvla]"

2. 2
   Obter um dataset com episódios suficientes

   A documentação recomenda cerca de 50 episódios e afirma que a mesma tarefa com 25 não foi suficiente. A AY-Robots define o mínimo em 30. Grave os seus próprios, ou comece pelo diretório de datasets.

   bash

   # any LeRobotDataset on the Hub works as --dataset.repo_id
   # lerobot/svla_so100_pickplace is the paper's own 50-episode set:
   # 5 cube positions, 10 episodes each

3. 3
   Iniciar o fine-tune

   O comando do guia lerobot, não modificado. A documentação estima 20000 passos em aproximadamente 4 horas numa A100. Numa placa de 24 GB, espere mais tempo e meça.

   bash

   cd lerobot && lerobot-train \
     --policy.path=lerobot/smolvla_base \
     --dataset.repo_id=${HF_USER}/mydataset \
     --batch_size=64 \
     --steps=20000 \
     --output_dir=outputs/train/my_smolvla \
     --job_name=my_smolvla_training \
     --policy.device=cuda \
     --wandb.enable=true

4. 4
   Reduzir o tamanho do batch até que caiba

   batch_size=64 é um exemplo documentado, não uma promessa sobre a sua placa. A documentação aconselha começar pequeno e aumentar enquanto os tempos de carregamento permanecerem curtos.

   bash

   lerobot-train --help

5. 5
   Implementar o checkpoint no braço

   Mesma biblioteca, um comando. As flags de chunking em tempo real estão comentadas na documentação e são as que devem ser usadas em hardware de baixa potência.

   bash

   lerobot-rollout \
     --strategy.type=base \
     --robot.type=so101_follower \
     --robot.port=/dev/ttyACM0 \
     --robot.id=my_blue_follower_arm \
     --robot.cameras="{ front: {type: opencv, index_or_path: 8, width: 640, height: 480, fps: 30}}" \
     --task="Grasp a lego block and put it in the bin." \
     --policy.path=HF_USER/FINETUNE_MODEL_NAME

Duas maneiras de colocar um VLA pequeno num braço

Quando um modelo pequeno é a escolha errada

Ambos os artigos são mais cuidadosos aqui do que os resumos. A análise de falhas do TinyVLA é específica: a variante de 0,4 B falhou três vezes ao interpretar mal a instrução, o que os autores atribuem à compreensão limitada da linguagem no VLM menor, e esse modo desapareceu em 1,3 B. O SmolVLA mostra a mesma curva do outro lado: a versão de 2,25 B da arquitetura idêntica pontua 88,75 no LIBERO e 68,24 no Meta-World contra 87,3 e 57,3 para o modelo de 0,45 B.

A comparação que vale a pena fazer não é TinyVLA contra SmolVLA. É SmolVLA contra ACT na sua própria tarefa, e o artigo do SmolVLA é o argumento para isso. Treinado para uma única tarefa sem pré-treinamento em robótica, o SmolVLA obteve uma média de 40,0 em três tarefas SO-100, onde o ACT de tarefa única conseguiu 48,3. O que o eleva para 78,3 é o pré-treinamento comunitário mais o treinamento multi-tarefa, não a arquitetura sozinha. Na tarefa de lego SO-101, ambas de tarefa única, o SmolVLA vence: 90 contra 70 em distribuição. Então SmolVLA contra Pi0.5 se o orçamento permitir.

Uma tabela de decisão sobre a qual você pode agir

Para a última linha, o braço ao vivo transmite um SO-100 físico que você pode controlar do navegador sem uma conta, e as três formas de começar cobrem o resto. O SO-100 é o braço de referência aqui, custando aproximadamente 110 a 150 EUR em peças, com um guia completo de configuração.

O que vem depois dos modelos sub-1 B

Reduzir a contagem de parâmetros é uma forma de tornar um VLA barato e não é obviamente a vencedora. OpenVLA-OFT (arXiv 2502.19645) mantém o backbone de 7 B e altera apenas como as ações são decodificadas, relatando um aumento de 26x na taxa de transferência de geração de ações e o LIBERO subindo de 76.5 para 97.1 por cento. BitVLA (arXiv 2506.07530) torna ternário cada peso de um backbone BitNet b1.58 2B4T de 1 bit, relatando 11.0x menos memória e 4.4x menor latência de ponta a ponta, enquanto iguala o OpenVLA-OFT de precisão total. X-VLA-0.9B (arXiv 2510.10274) se posiciona na linha de 1 B com flow matching.

O ponto em comum: o decodificador de ações, não o modelo de linguagem, é onde reside a latência. Pergunte como uma política emite ações antes de perguntar quantos parâmetros ela possui. A arena possui 85 modelos e 332 resultados, cada um vinculado à sua fonte; há uma visão geral mais ampla em nossa introdução aos VLA.