Modelos VLA Pequeños: TinyVLA, SmolVLA y el Caso Sub-1B

Casi todos los modelos de visión-lenguaje-acción de los que se escribe asumen una tarjeta de centro de datos. OpenVLA tiene 7 B de parámetros. GR00T N1.7 y Pi0.5 tienen alrededor de 3 B y requieren una A100 de 80 GB para el ajuste fino. Si la tarjeta en su escritorio es una 4090, esa clase de modelo está fuera de su alcance.

Dos artículos argumentan que no es necesario. TinyVLA (arXiv 2409.12514, aceptado por IEEE Robotics and Automation Letters en febrero de 2025) construye un VLA a partir de un backbone de 400 M a 1.3 B más un cabezal de acción por difusión. SmolVLA (arXiv 2506.01844, enviado el 2 de junio de 2025) distribuye 450 M de parámetros con pesos abiertos, datos abiertos y un script que se ejecuta en una tarjeta de consumidor. Esto es lo que ambos midieron, y dónde el argumento de menos de 1 B deja de ser válido.

¿Qué se considera realmente un VLA pequeño?

El recuento de parámetros en una tarjeta de modelo no es un número único. Puede referirse al total de pesos, a los pesos cargados durante la inferencia o a los pesos que reciben gradientes durante . TinyVLA informa ambos, y la brecha es grande: TinyVLA-H tiene un total de 1.3 B pero 143 M entrenables, porque la torre de visión y la mayor parte del modelo de lenguaje permanecen congelados mientras los adaptadores LoRA y el cabezal de acción se mueven. El artículo sitúa la proporción entrenable en aproximadamente un 5 por ciento.

Hay dos filas que merecen discusión. con aproximadamente 80 M es más pequeño que todo lo demás aquí, pero no tiene un modelo de lenguaje, por lo que no es un VLA: aprende una tarea y no se le puede indicar que haga otra. con 27 M se condiciona a través de un codificador de texto T5-Base, no un backbone LLM. Son buenas líneas base, pero ninguna ofrece el seguimiento de instrucciones que implica la etiqueta.

TinyVLA: la velocidad viene de la cabeza, no del backbone

La lectura obvia es que hicieron el modelo de lenguaje más pequeño, por lo que se volvió más rápido. La ablación del artículo dice lo contrario. Intercambiar el backbone de 7 B de OpenVLA por uno de aproximadamente 1 B redujo la predicción por acción de 292 ms a 140 ms, una ganancia de 2x. TinyVLA-H, con un recuento de parámetros comparable, se ejecuta a 14 ms en la misma tarjeta. El otro 10x es el cabezal de acción.

OpenVLA emite acciones como tokens discretizados a través del cabezal del modelo de lenguaje, uno por dimensión de acción, de forma autorregresiva. TinyVLA adjunta un decodificador de difusión que produce el fragmento completo de una sola vez. La Tabla V muestra la arquitectura en TinyVLA-H e intercambia solo el cabezal, en las mismas cinco tareas de robot reales. Es la evidencia más clara en cualquiera de los artículos para el argumento que las políticas de coincidencia de flujo hacen, y la razón por la que Pi0 se alejó de la decodificación de tokens.

Qué puntuó TinyVLA

La fila bimanual tiene una explicación aburrida que el propio artículo ofrece: OpenVLA está preentrenado en Open X-Embodiment, que consiste enteramente en datos de un solo brazo, por lo que un espacio de acción de dos brazos está fuera de distribución y puntúa cero. La línea base de la política de difusión supera a TinyVLA-H en dos de esas tres tareas. Antecedentes en el informe de Open X-Embodiment.

El repositorio de TinyVLA, a agosto de 2026

El artículo es bueno. El código es un lanzamiento de investigación. El repositorio es github.com/liyaxuanliyaxuan/TinyVLA; su README fecha el lanzamiento del código el 17 de febrero de 2025 y el último commit es el 11 de marzo de 2025. Está bien para reproducir un artículo, pero es un problema si se quisiera una biblioteca mantenida.

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 tampoco lee conjuntos de datos de LeRobot. Su formato es HDF5 estilo ACT: action, language_raw, y un grupo de observaciones con imágenes multi-vista, joint_positions, qpos y qvel. El repositorio incluye data_utils/rlds_to_h5py.py para entrada RLDS, y cada tarea se registra manualmente en aloha_scripts/constants.py con su dataset_dir, episode_len y camera_names. Si sus episodios provienen de lerobot o del cliente de escritorio, usted es responsable de la conversión.

