Costo de Entrenamiento VLA: Lo que Realmente Cuesta una Ejecución de Ajuste Fino

La factura tiene cuatro líneas, y la GPU es la más pequeña

Cuando la gente pregunta cuánto cuesta ajustar un modelo de visión-lenguaje-acción para un SO-100, casi siempre se refieren al alquiler de la GPU. Ese es el número que aparece como cargo en una tarjeta, por lo que es el que se siente real. También es, por un amplio margen, el más pequeño de los cuatro números que deciden lo que realmente cuesta una política en funcionamiento.

Los tiempos de entrenamiento a continuación provienen de los propios artículos y repositorios de los cinco modelos, el costo del hardware del listado de materiales publicado, los números de la plataforma de AY-Robots catálogo de políticas y página de precios. Cuando la plataforma no ayuda, este artículo lo indica.

Lo que realmente cuesta una hora de GPU en el mercado spot

No hay un precio único para una hora de A100. En un marketplace como vast.ai, cada host establece su propia tarifa, y la ejecución de entrenamiento que lanzas aterriza en la máquina que esté barata y libre en ese segundo. La respuesta honesta es una distribución. Aquí está, medida el 23 de agosto de 2026 a las 13:44 UTC: tarjetas completas individuales, bajo 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 qué los modelos 3B no pueden usar la tarjeta barata

Una hora de 4090 y una hora de H100 de 80 GB difieren en aproximadamente seis veces en las medianas anteriores. Lo que te obliga a usar la tarjeta cara no es la velocidad, es la memoria. openpi establece el mínimo para un Pi0.5 completo ajuste fino en 70 GB, y NVIDIA recomienda 40 GB o más para GR00T. Nótese lo que el número de GR00T no es. Su configuración de ajuste fino congela el modelo de lenguaje y el codificador visual por defecto (tune_llm y tune_visual son False, el proyector y el cabezal de difusión True), razón por la cual el catálogo lista aproximadamente 40 M de parámetros entrenados de un total de 3 B. Los 40 GB no son el estado del optimizador para 3 B de pesos, es el backbone congelado más las activaciones. Las variantes de alcance reducido requieren menos: la ruta LoRA de openpi necesita 22.5 GB y menciona la 4090, y el flujo de trabajo Isaac Lab Arena de NVIDIA lista una opción de GPU única de 24 GB para el post-entrenamiento de GR00T. La plataforma se basa en los mínimos que cada proveedor publica para la configuración que realmente ejecuta. El artículo sobre flow-matching de pi0 explica de dónde viene esa coincidencia de flujo huella.

Esa tabla es la razón por la que la plataforma divide los cinco modelos en dos niveles. GR00T N1.7, GR00T N1.5 y Pi0.5 se ejecutan en A100 de 80 GB o H100 porque eso es lo que los proveedores solicitan. SmolVLA y ACT se ejecutan en una RTX 4090 o cualquier tarjeta de 24 GB porque eso es realmente suficiente.

¿Cuánto tiempo se ejecuta realmente cada uno de los cinco modelos?

El tiempo de ejecución es la otra mitad del costo: 2.00 USD por hora es irrelevante si el trabajo dura 40 minutos y ruinoso si dura 40 horas. Estos son los valores predeterminados que AY-Robots realmente envía al entrenador, con la ventana de ejecución y el costo para cada nivel.

De dónde provienen esos rangos de tiempo de ejecución

• SmolVLA: la documentación de lerobot indica que 20,000 pasos tardan aproximadamente 4 horas en una sola A100. La plataforma ejecuta los mismos 20,000 pasos en el nivel más económico de 24 GB, de ahí un rango de tiempo en lugar de 4 horas exactas.
• ACT: el artículo original de ALOHA reporta alrededor de 5 horas en una sola RTX 2080 Ti de 11 GB para un modelo de 80 millones de parámetros. Una 4090 es varias generaciones más nueva, pero la plataforma presupuesta 100,000 pasos, por lo que el rango de tiempo se mantiene en el mismo lugar.
• GR00T: el flujo de trabajo de referencia de NVIDIA para la generación N1.6 cita aproximadamente de 4 a 8 horas para 20,000 pasos con un tamaño de lote de 24 en ocho tarjetas L40S, y de 2 a 3 horas para 30,000 pasos con un tamaño de lote de 16 en una sola Ada 6000. El ajuste fino de una VLA de 3B en una sola tarjeta en unas pocas horas es normal, no optimista.
• Pi0.5: openpi no publica una cifra de tiempo real, pero sí publica el requisito mínimo de 70 GB para un ajuste fino completo, lo que determina la tarjeta y, por lo tanto, la tasa.

