Forem

Cover image for ¿Cómo Entrenar Tu Propio ChatGPT por $50?
Roobia
Roobia

Posted on • Originally published at apidog.com

¿Cómo Entrenar Tu Propio ChatGPT por $50?

TL;DR

nanochat es el framework open source de Andrej Karpathy para entrenar un LLM tipo GPT-2 por menos de $50 y en 2 horas, usando un solo nodo GPU 8xH100. El código es mínimo (~500 líneas), la configuración se reduce a un solo parámetro (--depth) y la optimización de hiperparámetros es automática. El entrenamiento más reciente terminó en 1.65 horas y puntuó 0.2626 en CORE, superando el GPT-2 original de OpenAI (2019), que costó $43,000 y tomó 168 horas.

Prueba Apidog hoy

Introducción

Entrenar un LLM antes era solo para empresas con millones y equipos de investigación con PhD. Eso se acabó.

Karpathy publica nanochat: IA conversacional de código abierto que entrenas por menos de lo que cuesta una buena cena. Corre todo en un nodo GPU 8xH100, completando el flujo en menos de 2 horas.

Por Qué Esto Importa Ahora

En 2026, entrenar LLM es 100 veces más rápido y barato que en 2019. Lo que costaba $43,000 y 168 horas ahora toma 1.65 horas y $48 gracias a optimización algorítmica y hardware moderno.

Para devs de APIs y equipos IA, esto permite experimentar, ajustar modelos y entender los fundamentos de los LLM sin infraestructuras prohibitivas.

💡 Combina esto con plataformas de desarrollo de API como Apidog para testear y documentar tus servicios IA y tendrás un stack completo para producción.

Lo Que Aprenderás

  • Cómo nanochat logra 100x reducción de costo vs entrenamiento tradicional de LLM
  • Arquitectura completa: modelo GPT, optimizador Muon, data loader
  • Instrucciones paso a paso para entrenar tu propio modelo
  • Cómo usar nanochat para experimentar rápido con LLM
  • Limitaciones y el alcance real de la capacidad GPT-2

¿Qué es nanochat?

nanochat es un entorno mínimo para entrenar LLM: tokenización, preentrenamiento, ajuste fino, evaluación, inferencia y una interfaz web tipo ChatGPT.

nanochat arquitectura

El código es un solo repo, sin configuraciones monstruosas ni frameworks complejos. Karpathy lo plantea como "línea base sólida" para leer, modificar y bifurcar.

La Afirmación Principal

Entrena un modelo GPT-2 (1.6B parámetros) por:

  • $48 on-demand (2h a ~$24/hora en 8xH100)
  • ~$15 usando instancias spot

El GPT-2 original de OpenAI costó $43,000 y 7 días en 32 TPU v3.

Lo que nanochat cubre

Etapa Script Descripción
Tokenización scripts.tok_train Entrenar tokenizador BPE (vocab 32,768)
Preentrenamiento scripts.base_train Entrenar modelo GPT base
Ajuste fino scripts.chat_sft SFT para chat supervisado
Evaluación scripts.base_eval Métrica CORE, bits-por-byte
Inferencia scripts.chat_cli Chat CLI
Interfaz web scripts.chat_web Interfaz web tipo ChatGPT

La Filosofía: Un Solo Selector para Controlar Todo

La mayoría de frameworks LLM requieren múltiples archivos de configuración. nanochat lo reduce todo a un parámetro: --depth (capas del transformador).

# Modelo tipo GPT-1
torchrun --standalone --nproc_per_node=8 -m scripts.base_train -- --depth=12

# Modelo capacidad GPT-2
torchrun --standalone --nproc_per_node=8 -m scripts.base_train -- --depth=24

# Más grande aún
torchrun --standalone --nproc_per_node=8 -m scripts.base_train -- --depth=26
Enter fullscreen mode Exit fullscreen mode

Al ajustar la profundidad, nanochat calcula automáticamente:

  • Ancho del transformador
  • Nº de cabezas de atención
  • Tasas de aprendizaje por grupo de parámetros
  • Pasos totales de entrenamiento
  • Decaimiento de peso
  • Tamaños de lote

Esto habilita la "miniserie nanochat": modelos de diferentes tamaños, todos óptimos y fáciles de comparar.

Por Qué Funciona

Karpathy midió leyes de escalado en múltiples entrenamientos y codificó esas relaciones en el script. Así puedes entrenar de forma óptima sin ser experto en deep learning.

leyes de escalado

La Clasificación: Compitiendo para Vencer al GPT-2

nanochat mantiene una clasificación pública ("race to GPT-2") para superar la puntuación CORE de OpenAI (0.256525) en 22 tareas.

