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

TL;DR

nanochat es el framework de entrenamiento de LLM de código abierto de Andrej Karpathy que te permite entrenar un chatbot de nivel GPT-2 por menos de $50 en unas 2 horas. El proyecto utiliza un único nodo GPU 8xH100, código mínimo (~500 líneas para el modelo principal), y un solo parámetro de configuración (--depth) para optimizar automáticamente todos los hiperparámetros. Los registros actuales muestran la finalización del entrenamiento en 1.65 horas con una puntuación CORE de 0.2626, superando al GPT-2 de OpenAI de 2019 que costó $43,000 y tardó 168 horas.

Introducción

Entrenar un modelo de lenguaje grande solía requerir millones de dólares y un equipo de investigadores con doctorado. Esos días han terminado.

Andrej Karpathy acaba de lanzar nanochat, un proyecto de código abierto que entrena una IA conversacional capaz por menos de lo que cuesta una buena cena. Todo el proceso se ejecuta en un único nodo GPU 8xH100 y se completa en menos de 2 horas.

Por Qué Esto Importa Ahora

El panorama de la IA cambió drásticamente a principios de 2026. Lo que a OpenAI le llevó 168 horas y $43,000 en 2019, ahora toma 1.65 horas y $48. Esto es una aceleración de 100 veces impulsada por mejoras algorítmicas, mejor hardware y optimización comunitaria.

Para los desarrolladores de API y los equipos que construyen aplicaciones impulsadas por IA, esto lo cambia todo. Ahora puedes experimentar con el entrenamiento de modelos personalizados, probar cambios arquitectónicos y comprender los internos de los LLM sin presupuestos de infraestructura masivos.

Lo Que Aprenderás

Al final de este artículo, comprenderás:

• Cómo nanochat logra una reducción de costos de 100x frente al entrenamiento tradicional de LLM
• La arquitectura completa (modelo GPT, optimizador Muon, carga de datos)
• Instrucciones paso a paso para entrenar tu propio modelo
• Cómo usar nanochat para la investigación y experimentación rápida de LLM
• Limitaciones reales y lo que realmente significa la capacidad GPT-2

¿Qué es nanochat?

nanochat es un entorno mínimo de entrenamiento de LLM que cubre todo el proceso de desarrollo: tokenización, preentrenamiento, ajuste fino, evaluación, inferencia y una interfaz de usuario web similar a ChatGPT.

La base de código cabe en un único repositorio sin monstruos de configuración ni complejidad de framework. Karpathy lo diseñó como una "línea base sólida" que es legible, modificable y bifurcable.

La Afirmación Principal

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

• $48 bajo demanda (2 horas a ~$24/hora para 8xH100)
• ~$15 en instancias spot

Para contextualizar, el entrenamiento original del GPT-2 de OpenAI en 2019 costó aproximadamente $43,000 y tardó 7 días en 32 chips TPU v3.

Lo que nanochat Cubre

La Filosofía: Un Solo Selector para Controlar Todo

La mayoría de los frameworks de LLM te ahogan en archivos de configuración. nanochat adopta el enfoque opuesto.

Todo el sistema gira en torno a un parámetro: --depth (el número de capas del transformador).

# Modelo de tamaño GPT-1
torchrun --standalone --nproc_per_node=8 -m scripts.base_train -- --depth=12

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

# Superando los límites
torchrun --standalone --nproc_per_node=8 -m scripts.base_train -- --depth=26

Establece la profundidad, y nanochat calcula todo lo demás automáticamente:

• Ancho del transformador (dimensión de incrustación)
• Número de cabezas de atención
• Tasas de aprendizaje para cada grupo de parámetros
• Horizonte de entrenamiento (pasos totales)
• Programaciones de decaimiento de peso
• Tamaños de lote

Esta filosofía de "un solo selector" permite lo que Karpathy llama la miniserie nanochat: una familia de modelos computacionalmente óptimos de diferentes tamaños, todos entrenados con el mismo enfoque basado en principios.