Vale la pena detenerse en el número que no está pagando. El artículo de GR00T N1 reporta aproximadamente 50,000 horas de GPU H100 para preentrenar el modelo 2.2B, en un clúster de hasta 1024 GPUs, con un tamaño de lote de preentrenamiento de 16,384 para 200,000 pasos de gradiente. Al precio de 1.34 a 2.34 USD por hora medido anteriormente, eso representa un costo de computación alquilada del orden de 67,000 a 117,000 USD. El artículo de SmolVLA sitúa su proyecto en aproximadamente 30,000 horas de GPU a lo largo de 481 conjuntos de datos comunitarios, 22.9K episodios y 10.6M fotogramas. Usted hereda todo esto por el precio de una descarga; sus 8 USD compran los últimos 20,000 pasos. Por qué las VLA se construyen de esta manera cubre esa división.

El brazo: un costo único que empequeñece la factura de la GPU

Una ejecución de entrenamiento cuesta menos que un almuerzo. El robot no. Por eso el SO-100 importa: es el brazo más barato que toda la aprendizaje por imitación cadena de herramientas realmente soporta.

La lista de materiales upstream en el repositorio SO-ARM100 es más granular y vale la pena verificarla según tu región: su Piezas para dos brazos lista suma 229.88 USD o 226.30 EUR para una configuración de líder más seguidor, y su Piezas para un brazo seguidor lista suma 121.94 USD o 124.30 EUR. Seis servos STS3215 a 13.89 USD cada uno son 83.34 de esos 121.94, por lo que los servos son el brazo. A 1 to 3 USD por ejecución de SmolVLA o ACT, un par de brazos vale entre 77 y 230 ejecuciones de entrenamiento. Si aún estás eligiendo, SO-100 contra SO-101 es la comparación que importa, porque los dos son lo suficientemente parecidos como para que la decisión sea sobre disponibilidad en lugar de capacidad.

Horas humanas: la línea que nadie pone en la hoja de cálculo

Este es el número que pone patas arriba la discusión sobre los costos. Grabar demostraciones implica que una persona mueva un brazo robótico, un episodio a la vez, en tiempo real. No se puede procesar por lotes ni alquilar por segundos. El conjunto de datos de LeRobot grabador se envía con valores predeterminados que facilitan la aritmética, los tres confirmados en DatasetRecordConfig: 60 segundos por episodio, 60 segundos para reiniciar la escena, 50 episodios. La columna de dinero a continuación asume 15 USD por una hora del tiempo de una persona, lo cual es una suposición en lugar de un número de plataforma. Sustituya su propia tarifa; la proporción es lo importante.

1. 1
   Grabe el conjunto de datos con los valores predeterminados por los que realmente se le facturará

   Esta es la versión 0.6.1 de lerobot, la versión en PyPI a partir del 3 de agosto de 2026. Observe la forma de la CLI: la grabación se ejecuta a través del punto de entrada de la consola lerobot-record (lerobot.scripts.lerobot_record), no la antigua ruta del módulo python -m lerobot.scripts.record. AY-Robots apunta a la versión 0.5.1, y el paquete 0.5.1 declara los mismos puntos de entrada lerobot-record y lerobot-train, por lo que la forma a continuación es estable en ambas. Las tres banderas de tiempo son los valores predeterminados de origen, por lo que este es también el comando que asume la aritmética en la siguiente tabla.

   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
   Mire lo que grabó antes de alquilar un solo minuto de GPU

   Inspeccionar un conjunto de datos cuesta cero USD por hora. Descubrir el mismo problema a partir de una curva de pérdida cuesta 2.00 USD por hora en el nivel H100 y le informa con cuatro horas de retraso. Suba el conjunto de datos y revíselo en el visor de LeRobot, o explore el directorio de conjuntos de datos de 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
   Entrene y asegúrese de que el punto de control sobreviva al pod

   Una máquina alquilada es temporal por definición, así que escriba los puntos de control en algún lugar duradero durante la ejecución. Dos banderas deciden si conserva lo que pagó. --save_freq tiene un valor predeterminado de 20,000 pasos, por lo que una ejecución predeterminada de SmolVLA de 20,000 pasos escribe su primer punto de control cuando la ejecución ya ha terminado; bájelo antes de alquilar cualquier cosa interrumpible. --save_checkpoint_to_hub requiere --policy.repo_id y no existe en lerobot 0.5.1, por lo que en esa versión debe copiar el directorio de salida de la máquina usted mismo. El tamaño de lote a continuación es el ejemplo del documento de origen; el formulario de AY-Robots envía 2 para SmolVLA y escribe en el almacenamiento de objetos a medida que aparecen los puntos de control.

   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 la columna de la derecha con los 1 a 12 USD que cuesta la ejecución. A esa tasa asumida, un conjunto de datos de 50 episodios cuesta de dos a siete veces más grabar que entrenar, antes de la calibración, la configuración de la cámara y los episodios que se descartan. Por eso tiene un valor monetario directo. La guía de lerobot sugiere al menos 50 episodios con 10 por ubicación de objeto; la documentación de SmolVLA informa que una versión de 25 episodios de la misma tarea no fue suficiente.

Dónde se pierde realmente el dinero

1. Ejecuciones con datos que nunca iban a funcionar