Récords Actuales

Ejecución Modelo Tiempo Puntuación CORE Innovación Clave
GPT-2 Original 1.6B 168 hrs 0.2565 Línea base OpenAI 2019
Ejecución 1 d24 3.04 hrs 0.2585 Línea base inicial
Ejecución 2 d26 2.91 hrs 0.2578 Entrenamiento FP8
Ejecución 3 d26 2.76 hrs 0.2602 Lote de 1M tokens
Ejecución 4 d24 2.02 hrs 0.2571 Dataset ClimbMix
Ejecución 5 d24 1.80 hrs 0.2690 Optimizaciones por IA
Ejecución 6 d24 1.65 hrs 0.2626 Mejora en smear/backout

Cómo la IA Descubrió Optimizaciones

Las ejecuciones 5 y 6 incluyen mejoras de un sistema de "autoinvestigación" (IA prueba cambios arquitectónicos en modelos pequeños y los aplica a d24). Ejemplo:

  • Retroceso: mejor resta residual
  • Smear: mezcla bigramas más eficiente

Resultado: tiempo reducido de 2.02h a 1.65h, mejora del 19% descubierta automáticamente.

Cómo Funciona nanochat

El core tiene ~3,000 líneas en módulos clave:

1. Modelo GPT (nanochat/gpt.py)

Características principales:

  • Incrustaciones rotativas (RoPE)
  • Normalización QK (estabilidad)
  • Pesos no ligados (token/output)
  • ReLU² en MLP
  • Atención GQA (más eficiente)
  • Atención de ventana deslizante (ej. "SSSL")
  • Flash Attention 3

Incrustaciones de valor (ResFormer):

# Value residual: mezcla value embedding por head
if ve is not None:
    ve = ve.view(B, T, self.n_kv_head, self.head_dim)
    gate = 3 * torch.sigmoid(self.ve_gate(x[..., :self.ve_gate_channels]))
    v = v + gate.unsqueeze(-1) * ve
Enter fullscreen mode Exit fullscreen mode

Trucos de eficiencia:

# 1. Escala residual por capa
x = self.resid_lambdas[i] * x + self.x0_lambdas[i] * x0

# 2. Smear: mezcla embedding del token anterior
gate = self.smear_lambda * torch.sigmoid(self.smear_gate(x[:, :, :24]))
x = x + gate * x_pre_smear

# 3. Backout: resta residuo capa intermedia
x = x - self.backout_lambda * x_backout
Enter fullscreen mode Exit fullscreen mode

2. Optimizador Muon (nanochat/optim.py)

Optimización híbrida:

Parámetro Optimizador Propósito
Embeddings, lm_head AdamW Optimización adaptativa
Parámetros escalares AdamW Factores de escala aprendidos
Matrices 2D Muon Actualizaciones ortogonales

Muon (Newton-Schulz "Polar Express"):

# Coeficientes Polar Express (5 iters)
polar_express_coeffs = [
    (8.156, -22.483, 15.879),
    (4.043, -2.809, 0.500),
    # ...
]
for a, b, c in polar_express_coeffs[:ns_steps]:
    A = X.mT @ X
    B = b * A + c * (A @ A)
    X = a * X + X @ B
Enter fullscreen mode Exit fullscreen mode

Reducción de varianza NorMuon:

v_mean = g.float().square().mean(dim=red_dim, keepdim=True)
v_norm = v_mean.sum(dim=(-2, -1), keepdim=True).sqrt()
final_scale = step_size * (v_norm / v_norm_new.clamp_min(1e-10))
g = g * final_scale.to(g.dtype)
Enter fullscreen mode Exit fullscreen mode

Entrenamiento distribuido: Sharding ZeRO-2 con comunicación asíncrona.

Fase 1: reduce_scatter asíncrono
Fase 2: esperar, actualizar, all_gather
Fase 3: esperar, copiar parámetros
Enter fullscreen mode Exit fullscreen mode

3. Gestión de Precisión (nanochat/common.py)

nanochat controla la precisión manualmente:

Hardware dtype predet. Razón
CUDA SM 80+ (A100+) bfloat16 Soporte nativo BF16
CUDA < SM80 (V100) float32 Sin soporte BF16
CPU / MPS float32 Sin núcleos reducción 
class Linear(nn.Linear):
    def forward(self, x):
        return F.linear(x, self.weight.to(dtype=x.dtype))
Enter fullscreen mode Exit fullscreen mode

FP8 disponible en H100/Blackwell con --fp8.

4. Carga de Datos (nanochat/dataloader.py)

  • Cada batch comienza con BOS
  • Empaquetamiento best-fit (minimiza desperdicio)
  • Recorte solo si es necesario
  • 100% de tokens útiles, ~35% recorte a secuencia 2048 