# 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 asume un nodo de ocho tarjetas. Establécelo en 1 y reduce el tamaño del lote muy por debajo de 32. No se envía ninguna variante de una sola GPU, por lo que el comando no se puede ejecutar textualmente en una 4090.
• --deepspeed scripts/zero2.json apunta a un archivo que no está en el directorio scripts de nivel superior. Las configuraciones de DeepSpeed se encuentran en llava-pythia/scripts/zero2.json. Corrige la ruta antes de tu primera ejecución.
• El README requiere que el nombre del directorio de salida contenga llava_pythia, más lora si LoRA está habilitado.
• El backbone es una descarga separada: lesjie/Llava-Pythia-400M, -700M o -1.3B. No hay un único checkpoint base al que apuntes una política de la misma manera que apuntas a lerobot/smolvla_base.

SmolVLA: el modelo de menos de 1 B que puedes ejecutar esta tarde

SmolVLA presenta el mismo argumento dentro de una biblioteca mantenida. Tiene 450 M de parámetros en un backbone SmolVLM2-500M-Video-Instruct, y la eficiencia proviene de las configuraciones que puedes leer en configuration_smolvla.py en lugar de una afirmación sobre su tamaño reducido.

El preentrenamiento utilizó 481 conjuntos de datos comunitarios de LeRobot, 22.9 K episodios y 10.6 M fotogramas en 4 GPUs, 200000 pasos con un tamaño de lote global de 256; el artículo estima el proyecto completo en aproximadamente 30 K horas de GPU. Un número a tener en cuenta: el blog de lanzamiento de Hugging Face menciona 487 conjuntos de datos curados, mientras que la tabla del artículo indica 481. Utilizamos la cifra del artículo y señalamos la discrepancia.

Un accidente ayuda: la tabla Meta-World del artículo de SmolVLA incluye los propios números publicados de TinyVLA como línea base, así que por una vez ambos modelos se encuentran en una misma tabla, SmolVLA-0.45B con 57.3 frente a TinyVLA-H con 31.6. También informa que el entrenamiento de SmolVLA es aproximadamente un 40 por ciento más rápido que Pi0 con 6 veces menos memoria. Todo esto proviene de los autores de SmolVLA; la entrada de la arena enlaza cada valor a su fuente.

Dónde SmolVLA emplea su tiempo

AY-Robots lista a SmolVLA en 245 ms por paso de acción y a ACT en 20 ms en el catálogo de políticas. TinyVLA reporta 14 ms por predicción de acción. Esos números no son comparables, y tratarlos como si lo fueran es el error más común en este tema: algunos miden un pase hacia adelante, otros dividen ese pase entre un fragmento una vez que el chunking de acciones lo amortiza.

• SmolVLA emite 50 acciones por pase hacia adelante y ejecuta las 50. A los 30 fps que el artículo utiliza en robots reales, una inferencia cubre aproximadamente 1.7 segundos de movimiento.
• La inferencia asíncrona calcula el siguiente fragmento mientras el actual aún se ejecuta: 9.7 s de tiempo promedio de finalización de tarea frente a 13.75 s síncronos, aproximadamente un 30 por ciento más rápido, y 19 ciclos de pick-and-place en una ventana fija de 60 segundos frente a 9.
• Las tasas de éxito fueron comparables en lugar de mejores, 78.3 síncronas frente a 73.3 asíncronas. La asincronía compra rendimiento, no precisión.
• El chunking oculta la latencia de cómputo, no la latencia de red, y hace que la política sea menos reactiva porque está comprometida con 50 acciones.

Ajuste fino de SmolVLA en una tarjeta de consumo

La ruta manual, en lerobot 0.6.1, la versión actual de PyPI a partir del 23 de agosto de 2026. Todo lo siguiente proviene de la documentación de Hugging Face lerobot SmolVLA, obtenida el mismo día; la versión guiada es más suave.