Una ejecución de GR00T de 20.000 pasos en un conjunto de datos con dos flujos de cámara intercambiados cuesta lo mismo que una en un conjunto de datos limpio, toma el mismo tiempo y produce una curva de pérdida que parece correcta. El fallo aparece en el brazo, horas después. se facturan por hora y el diagnóstico se factura en días. Dos síntomas que vale la pena memorizar: usualmente significa que las observaciones no contienen lo que la tarea necesita, y significa que el conjunto de datos tenía menos variación de la que pensabas.

2. Pagar precios de modelo fundacional para una tarea de cámara fija

ACT tiene aproximadamente 80M de parámetros y fue diseñado para entrenar desde cero con 50 demostraciones de una tarea. GR00T N1.7 tiene aproximadamente 3B con un backbone preentrenado. Para una cámara atornillada, una mesa fija y un objeto, el modelo de 80M frecuentemente lo logra, se ejecuta a unos 20 ms por paso de acción en lugar de 152 ms, y cuesta de 1 a 3 USD por ejecución en lugar de 4 a 12. Gaste 3 USD en averiguar si el modelo barato funciona antes de gastar 12 USD en el caro. ACT contra SmolVLA y GR00T N1.7 contra Pi0.5 muestran dónde cada uno deja de ser la respuesta correcta; la arena de modelos tiene 85 modelos y 332 resultados de benchmark.

3. La GPU que olvidaste

El error más barato de prevenir y el más común de cometer. Una instancia iniciada un viernes para depurar algo factura durante el fin de semana a la misma tarifa que una ejecución real.

En AY-Robots, este fallo se ha eliminado para la inferencia: los pods aprovisionados por la API de inferencia incluyen un vigilante de inactividad y se autodestruyen después de un período de inactividad. Si alquilas la tarjeta tú mismo, ese vigilante es tu recordatorio del calendario.

4. Pagar dos veces por la misma respuesta

El punto de entrada de ajuste fino de GR00T es una CLI de tyro que no expone ninguna semilla. Eso no es una limitación de la plataforma, es la herramienta original: no hay un campo de semilla en gr00t/configs/finetune_config.py, y los propios consejos de entrenamiento del repositorio advierten que las ejecuciones varían entre un 5 y un 6 por ciento porque las aumentaciones de imagen no son deterministas. lerobot utiliza por defecto la semilla 1000 tanto en 0.5.1 como en 0.6.1, por lo que las ejecuciones de ACT, SmolVLA y Pi0.5 pueden al menos ser repetidas desde la misma inicialización y orden de datos. Eso no es una promesa de pesos idénticos bit a bit en una GPU, pero es la diferencia entre una repetición y un nuevo experimento. Si una ejecución de GR00T produce una política que funciona y no guardaste el punto de control, pagas el precio completo por un resultado que puede diferir más de la diferencia que buscabas. Hay una segunda forma de perder un punto de control por el que pagaste: la CLI utiliza por defecto --save-total-limit 5, documentado como el número máximo de puntos de control que se conservan antes de que se eliminen los más antiguos. El almacenamiento cuesta céntimos; una repetición cuesta de 4 a 12 USD y seis horas.

Hacerlo tú mismo versus dejar que la plataforma alquile la tarjeta

# 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>

¿Qué cobra la plataforma y cómo elige la tarjeta?

La lógica es deliberadamente sencilla. Cada modelo en el catálogo, declara un nivel de GPU; el backend toma la VRAM requerida y alquila una tarjeta compatible en el mismo mercado spot medido anteriormente. Por eso el costo cotizado es un rango, no un precio. GR00T y Pi0.5 son solo para la nube aquí debido a los límites inferiores de 40 GB y 70 GB. SmolVLA y ACT también se ejecutan localmente en su propia tarjeta de 24 GB, donde el costo de la nube es cero y la electricidad es su problema.

Un ajuste merece una advertencia. La acumulación de gradientes se aplica genuinamente a ambas variantes de GR00T, por lo que aumentarla permite un tamaño de lote efectivo mayor en la misma tarjeta. Para Pi0.5 y SmolVLA no se aplica en absoluto: lerobot 0.5.1 no tiene opción de acumulación de gradientes en su configuración de entrenamiento, por lo que establecer el campo en 16 no cuesta nada y no aporta nada. Si un trabajo en cola nunca comienza, la página de trabajos atascados en cola, cubre qué verificar; si el conjunto de datos es rechazado antes de que comience la ejecución, casi siempre es el problema del formato v3.0.

Un presupuesto detallado para una primera política funcional

Las cuatro líneas juntas, empezando de cero. El total de GPU asume de 3 a 5 ejecuciones: la primera prueba que el pipeline funciona, la segunda expone un problema de datos, la tercera o cuarta es la que se conserva.

El patrón se mantiene para este tamaño de robot: la computación es un error de redondeo, el hardware es un costo único real, las horas humanas son el gasto recurrente. Para probar la parte de entrenamiento antes de comprar nada, le permiten comparar modelos y alquilar una GPU sin un brazo, y es un SO-100 físico que puede controlar en el navegador sin necesidad de registrarse. Para la pipeline completa de principio a fin, la cubre la configuración, la y el entrenamiento, y es la versión corta.