Por Qué Funciona Esto

El equipo midió leyes de escalado en docenas de ejecuciones de entrenamiento. Encontraron relaciones predecibles entre la profundidad, el ancho, el tamaño del lote y la duración del entrenamiento. En lugar de exponer todos estos controles, nanochat codifica estas relaciones directamente en el script de entrenamiento.

Obtienes entrenamiento computacionalmente óptimo sin necesidad de un doctorado en aprendizaje profundo.

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

nanochat mantiene una clasificación pública que rastrea la capacidad de "tiempo hasta GPT-2". El objetivo es superar la puntuación CORE original de OpenAI de 0.256525 en 22 tareas de evaluación (ARC, MMLU y otras del conjunto de benchmarks DCLM).

Récords Actuales

Cómo la IA Descubrió Optimizaciones

Las ejecuciones 5 y 6 incorporaron cambios del sistema de "autoinvestigación" de Karpathy. Un agente de IA exploró modificaciones arquitectónicas en pequeños modelos d12 (ejecuciones de entrenamiento de 5 minutos), luego tradujo los cambios exitosos a la configuración completa d24.

El sistema encontró mejoras en:

• Mecanismo de retroceso: Mejor resta residual de capa intermedia
• Implementación de Smear: Mezcla de bigramas más eficiente a partir de tokens anteriores

Estos cambios redujeron el tiempo de entrenamiento de 2.02 horas a 1.65 horas, una mejora del 19% descubierta a través de la experimentación autónoma.

Cómo Funciona nanochat

La base de código contiene aproximadamente 3,000 líneas en los módulos principales. Examinemos cada componente.

1. El Modelo GPT (nanochat/gpt.py)

El transformador sigue las mejores prácticas modernas con varias optimizaciones:

Características de la Arquitectura:

• Incrustaciones rotativas (RoPE): Codificación posicional relativa sin incrustaciones posicionales aprendidas
• Normalización QK: Estabiliza el entrenamiento a escala
• Pesos no ligados: Capas separadas de incrustación de tokens y proyección de salida
• Activación ReLU²: ReLU al cuadrado en MLP en lugar de GeLU
• Atención de Consulta Agrupada (GQA): Menos cabezas KV que cabezas de consulta para una inferencia más rápida
• Atención de ventana deslizante: Patrón configurable (ej., "SSSL" alterna contexto corto/largo)
• Flash Attention 3: Optimización de GPU Hopper con respaldo SDPA

Incrustaciones de Valor (ResFormer):Las capas alternas incluyen incrustaciones de valor aprendibles mezcladas a través de un gating dependiente de la entrada:

# Value residual: mix in value embedding with per-head gate
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

Esto añade capacidad sin una sobrecarga computacional significativa.

Trucos de Eficiencia:

El modelo incluye tres mecanismos aprendidos que mejoran la dinámica de entrenamiento:

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

# 2. Smear: mezcla la incrustación del token anterior para información de bigramas
gate = self.smear_lambda * torch.sigmoid(self.smear_gate(x[:, :, :24]))
x = x + gate * x_pre_smear

# 3. Backout: resta el residuo de la capa intermedia
x = x - self.backout_lambda * x_backout

2. El Optimizador Muon (nanochat/optim.py)

nanochat utiliza una estrategia de optimizador mixto:

Muon (Momento Ortogonalizado por Newton-Schulz):

El optimizador Muon ortogonaliza las actualizaciones de peso utilizando una iteración quíntica de Newton-Schulz llamada "Polar Express":

# Coeficientes de Polar Express (5 iteraciones)
polar_express_coeffs = [
    (8.156, -22.483, 15.879),
    (4.043, -2.809, 0.500),
    # ... más coeficientes
]

# Bucle de ortogonalización
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

Reducción de Varianza NorMuon:

Después de la ortogonalización, las actualizaciones se normalizan por neurona para evitar el colapso de escala:

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)