1. 1
   Instalar lerobot con el extra smolvla

   Las dependencias de SmolVLA son un extra opcional, no forman parte de la instalación base. Instalar sin ellas y luego preguntarse por qué el tipo de política es desconocido es una media hora perdida común.

   bash

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

2. 2
   Obtener un conjunto de datos con suficientes episodios

   La documentación recomienda alrededor de 50 episodios y afirma que la misma tarea con 25 no fue suficiente. AY-Robots establece el mínimo en 30. Grabe los suyos propios, o empiece desde el directorio de conjuntos de datos.

   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 el ajuste fino

   El comando de la guía de lerobot, sin modificar. La documentación estima 20000 pasos en aproximadamente 4 horas en una A100. En una tarjeta de 24 GB, espere más tiempo y mídalo.

   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
   Reducir el tamaño del lote hasta que quepa

   batch_size=64 es un ejemplo documentado, no una promesa sobre su tarjeta. La documentación aconseja empezar con un valor pequeño y aumentarlo mientras los tiempos de carga sigan siendo cortos.

   bash

   lerobot-train --help

5. 5
   Desplegar el punto de control en el brazo

   La misma biblioteca, un comando. Las banderas de fragmentación en tiempo real están comentadas en la documentación y son las que hay que usar en hardware de baja potencia.

   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

Dos formas de llevar un VLA pequeño a un brazo

Cuando un modelo pequeño es la elección equivocada

Ambos artículos son más cuidadosos aquí de lo que lo son los resúmenes. El análisis de fallos de TinyVLA es específico: la variante de 0.4 B falló tres veces al interpretar erróneamente la instrucción, lo que los autores atribuyen a una comprensión lingüística limitada en el VLM más pequeño, y ese modo desapareció en 1.3 B. SmolVLA muestra la misma curva desde el otro extremo: la versión de 2.25 B de la arquitectura idéntica obtiene 88.75 en LIBERO y 68.24 en Meta-World, frente a 87.3 y 57.3 para el modelo de 0.45 B.

La comparación que vale la pena hacer no es TinyVLA contra SmolVLA. Es SmolVLA contra ACT en tu propia tarea, y el artículo de SmolVLA es el argumento de por qué. Entrenado en una sola tarea sin preentrenamiento robótico, SmolVLA promedió 40.0 en tres tareas SO-100 donde ACT de una sola tarea logró 48.3. Lo que lo eleva a 78.3 es el preentrenamiento comunitario más el entrenamiento multitarea, no solo la arquitectura. En la tarea de lego SO-101, ambas de una sola tarea, SmolVLA sí gana: 90 contra 70 en distribución. Luego SmolVLA contra Pi0.5 si el presupuesto lo permite.

Una tabla de decisiones sobre la que puede actuar

Para la última fila, el brazo en vivo transmite un SO-100 físico que puedes controlar desde el navegador sin una cuenta, y las tres formas de empezar cubren el resto. El SO-100 es el brazo de referencia aquí, con un costo aproximado de 110 a 150 EUR en piezas, con una guía completa de configuración.

¿Qué viene después de los modelos de menos de 1 B?

Reducir el número de parámetros es una forma de hacer que un VLA sea económico y no es obviamente la más exitosa. OpenVLA-OFT (arXiv 2502.19645) mantiene la arquitectura base de 7 B y solo cambia cómo se decodifican las acciones, reportando un aumento de 26x en el rendimiento de generación de acciones y un incremento de LIBERO del 76.5 al 97.1 por ciento. BitVLA (arXiv 2506.07530) convierte cada peso de una arquitectura base BitNet b1.58 2B4T de 1 bit en ternario, reportando 11.0x menos memoria y 4.4x menor latencia de extremo a extremo, igualando el rendimiento de OpenVLA-OFT de precisión completa. X-VLA-0.9B (arXiv 2510.10274) se sitúa en la línea de 1 B con emparejamiento de flujo.

El hilo conductor: el decodificador de acciones, no el modelo de lenguaje, es donde reside la latencia. Pregunta cómo una política emite acciones antes de preguntar cuántos parámetros tiene. La arena tiene 85 modelos y 332 resultados, cada uno vinculado a su fuente; hay una visión general más amplia en nuestra introducción a los VLA.