# Best-fit document packing
best_idx = -1
best_len = 0
for i, doc in enumerate(doc_buffer):
    doc_len = len(doc)
    if doc_len <= remaining and doc_len > best_len:
        best_idx = i
        best_len = doc_len

if best_idx >= 0:
    doc = doc_buffer.pop(best_idx)
    # Añadir doc completo
else:
    # Recortar doc más corto para llenar batch
Enter fullscreen mode Exit fullscreen mode

5. Unificación Flash Attention (nanochat/flash_attention.py)

Interfaz única: selecciona FA3 o PyTorch SDPA automáticamente.

from nanochat.flash_attention import flash_attn

y = flash_attn.flash_attn_func(q, k, v, causal=True, window_size=window_size)
Enter fullscreen mode Exit fullscreen mode

6. Motor de Inferencia (nanochat/engine.py)

  • Caché KV: prompt caché vía FA3
  • Herramientas: evalúa Python cuando toca
  • Batching: clona caché para muestreo paralelo

Coordina el flujo conversacional, incluyendo herramientas activadas por tokens.

Paso a Paso: Entrena Tu Propio Modelo

El flujo está en runs/speedrun.sh. Ejecuta cada paso:

Requisitos Previos

  • Nodo GPU 8xH100 (o similar)
  • ~20 GB de disco
  • Python 3.10+
  • uv como package manager

Paso 1: Configura el Entorno 

# Instala uv
curl -LsSf https://astral.sh/uv/install.sh | sh

# Virtualenv
uv venv
source .venv/bin/activate

# Instala dependencias
uv sync --extra gpu
Enter fullscreen mode Exit fullscreen mode

Paso 2: Descarga los Datos 

# ~2B caracteres del dataset ClimbMix
python -m nanochat.dataset -n 170
Enter fullscreen mode Exit fullscreen mode

Descarga ~170 archivos de ~100MB (total ~17 GB comprimidos).

Paso 3: Entrena el Tokenizador 

# Tokenizador BPE vocab 32,768
python -m scripts.tok_train

# Evalúa compresión
python -m scripts.tok_eval
Enter fullscreen mode Exit fullscreen mode

Paso 4: Preentrena el Modelo 

# Modelo d24 (GPT-2)
torchrun --standalone --nproc_per_node=8 -m scripts.base_train -- \
    --depth=24 \
    --target-param-data-ratio=8 \
    --device-batch-size=16 \
    --fp8 \
    --run=my-first-model
Enter fullscreen mode Exit fullscreen mode

Parámetros clave:

  • --depth=24: tamaño GPT-2
  • --target-param-data-ratio=8: subentrenado para velocidad
  • --device-batch-size=16: batch por GPU
  • --fp8: FP8 activado (solo H100+)

Tiempo estimado: ~2h.

Paso 5: Ajuste Fino Supervisado 

# Descarga conversaciones de identidad
curl -L -o ~/.cache/nanochat/identity_conversations.jsonl \
    https://karpathy-public.s3.us-west-2.amazonaws.com/identity_conversations.jsonl

# Ejecuta SFT
torchrun --standalone --nproc_per_node=8 -m scripts.chat_sft -- \
    --device-batch-size=16 \
    --run=my-sft
Enter fullscreen mode Exit fullscreen mode

Esto entrena el formato conversacional, tokens especiales y herramientas.

Paso 6: Chatea con el Modelo 

# Chat CLI
python -m scripts.chat_cli -p "Why is the sky blue?"

# O interfaz web
python -m scripts.chat_web
Enter fullscreen mode Exit fullscreen mode

La web corre en puerto 8000, interfaz estilo ChatGPT.

Flujo de Trabajo de Investigación: Experimentación Rápida

Para probar ideas, usa modelos pequeños.

Experimentos Rápidos (~5 minutos) 

OMP_NUM_THREADS=1 torchrun --standalone --nproc_per_node=8 -m scripts.base_train -- \
    --depth=12 \
    --run="d12-test" \
    --core-metric-every=999999 \
    --sample-every=-1 \
    --save-every=-1
Enter fullscreen mode Exit fullscreen mode

Entrena un modelo d12 (GPT-1), ideal para validar cambios arquitectónicos rápidamente.

Métricas a Monitorizar

En Weights & Biases, sigue:

  1. val_bpb: bits-por-byte validación
  2. core_metric: score DCLM CORE
  3. train/mfu: uso FLOPS modelo
  4. train/tok_per_sec: throughput entrenamiento

Requisitos de Prueba

