Little-lm 3.8B: entrenan un LLM por US$998 y supera a GPT-2

Un ingeniero, US$998 y un modelo que supera a GPT-2 en el benchmark CORE

El 10 de septiembre de 2026, Hugo Vergnes publicó un experimento singular: entrenó desde cero un LLM de 3,8 mil millones de parámetros durante 43 horas en 8 GPU B200 alquiladas, gastando US$998 en cómputo y 65 mil millones de tokens de entrenamiento. El modelo, llamado little-lm, alcanzó 0,384 en el benchmark CORE (DCLM), una puntuación que deja atrás al GPT-2 de 1,5B parámetros publicado por OpenAI en 2019, que se quedó en 0,2565.

Lo más interesante no es el resultado en sí, sino el método: una persona, varias noches, una tarjeta local RTX 5090 para iterar y luego un nodo de B200 alquilado por horas. El proyecto está abiertamente inspirado en nanochat, el repositorio de Andrej Karpathy que se autodefine como "el mejor ChatGPT que US$100 pueden comprar" y que en su versión de US$1.000 (nodo de 8×H100, ~33 horas) alcanza 0,310 en CORE con ~1B parámetros, según la documentación del proyecto recogida por Hackaday. little-lm mejora esa marca con un modelo casi cuatro veces más grande y un costo similar.

¿Qué arquitectura tiene el modelo y por qué importa?

little-lm es estilo Llama, con piezas modernas que conviene reconocer:

🤖 La IA no es solo para leer sobre ella

En la comunidad la aplicamos: automatización, agentes IA y herramientas reales para emprender, no solo para informarte.

👥 Aplicarla en la comunidad

RMSNorm y RoPE para normalización y codificación posicional.
GQA (Grouped Query Attention) con 24 cabezas de consulta y 8 de clave/valor (ratio 3:1) para ahorrar memoria de caché.
MLPs no gated con activación relu² (dos multiplicaciones de matriz en lugar de tres), un trade-off throughput vs. calidad que el autor acepta.
QK-norm, logit softcap de 15 y escalas residuales aprendidas por capa.
Lo más distintivo: value embeddings estilo ResFormer — tablas de vocabulario × dimensión KV en 14 capas alternas. Esas tablas pesan 721,2 millones de parámetros, el 19% del modelo total.

El detalle de los value embeddings no es decorativo: el autor demuestra que aportan 3,2% más CORE y 0,46% mejor loss que un modelo idéntico sin ellas, por sólo 19% más parámetros, sin coste adicional de cómputo porque son lookups, no multiplicaciones de matriz.

Los números exactos: lo que cuesta entrenar un 3.8B hoy

Configuración	Parámetros	Tokens	Hardware	Tiempo	Costo	CORE
GPT-2 (2019)	1,5B	—	—	—	—	0,2565
nanochat d26	~561M	11,2B	8×H100	~3h	—	~0,258
nanochat d32	~1B	—	8×H100	~33h	~US$1.000	0,310
little-lm 3.8B (1024 ctx)	3,848B	57,3B	8×B200	35,9h	US$820	0,338
little-lm 3.8B (2048 ctx)	3,848B	65,3B	8×B200	43h	US$998	0,384

En estado estable, el entrenamiento corrió a ~480.000 tokens/s, lo que sitúa los 57,3B tokens en unas 33 horas de cómputo puro; el reloj real fue 35,9h porque las evaluaciones CORE añaden ~15 minutos cada una (diez en total, 7% del tiempo). Las B200 rindieron unas 1.047 TFLOP/s sostenidos por GPU, alrededor del 25% del pico FP8 denso de Blackwell y 50% frente al pico bf16 — exactamente el régimen esperado para entrenamientos bien alimentados por los tensor cores.

Cinco cambios que desbloquearon el salto (y un post-mortem honesto)

Antes del modelo de US$998 hubo un fracaso útil: un 858M sobre FineWeb-Edu, 16,4B tokens, 5,8 días en una sola A100. Resultado: PIQA 60,45%, peor que GPT-2 124M (2019). Vergnes hizo la autopsia y corrigió cinco cosas:

LR trapezoidal en lugar de coseno a cero: el cooldown lineal mantiene tasa útil hasta el final. En la corrida final el eval loss seguía bajando en el último step.
Muon para matrices + AdamW para el resto: Muon cuesta ~25% por step (Newton-Schulz), pero con 7 pasos de acumulación ese overhead se diluye a ~4%, y la convergencia mejora por token.
ClimbMix en lugar de FineWeb-Edu: ClimbMix es el corpus de Nemotron-CLIMB de NVIDIA (Diao et al., 2025), una mezcla de datos construida por clustering iterativo. Vergnes lo describe como "un salto enorme en velocidad de convergencia".
FP8 + padding de vocabulario a múltiplo de 64: FP8 vía torch._scaled_mm con escalado dinámico tensorwise en los tres GEMMs. Sumado al padding (50.257 → 50.304, sólo 47 filas desperdiciadas), dio +33% de throughput.
Contexto 1024 en lugar de 2048 durante la corrida principal: a memoria fija, recortar contexto duplica el batch y los tokens por segundo apenas cambian — señal de que los MLPs dominan el cómputo, no la atención.