Entrenamiento Distribuido:

Para configuraciones multi-GPU, el optimizador implementa el sharding estilo ZeRO-2 con comunicación asíncrona de tres fases:

Fase 1: Lanzar todas las operaciones asíncronas reduce_scatter
Fase 2: Esperar reducciones, calcular actualizaciones, lanzar all_gathers
Fase 3: Esperar gathers, copiar de vuelta los parámetros actualizados

Esto superpone la comunicación con la computación, maximizando la utilización de la GPU.

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

nanochat gestiona la precisión explícitamente en lugar de usar torch.amp.autocast:

La capa Lineal personalizada convierte los pesos para que coincidan con el tipo de datos de cómputo durante el pase hacia adelante:

class Linear(nn.Linear):
    def forward(self, x):
        return F.linear(x, self.weight.to(dtype=x.dtype))

Los pesos maestros permanecen en FP32 para la precisión del optimizador. Para las GPU H100 y Blackwell, el entrenamiento FP8 está disponible a través de --fp8, convirtiendo la mayoría de las capas a Float8Linear con escalado tensorial.

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

El cargador de datos utiliza empaquetado de mejor ajuste alineado con BOS:

• Cada fila comienza con el token BOS (Inicio de Secuencia)
• Documentos empaquetados usando el algoritmo de mejor ajuste para minimizar el desperdicio
• Cuando ningún documento encaja, uno se recorta para llenar exactamente
• Utilización del 100% con un ~35% de recorte de tokens a una longitud de secuencia de 2048

Esto asegura que cada token pueda atender de vuelta a BOS y ver el contexto completo del documento.

# Encontrar el documento más grande que encaje completamente
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 documento completo
else:
    # Recortar el documento más corto para llenar el espacio restante

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

El proyecto proporciona una interfaz unificada que cambia automáticamente entre FA3 y PyTorch SDPA:

from nanochat.flash_attention import flash_attn

# Funciona en cualquier hardware - selecciona automáticamente el mejor backend
y = flash_attn.flash_attn_func(q, k, v, causal=True, window_size=window_size)

En las GPU Hopper con bfloat16, utiliza Flash Attention 3. En cualquier otro lugar, recurre a la atención de producto escalar escalado de PyTorch.

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

La clase Engine maneja la generación eficiente con:

• Caché KV: Caché de prompt prellenado con flash_attn_with_kvcache de FA3
• Uso de Herramientas: Tokens especiales activan la calculadora de Python a través de eval()
• Generación por Lotes: Clonar caché KV para muestreo paralelo

El motor coordina el flujo de la conversación, incluyendo forzar los tokens de salida de la herramienta cuando el modelo invoca la calculadora.

Paso a Paso: Entrena Tu Propio Modelo

Todo el proceso reside en runs/speedrun.sh. Aquí te explicamos cómo ejecutarlo.

Requisitos Previos

• Nodo GPU 8xH100 (o similar)
• ~20 GB de espacio en disco para el conjunto de datos
• Python 3.10+
• Administrador de paquetes uv

Paso 1: Configuración del Entorno

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

# Crear y activar entorno virtual
uv venv
source .venv/bin/activate

# Instalar dependencias
uv sync --extra gpu

Paso 2: Descargar Datos de Entrenamiento

# Descargar ~2B caracteres del conjunto de datos ClimbMix
python -m nanochat.dataset -n 170

# Esto descarga ~170 fragmentos de ~100MB cada uno
# Total: ~17 GB comprimidos

El script descarga fragmentos de datos de preentrenamiento con bloqueo de archivos para manejar la coordinación multi-rango.

Paso 3: Entrenar el Tokenizador

# Entrenar tokenizador BPE con vocabulario de 32,768
python -m scripts.tok_train

# Evaluar la relación de compresión
python -m scripts.tok_eval

El tokenizador utiliza un patrón de división estilo GPT-4 con BPE de respaldo de bytes. El entrenamiento se completa en ~10 minutos con 2B caracteres.

