Entrené mi propio LLM desde cero en 2025: lo que el tutorial viral de HN no te dice sobre el costo real

Estaba revisando HN un martes a la noche cuando vi el post: "Train Your Own LLM from Scratch", 241 puntos, 87 comentarios, y una energía en el hilo que reconocí de inmediato — la misma que tienen los threads de "construí mi propio servidor de email" o "reemplacé Docker con scripts de bash". Mezcla de genuino entusiasmo técnico y colectivo wishful thinking.

Lo guardé. Dos días después lo abrí, cloné el repo y empecé a medir todo.

No porque crea que voy a reemplazar a Anthropic desde mi laptop. Sino porque la pregunta que nadie responde honestamente en esos threads es: ¿cuánto cuesta realmente? No en abstracto. En pesos, en horas, en oportunidad.

Mi tesis es esta: entrenar un LLM desde cero en 2025 tiene sentido en exactamente dos casos — como ejercicio de aprendizaje profundo sobre la arquitectura transformer, o cuando tenés un dominio tan específico y sensible que ningún modelo externo puede tocarlo. En cualquier otro caso, estás pagando un precio enorme para obtener algo que Claude Code o DeepSeek ya te dan gratis o casi gratis. Y el tutorial viral no te dice eso.

El tutorial viral: qué promete y qué entrega

El post de HN enlaza a una implementación de un transformer pequeño tipo GPT, entrenado desde cero en Python puro con PyTorch. El código es limpio. Los comentarios están bien. El autor sabe lo que hace.

Lo que promete, implícitamente: "vos también podés hacer esto."

Técnicamente es verdad. Prácticamente, hay una grieta enorme entre correr el código y tener algo útil.

El tutorial entrena un modelo de ~10M de parámetros sobre un corpus de texto en inglés (Shakespeare, en la versión clásica de Karpathy; este repo usa algo similar). El resultado es un modelo que genera texto coherente a nivel sintáctico pero sin comprensión semántica real. Es una demo educativa. No es un LLM de producción.

Yo lo corrí. Acá están los números reales.

El costo real: lo medí, no lo estimé

Setup inicial

# Entorno que usé — documentando versiones exactas
# Python 3.11.9, PyTorch 2.3.1, CUDA 12.1
# Instancia: RunPod, RTX 4090 (24GB VRAM), spot instance

pip install torch==2.3.1 datasets transformers
# El repo tiene sus propias dependencias — algunas conflictan con lo que ya tenés

Usé RunPod porque Railway, donde vivo habitualmente, no tiene GPUs para training pesado. Eso ya es el primer costo oculto: si querés entrenar algo serio, necesitás salir de tu infra normal.

Experimento 1: modelo 10M de parámetros (el del tutorial)

# Configuración del modelo chico — la del tutorial original
config = {
    "n_embd": 384,       # dimensión del embedding
    "n_head": 6,         # cabezas de atención
    "n_layer": 6,        # capas transformer
    "block_size": 256,   # contexto máximo
    "vocab_size": 50257, # tokenizer GPT-2
    "dropout": 0.1
}
# Parámetros totales: ~10.7M
# Dataset: ~300MB de texto procesado

Resultado:

• Tiempo de entrenamiento: 47 minutos en RTX 4090
• Costo en RunPod: USD 0,44/hora × 0,78h = USD 0,34
• Resultado del modelo: genera texto que parece inglés desde lejos

Bien. Treinta y cuatro centavos. Eso no es el problema.

Experimento 2: escalar a algo remotamente útil

El problema aparece cuando intentás escalar. Un modelo de 10M de parámetros no sirve para nada más allá de demostrar que entendés la arquitectura. Para tener capacidades de razonamiento básico necesitás estar en el orden de 1B-7B parámetros mínimo — y eso cambia completamente la ecuación.

# Estimación de costo para modelo 1B de parámetros
# Con el mismo setup (RTX 4090, RunPod spot):

# Tokens necesarios para un training decente: ~20B tokens
# Tokens por segundo en RTX 4090: ~8,000 tokens/seg (con batch optimizado)
# Tiempo estimado: 20,000,000,000 / 8,000 = 2,500,000 segundos
# En horas: ~694 horas
# En días: ~29 días continuos

# Costo RunPod RTX 4090 spot: USD 0,44/hora
# Costo total estimado: 694 × 0.44 = USD 305

echo "Y eso si la spot instance no te interrumpe cada 3-4 horas"
echo "Con interrupciones reales, multiplicá por 1.4 como mínimo"
# Costo real estimado: ~USD 427

Cuatrocientos dólares para un modelo de 1B que va a ser peor que Llama 3.2 1B, que es gratis.

Experimento 3: el costo que el tutorial ignora

El costo de compute no es el mayor problema. El mayor problema es el costo de datos y el costo de tu tiempo.