Qué probó y descartó (la parte más honesta del informe)

No todo funcionó. Estos son los hallazgos negativos:

Máscaras de frontera de documento con flex attention: elegante, pero Andrej Karpathy ya había mostrado que la fuga entre documentos bajo packing BOS-aligned no hace mucho daño. Se borró y volvió a scaled_dot_product_attention causal puro.
Liger RMSNorm y RoPE: RoPE era 2,2× más rápido en microbenchmark pero no movió el throughput end-to-end; RMSNorm de Liger era más lento que F.rms_norm de PyTorch 2.9. Ambos revertidos.
Inicialización estilo nanochat (embeddings N(0, 0.8), proyecciones de salida a cero): la curva arranca marginalmente más baja pero se solapa con la inicialización clásica hacia los 1.500 steps. Se quedó por estética, no por evidencia.
Datasets en streaming: incluso con red sana, los shards locales dieron 2-3% más throughput, y los dips ocasionales de red costaban más que eso. Para runs largos vale la pena descargar al inicio.

La trampa del contexto: 1024 vs 2048 cambia el marcador, no el modelo

Este es el hallazgo más contraintuitivo del informe. Tres de las 22 tareas de CORE — SQuAD, BoolQ y bigbenchlanguageid — tienen prompts que casi nunca caben en 1024 tokens:

En SQuAD el 100% de los prompts se recortaron; en BoolQ el 99,8%; en language_id el 99,7%.
SQuAD es 10-shot, así que el ejemplo real (~169 tokens) sobrevivió, pero los 10 ejemplos de demostración se cortaron. El modelo leyó el pasaje y la pregunta, pero nunca vio el formato de salida esperado. Como SQuAD puntúa por match exacto de token, la prosa fluida suma cero. El modelo decayó monotónicamente a 0,000 a medida que mejoraba como modelo de lenguaje: al ser más preciso, dejó de acertar por casualidad.
Pasar de 1024 a 2048 movió el CORE de 0,338 a 0,384. SQuAD y BoolQ explican el 83% de la ganancia. Las 19 tareas restantes se movieron +0,008 combinadas — "lo que 14% más tokens te comprarían por sí solos". Coste: 9% menos throughput (480K → 437K tok/s).

Implicación práctica: si vas a reportar CORE, 2048 de contexto no es opcional para no subestimar tu propio modelo. Si lo que buscas es un score rápido durante desarrollo, 1024 es válido pero debes saber que tres tareas concretas будут报告adas como casi cero sin que tu modelo tenga la culpa.

¿Qué significa esto para tu startup?

Tres lecciones concretas para founders que construyen sobre LLMs, extraídas del experimento:

El techo de US$1.000 ya supera a un modelo de frontera de 2019. little-lm 3.8B bate a GPT-2 (OpenAI, 2019, equipo grande, presupuesto institucional) en CORE por un margen amplio. Si tu producto depende de un LLM propio por privacidad, costo o latencia, el presupuesto realista para una iteración decente cabe en una factura de tarjeta de crédito. El paper de Karpathy nanochat lleva meses mostrando lo mismo desde el otro extremo (US$100, ~4h, 8×H100).
La infraestructura es lo que separa al experimento del producto. Vergnes insiste: separar concerns, interfaces limpias, componentes intercambiables. Lo define como "infraestructura que casi nunca requiere editar código a mano". Cada run es un YAML de tres líneas. En tu startup: si vas a iterar sobre prompts, fine-tunes o arquitecturas, paga el costo de hacer la infra aburrida una vez. El primer problema de convergencia te lo devuelve con intereses.
Tres perillas son las que más rinden por dólar: optimizador (Muon para matrices), precisión (FP8) y alineación de tensores (padding de vocabulario). En su corrida en una sola 5090, esos tres cambios (más la FusedLinearCrossEntropyLoss de Liger) le llevaron de 26.144 a 37.621 tok/s, un +44% con el mismo hardware. Para un founder, eso significa: o el mismo entrenamiento cuesta 44% menos, o con el mismo presupuesto entrenas un modelo 44% más grande.

El movimiento del campo apunta en esa dirección: Karpathy publicó en marzo de 2026 autoresearch, un agente que corre 700 experimentos en dos días sobre un codebase congelado y acumula sólo las mejoras que sobreviven validación, según TechTimes. Tras ese resultado, Karpathy se sumó a Anthropic para usar Claude acelerando el pre-training de Claude. La tesis es que el cuello de botella ya no es el cómputo: es quién sabe exprimir cada FLOP por dólar. Proyectos como little-lm son la prueba pública de que esa habilidad ya no requiere un laboratorio.

Conclusión

En 2019 GPT-2 fue un resultado de frontera producido por un laboratorio bien financiado. Siete años después, Hugo Vergnes lo supera por un margen amplio en sus tardes, por US$998, en hardware alquilado por horas. La frontera se movió, y todo lo que venía con ella también: lo que necesitaba un laboratorio hoy lo puede hacer un solo ingeniero. little-lm no es un producto, es un data point sobre qué es alcanzable fuera de las grandes estructuras — y los datos que deja (qué funcionó, qué no, qué se ablación) son probablemente la parte más útil para quien esté pensando en entrenar, no consumir, modelos propios.