Paso 4: Preentrenar el Modelo Base

# Entrenar modelo d24 (capacidad 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

Parámetros clave:

• --depth=24: modelo de tamaño GPT-2
• --target-param-data-ratio=8: Ligeramente subentrenado para mayor velocidad
• --device-batch-size=16: Tamaño de lote por GPU
• --fp8: Habilitar entrenamiento FP8 (solo H100+)

Tiempo de ejecución esperado: ~2 horas.

Paso 5: Ajuste Fino Supervisado

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

# Ejecutar SFT para capacidad de chat
torchrun --standalone --nproc_per_node=8 -m scripts.chat_sft -- \
    --device-batch-size=16 \
    --run=my-sft

Esto enseña al modelo el formato de conversación, los tokens especiales y el uso de herramientas.

Paso 6: Chatea Con Tu Modelo

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

# O lanzar la interfaz web
python -m scripts.chat_web

La interfaz web se ejecuta en el puerto 8000 y proporciona una interfaz similar a ChatGPT.

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

Para probar nuevas ideas, usa modelos más pequeños para una iteración más rápida.

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

Esto entrena un modelo d12 (tamaño GPT-1) con registro mínimo. Perfecto para probar cambios arquitectónicos.

Métricas a Monitorizar

Rastrea esto en Weights & Biases:

1. val_bpb: Bits-por-byte de validación (pérdida independiente del tamaño del vocabulario)
2. core_metric: Puntuación de evaluación DCLM CORE
3. train/mfu: Utilización de FLOPS del modelo (eficiencia del hardware)
4. train/tok_per_sec: Rendimiento del entrenamiento

Requisitos de Prueba

Cualquier mejora debe funcionar en todas las profundidades (d12 a d26). Esto evita el sobreajuste a un solo tamaño de modelo y asegura avances basados en principios.

Por Qué Importa nanochat

Accesibilidad de Costos

Esto pone el entrenamiento de LLM al alcance de:

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

Valor Educativo

La base de código sirve como recurso de aprendizaje:

• ~500 líneas para el modelo GPT
• ~530 líneas para el optimizador
• Comentarios claros sobre cada decisión de diseño
• Sin configuración oculta

Los estudiantes pueden leer, modificar y experimentar con un proceso completo de LLM.

Velocidad de Investigación

Reducir el entrenamiento de días a horas permite:

• Pruebas de hipótesis más rápidas
• Más experimentos por semana
• Menor costo de fracaso
• Colaboración comunitaria a través de la clasificación

Transparencia

Cada elección de diseño está documentada:

• Leyes de escalado en dev/LOG.md
• Estudios de ablación en GitHub Discussions
• Detalles completos de reproducción para entradas de clasificación
• Divulgación clara de la contribución de IA

Limitaciones y Verificación de la Realidad

nanochat es impresionante, pero tiene límites claros.

Requisitos de Hardware

La cifra de $48 asume acceso a un nodo 8xH100. Los costos de alquiler en la nube varían:

• Lambda Labs: ~$25/hora para 8xH100
• RunPod: ~$15/hora precios spot
• Tiempo total de ejecución: ~2 horas de preentrenamiento + SFT

Necesitarás ~$50-100 para una ejecución completa, dependiendo del proveedor.

Techo de Capacidad

nanochat logra un rendimiento a nivel GPT-2 (tecnología de 2019). Esto significa:

Lo que puede hacer:

• Conversación básica
• Razonamiento simple
• Matemáticas elementales
• Recuperación de hechos (limitada)

Lo que no puede hacer:

• Razonamiento complejo de múltiples pasos
• Generación de código más allá de funciones simples
• Seguimiento de instrucciones matizadas
• Competir con GPT-4, Claude o Gemini

Piensa en ello como un niño de preescolar: capaz de una conversación básica pero no de un trabajo a nivel experto.

Requisitos de Datos

La ejecución completa descarga:

• ~170 fragmentos de datos
• ~17 GB comprimidos
• ~2B caracteres en total

Necesitarás almacenamiento y ancho de banda adecuados.

Limitaciones de la Métrica

La puntuación CORE mide 22 tareas pero no captura:

• Calidad de la conversación en el mundo real
• Conocimiento específico del dominio
• Nuances en el seguimiento de instrucciones
• Seguridad y alineación

Diferentes semillas aleatorias producen una varianza CORE de ~0.016. Tus resultados pueden variar.

Preguntas Frecuentes

¿Cuánto cuesta entrenar un modelo con nanochat?

Aproximadamente $48 bajo demanda ($24/hora × 2 horas) o ~$15 en instancias spot. Esto cubre solo el preentrenamiento. Añade ~30 minutos para SFT.

¿Qué GPU necesito?

Mínimo: Una sola GPU (cualquier GPU moderna de centro de datos). Óptimo: 8xH100 u 8xA100 para el entrenamiento más rápido. El código escala de 1 GPU a 8 GPUs con acumulación automática de gradientes.

¿Cuánto tiempo dura el entrenamiento?

De 1.65 a 3 horas, dependiendo de la configuración y el hardware. El récord actual de la clasificación es de 1.65 horas para un modelo d24.

¿Qué es la métrica CORE?

La puntuación DCLM CORE evalúa modelos en 22 tareas, incluyendo ARC (preguntas de ciencia), MMLU (comprensión de lenguaje multitarea) y otros benchmarks. GPT-2 obtuvo 0.256525. nanochat supera regularmente 0.26.

¿Puedo entrenar con una sola GPU?

Sí. Omite torchrun y el código utilizará automáticamente la acumulación de gradientes. El entrenamiento tardará 8 veces más, pero produce resultados casi idénticos.

¿Qué conjunto de datos utiliza nanochat?

La versión actual utiliza ClimbMix (el conjunto de datos web curado de NVIDIA). Las versiones anteriores utilizaban FineWeb-EDU. El tokenizador se entrena con ~2B caracteres de los primeros ~8 fragmentos.

¿nanochat funciona en Apple Silicon?

Sí. El código se ejecuta en MPS (Metal Performance Shaders) con precisión float32. El entrenamiento es más lento que en CUDA, pero funcional para la experimentación.

¿Puedo reanudar el entrenamiento desde un punto de control?

Sí. Usa --resume-from-step=<step> para continuar desde un punto de control guardado. El estado del cargador de datos también se guarda para una reanudación exacta.

¿Cuál es la diferencia entre nanochat y nanoGPT?

nanoGPT cubría solo el preentrenamiento. nanochat se extiende a todo el proceso: tokenización, preentrenamiento, SFT, RLHF, evaluación, inferencia e interfaz web.

Conclusión

nanochat demuestra que el entrenamiento de LLM ya no requiere presupuestos masivos ni infraestructura especializada. Lo que costaba $43,000 en 2019 ahora cuesta menos de $50.

El impacto del proyecto va más allá de la mera reducción de costos. Al proporcionar una base de código mínima y legible con una interfaz de "un solo selector", Karpathy ha creado tanto una herramienta de investigación como un recurso educativo.

Puntos Clave

• 100x reducción de costos: De $43,000 a $48 para capacidad GPT-2
• 100x aceleración: De 168 horas a 1.65 horas
• Un solo selector de configuración: --depth controla todo
• Proceso completo: Desde la tokenización hasta la interfaz web
• Impulsado por la comunidad: Clasificación pública con mejoras continuas

Próximos Pasos

¿Listo para entrenar tu propio modelo? Comienza con el repositorio de nanochat y el script runs/speedrun.sh.

Para los desarrolladores de API que construyen aplicaciones impulsadas por IA, comprender los internos del entrenamiento de LLM nunca ha sido tan accesible. La barrera de entrada ha bajado de "startup financiada por capital de riesgo" a "proyecto de fin de semana."