# Lo que necesitás para un modelo que no sea basura:
# 1. Dataset curado y limpio
# 2. Tokenizer propio o adaptado
# 3. Evaluación continua durante el training
# 4. Hyperparameter tuning (mínimo 3-5 runs)
# 5. Checkpoint management — aprendí esto a las piñas

# En mi caso, el pipeline de datos me llevó 8 horas
# Solo para preparar 300MB de texto limpio
# Ese tiempo tiene un costo de oportunidad real

# Comparación directa que hice:
# - 8 horas preparando datos para modelo de 10M
# - vs 8 horas usando Claude Code en mi proyecto de Railway
# El delta de productividad es obsceno

Acá conecta directo con lo que documenté en el post sobre agentic coding en producción con logs reales: Claude Code en 8 horas me genera código funcional, tests, documentación y me hace preguntas que no esperaba. Un modelo de 10M entrenado por mí en 8 horas genera texto que parece coherente.

Por qué el tutorial viral genera expectativas incorrectas

No es culpa del autor del tutorial. El código es bueno y el objetivo educativo está claro. El problema es el contexto que se construye alrededor en HN.

Leí los 87 comentarios. Hay tres tipos de respuestas:

Tipo 1 — Los entusiastas: "¡Increíble! Ahora voy a entrenar mi propio modelo para [caso de uso específico]."

Tipo 2 — Los pragmáticos: "Interesante para aprender, pero para producción usá fine-tuning sobre un modelo base."

Tipo 3 — Los que ya lo hicieron: "Les cuento lo que tardaron mis checkpoints en crashear en AWS Spot."

El problema es que Tipo 1 son la mayoría, y los comentarios de Tipo 3 quedan enterrados.

Mi experiencia con DeepClaude — combinando Claude Code con DeepSeek en mi loop de agentes me dio una perspectiva clara: incluso DeepSeek V4, que costó cientos de millones de dólares entrenarlo, no supera a Claude en mis casos de uso específicos. ¿Qué espero lograr yo con un modelo de 10M entrenado en 47 minutos?

Los gotchas que el tutorial no menciona

1. El problema del overfitting silencioso

# Training loss bajando bien... o eso parece
# Epoch 1: loss = 4.23
# Epoch 5: loss = 2.17
# Epoch 10: loss = 1.44
# Epoch 20: loss = 0.89  ← acá empezó el problema

# El modelo estaba memorizando el dataset de training
# Validation loss: 1.91 — casi sin mejorar desde epoch 5
# Clásico overfitting que no ves si no monitoreás las dos curvas

# Lo que el tutorial muestra: la training loss bajando bonito
# Lo que el tutorial no muestra: comparar con validation loss en tiempo real

Tardé 20 minutos en darme cuenta porque el gráfico de training loss se veía hermoso. Clásico.

2. Los checkpoints te van a explotar el storage

En mi primer run de 47 minutos generé 11 checkpoints de ~240MB cada uno. Son 2.6GB por experimento. En un experimento de fine-tuning real, eso se multiplica por 10 o por 20 fácil. El tutorial no te dice nada sobre estrategia de checkpointing.

Esto me recuerda el rabbit hole de backups que documenté cuando migré de pgbackrest a Barman en producción: la parte técnica del tutorial siempre parece limpia. La operativa real siempre tiene fricción que nadie documenta.

3. El tokenizer es más importante de lo que parece

# El tutorial usa el tokenizer de GPT-2 — está bien para inglés
# Si querés entrenar sobre texto en español o código específico,
# el tokenizer importa muchísimo

from transformers import GPT2Tokenizer

tokenizer = GPT2Tokenizer.from_pretrained("gpt2")

# Problema: GPT-2 tokenizer fue entrenado principalmente en inglés
# Para español, palabras comunes se tokenizan en 3-4 tokens
# vs 1-2 tokens en modelos entrenados con texto en español

# "arquitectura" → ['arqu', 'ite', 'ctura'] # 3 tokens en GPT-2
# vs 1 token en tokenizers modernos español-aware

# Esto no es un detalle — afecta directamente el context window efectivo
# y la eficiencia del training

En mis specs YAML para agentes aprendí que los detalles de formato y tokenización importan más de lo que uno intuye al principio. Con LLMs propios, eso se magnifica.

4. La inferencia también cuesta

El tutorial termina cuando el modelo está entrenado. Pero si querés usar ese modelo en algún lado, necesitás infraestructura de inferencia. Servir un modelo de 1B en producción requiere al menos 2-4GB de VRAM dependiendo de la cuantización. En Railway eso no existe nativamente. En cualquier otro proveedor, suma costo mensual fijo.

Cuándo tiene sentido hacerlo (en serio)

Seré concreto porque las respuestas genéricas me aburren:

Tiene sentido si:

• Querés entender de verdad cómo funciona la atención multi-cabeza y los embeddings posicionales — nada te enseña como implementarlo vos mismo y ver qué pasa cuando rompés algo
• Trabajás en un dominio con datos que no pueden salir de tu infraestructura (medicina, legal, compliance) y necesitás un modelo especializado sobre esos datos privados
• Estás investigando algo específico de arquitectura y necesitás control total sobre cada variable

No tiene sentido si:

• Querés "tener tu propio LLM" como logro técnico sin un caso de uso concreto
• Creés que va a ser más barato que usar la API de DeepSeek (spoiler: no lo va a ser)
• Pensás que un modelo de 10M-100M parámetros entrenado por vos va a competir con Llama 3.2 o Phi-3

La anécdota que más me quedó de esta semana: cuando migré el monorepo de npm a pnpm y el install pasó de 14 minutos a 90 segundos, el equipo no lo podía creer. Esa sensación de "mejoré algo real que afecta a todos" — entrenar un LLM desde cero no me la dio. Me dio otra sensación: la de haber entendido algo profundo sobre cómo funciona el sistema que uso todos los días. Eso tiene valor. Pero es un valor diferente.

FAQ: lo que devs realmente quieren saber antes de empezar

¿Cuánto cuesta en dinero entrenar un LLM desde cero en 2025?

Depende brutalmente del tamaño. Un modelo de 10M parámetros en RunPod con RTX 4090 cuesta menos de USD 1 en compute. Un modelo de 1B parámetros puede costar entre USD 300 y USD 500 en una spot instance, asumiendo que no te interrumpe el proceso. Para algo de 7B parámetros que sea remotamente competitivo, estás hablando de miles de dólares y semanas de GPU time. El costo de datos y de tu propio tiempo siempre supera al costo de compute en modelos chicos.

¿Tiene sentido hacer fine-tuning en lugar de entrenar desde cero?

Casi siempre sí. Fine-tuning sobre Llama 3.2 1B o Phi-3 mini te da un modelo especializado a una fracción del costo — horas en lugar de semanas, decenas de dólares en lugar de cientos. La única razón para entrenar desde cero es cuando necesitás control total sobre los datos de pre-training o cuando el objetivo es educativo puro.

¿El tutorial de HN sirve para aprender?

Sí, genuinamente. El código es limpio y la implementación del transformer es didáctica. Lo que no te da es contexto sobre escala, sobre lo que pasa cuando querés hacer algo útil con el resultado, o sobre la operativa de manejo de checkpoints, datos y evaluación continua. Como punto de partida para entender la arquitectura, es excelente.

¿Puedo correrlo en mi máquina local sin GPU?

Podés correr el modelo de 10M en CPU, pero va a tardar entre 4 y 8 horas en lugar de 47 minutos. Para modelos más grandes en CPU, los tiempos se vuelven impracticables rápido. Si no tenés GPU, RunPod o Vast.ai con instancias spot son la opción más económica para experimentar.

¿Vale la pena si ya uso Claude Code o DeepSeek en producción?

Depende de qué estés buscando. Si el objetivo es productividad en desarrollo, no — Claude Code y DeepSeek te van a dar más valor por token gastado que cualquier modelo que puedas entrenar en un fin de semana. Si el objetivo es entender cómo funcionan por dentro los modelos que ya usás, sí, absolutamente vale la pena como ejercicio.

¿Qué pasa con los datos de entrenamiento? ¿Necesito un dataset enorme?

Para el tutorial básico, no. El repo funciona con unos pocos cientos de MB de texto. El problema es que con esa cantidad de datos, el modelo resultante es útil solo como demo. Para un modelo que tenga capacidades generales mínimas, la literatura reciente sugiere al menos 1T de tokens — algo que no vas a recolectar y limpiar en un fin de semana.

Mi conclusión: el ego técnico tiene un precio de mercado

Lo voy a dejar claro porque los cierres ambiguos me molestan: entrenar un LLM desde cero en 2025 no es la inversión técnica más inteligente para la mayoría de los devs. Es un ejercicio de comprensión profunda disfrazado de proyecto productivo, y el tutorial viral de HN lo vende con una energía que sugiere más de lo que entrega.

Lo que sí me llevé es concreto: ahora entiendo de verdad por qué los modelos grandes necesitan tanto compute para emergencia de capacidades. Entiendo por qué el contexto sobre tar en pipelines de Railway me importa — los detalles de formato y procesamiento de datos importan en todos los niveles del stack, desde backups hasta training data. Y entiendo por qué DeepSeek V4 a USD 0,14 por millón de tokens input es una aberración económica que todavía no termino de procesar.

Si querés entender transformers, correlo. Si querés construir algo útil, no pierdas de vista que el mundo en 2025 tiene modelos de 70B parámetros disponibles por API por fracciones de centavo. Competir con eso desde cero es un ejercicio de ego, no de ingeniería.

Fuente original: Hacker News - Train Your Own LLM from Scratch

Este artículo fue publicado originalmente en juanchi.dev