Cualquier mejora debe funcionar de d12 a d26 para evitar overfitting a un solo tamaño.

Por Qué Importa nanochat

Accesibilidad de Costos

Enfoque Costo Tiempo Hardware
OpenAI GPT-2 $43,000 168 hrs 32 TPU v3
nanochat (2026) $48 2 hrs 8xH100
nanochat spot ~$15 2 hrs 8xH100 spot

Esto permite entrenar LLM a:

  • Investigadores individuales
  • Startups pequeñas
  • Cursos universitarios
  • Aficionados

Valor Educativo

  • ~500 líneas para GPT
  • ~530 líneas para el optimizador
  • Comentarios y decisiones explícitas
  • Sin configuración oculta

Ideal para aprender y experimentar.

Velocidad de Investigación

Reducir días a horas permite:

  • Probar hipótesis rápido
  • Más experimentos por semana
  • Coste de fallo bajo
  • Colaboración comunitaria (rankings)

Transparencia

  • Leyes de escalado en dev/LOG.md
  • Ablaciones en GitHub Discussions
  • Detalles de reproducción para la clasificación
  • Contribución de IA documentada

Limitaciones y Verificación de la Realidad

nanochat es potente, pero tiene límites:

Requisitos de Hardware

La cifra de $48 asume acceso a 8xH100. Precios:

  • Lambda Labs: ~$25/hora (8xH100)
  • RunPod: ~$15/hora spot
  • Ejecución completa: ~2h + SFT

Presupuesta ~$50-100 por ejecución real.

Techo de Capacidad

nanochat llega a nivel GPT-2 (2019):

Puede:

  • Conversación básica
  • Razonamiento simple
  • Matemáticas básicas
  • Hechos simples

No puede:

  • Razonamiento complejo
  • Código avanzado
  • Instrucciones matizadas
  • Competir con GPT-4/Claude

Piénsalo como un "niño de preescolar" IA.

Requisitos de Datos

  • ~170 fragmentos
  • ~17GB comprimidos
  • ~2B caracteres

Necesitas almacenamiento y ancho de banda.

Limitaciones de la Métrica

CORE mide 22 tareas, pero no:

  • Calidad real de conversación
  • Conocimiento de nicho
  • Nuances de instrucciones
  • Seguridad/alineación

La varianza CORE es ~0.016. Tus resultados pueden variar.

Preguntas Frecuentes

¿Cuánto cuesta entrenar un modelo con nanochat?

~$48 bajo demanda (~$24/h × 2h) o ~$15 spot. SFT suma ~30min.

¿Qué GPU necesito?

Mínimo: una GPU moderna. Óptimo: 8xH100 u 8xA100. Escala de 1 a 8 GPUs con acumulación automática.

¿Cuánto tarda el entrenamiento?

1.65 a 3 horas según hardware/configuración. Récord: 1.65h (d24).

¿Qué es la métrica CORE?

CORE evalúa 22 tareas (ARC, MMLU, etc). GPT-2: 0.2565. nanochat: >0.26.

¿Puedo entrenar con una sola GPU?

Sí. Omite torchrun. Entrenamiento 8× más lento, pero resultados casi idénticos.

¿Qué dataset utiliza nanochat?

ClimbMix (NVIDIA). Tokenizador se entrena con ~2B caracteres (~8 fragmentos).

¿nanochat funciona en Apple Silicon?

Sí, en MPS (float32). Entrenamiento más lento que CUDA, pero útil para pruebas.

¿Puedo reanudar desde un checkpoint?

Sí, usa --resume-from-step=<step>. Loader de datos también guarda estado.

¿Diferencias con nanoGPT?

nanoGPT solo preentrenamiento. nanochat cubre: tokenización, preentrenamiento, SFT, RLHF, evaluación, inferencia, interfaz web.

Conclusión

nanochat prueba que entrenar LLM ya no requiere grandes presupuestos ni infraestructuras complejas. De $43,000 en 2019 a menos de $50 hoy.

Más allá del coste, el código mínimo y la filosofía de "un solo selector" lo hacen valioso tanto para investigación como para educación.

Puntos Clave

  • 100x reducción de costos: GPT-2 por $48
  • 100x aceleración: 168h a 1.65h
  • Un solo parámetro de configuración: --depth
  • Flujo completo: tokenización a interfaz web
  • Impulsado por la comunidad: ranking público y mejoras continuas

Próximos Pasos

¿Listo para entrenar tu modelo? Descarga el repo de nanochat y ejecuta runs/speedrun.sh.

Para devs de API, entender el entrenamiento LLM ahora está al alcance de un proyecto de fin de semana, no de una startup financiada.

Top comments (0)