Autoresearch: Guía de 5 minutos para el entrenamiento autónomo de GPT con IA

Imagine esto: mientras usted duerme, una IA ajusta parámetros, entrena y ejecuta experimentos por sí sola. Al despertar, se encuentra con un registro de experimentos y un modelo mejorado; eso es autoresearch. Es un marco de investigación autónomo minimalista donde un Agente de IA modifica los scripts de entrenamiento de GPT, ejecuta experimentos, evalúa resultados e itera automáticamente. Lo único que usted tiene que hacer es observar.

Público objetivo

• Desarrolladores interesados en Agentes de investigación autónoma con IA.
• Estudiantes que quieran entender el proceso de entrenamiento de LLM desde una perspectiva de ingeniería.
• Personas curiosas por ver cómo la IA puede mejorar por sí misma.

Dependencias principales y entorno

• Python 3.10+
• GPU NVIDIA (probado en H100)
• Gestor de paquetes uv

Estructura del proyecto

autoresearch/
├── prepare.py      # Constantes fijas, preparación de datos, tokenizador (no modificar)
├── train.py        # Modelo, optimizador, ciclo de entrenamiento (el Agente modifica esto)
├── program.md      # Instrucciones del Agente (el humano modifica esto)
├── pyproject.toml  # Dependencias
└── results.tsv     # Registros de experimentos (generado automáticamente)

Todo el repositorio se mantiene minimalista a propósito: solo tres archivos son realmente importantes. Este diseño permite que el alcance de los experimentos sea controlable y que los diffs sean fáciles de revisar.

Tutorial paso a paso

Paso 1: Instalar uv

Primero, instale el gestor de paquetes uv:

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

Paso 2: Instalar dependencias

Clone el repositorio e instale las dependencias:

git clone https://github.com/karpathy/autoresearch.git
cd autoresearch
uv sync

Este paso instalará PyTorch y otros paquetes necesarios.

Paso 3: Preparar datos y tokenizador

Ejecute el script de preparación de datos por única vez:

uv run prepare.py

Esto descargará los datos de entrenamiento y entrenará un tokenizador BPE en unos 2 minutos. Los datos se guardarán en ~/.cache/autoresearch/.

Paso 4: Ejecutar un entrenamiento base (baseline)

Primero ejecutamos un entrenamiento manual para establecer una referencia:

uv run train.py

El entrenamiento durará exactamente 5 minutos (sin contar el tiempo de inicio y compilación). La métrica de evaluación es val_bpb (bits por byte en el conjunto de validación): cuanto menor sea, mejor.

Al terminar, verá una salida similar a esta:

---
val_bpb:          0.997900
training_seconds: 300.1
total_seconds:    325.9
peak_vram_mb:     45060.2
mfu_percent:      39.80
total_tokens_M:   499.6
num_steps:        953
num_params_M:     50.3
depth:            8

Este baseline es nuestro punto de partida. Ahora, entreguémoslo a la IA.

Paso 5: Conectar su Agente de IA

Cree una nueva rama para el experimento:

git checkout -b autoresearch/mar15

Inicialice el archivo de resultados:

echo -e "commit\tval_bpb\tmemory_gb\tstatus\tdescription" > results.tsv

Inicie su Agente de IA (Claude, Codex, etc., asegúrese de configurar los permisos necesarios):

claude

Luego, dígale lo siguiente:

Hi have a look at program.md and let's kick off a new experiment! let's do the setup first.

El Agente leerá program.md, entenderá el flujo de trabajo y comenzará a iterar sobre train.py de forma autónoma.

Paso 6: Entender el ciclo de experimentos

El Agente repetirá continuamente los siguientes pasos:

1. Modificar train.py: Cambiar la arquitectura, ajustar hiperparámetros, modificar el optimizador, etc.
2. Git commit: Guardar este cambio.
3. Ejecutar experimento: uv run train.py > run.log 2>&1
4. Leer resultados: grep "^val_bpb:\|^peak_vram_mb:" run.log
5. Registrar en results.tsv: Anotar el experimento.
6. Decisión:
   • Si val_bpb baja → Conservar el commit y continuar.
   • Si val_bpb empeora → git reset y probar otro enfoque.

Análisis de las instrucciones principales en program.md

program.md es el cerebro de su investigador de IA; los puntos clave son:

• Presupuesto de tiempo fijo: Siempre 5 minutos para asegurar que los experimentos sean comparables.
• Modificar un solo archivo: Solo se puede tocar train.py.
• Sin nuevas dependencias: Solo se pueden usar los paquetes ya presentes en pyproject.toml.
• Principio de simplicidad: Si una pequeña mejora aporta mucha complejidad, no vale la pena.

El primer experimento siempre debe ser el baseline para establecer la base de comparación.

Formato de salida

Los resultados se registran en results.tsv separados por tabulaciones:

commit	val_bpb	memory_gb	status	description
a1b2c3d	0.997900	44.0	keep	baseline
b2c3d4e	0.993200	44.2	keep	increase LR to 0.04
c3d4e5f	1.005000	44.0	discard	switch to GeLU activation

Nota: Use tabulaciones, no comas, ya que las comas pueden causar problemas dentro de las descripciones.

Solución de problemas comunes

1. Datos no preparados

Error: FileNotFoundError no encuentra los archivos de caché. Solución: Ejecute primero uv run prepare.py para descargar los datos y entrenar el tokenizador.

2. Memoria insuficiente (OOM)

Error: CUDA out of memory. Solución: El Agente debería detectar esto y marcarlo como "crash" en results.tsv. Correcciones comunes:

• Reducir TOTAL_BATCH_SIZE en train.py.
• Reducir el número de capas (DEPTH).
• Usar una longitud de secuencia más corta.

3. Tiempo de espera agotado

Error: La ejecución supera los 10 minutos. Solución: Mate el proceso manualmente. Marque el experimento como "discard" y revierta los cambios.

4. El Agente no trabaja

Problema: El Agente lee los archivos pero no ejecuta los experimentos. Solución: Verifique que el Agente se inició en el directorio correcto y que tiene permisos para ejecutar comandos de shell.

5. Siempre peor que el baseline

Problema: Todos los resultados son similares o peores. Solución:

• Pruebe cambios de arquitectura más agresivos (mecanismos de atención, funciones de activación).
• Ajuste la tasa de aprendizaje (el valor por defecto puede no ser óptimo).
• Pruebe diferentes optimizadores (Muon vs AdamW).

6. Incompatibilidad de plataforma

Error: "No CUDA GPUs available". Solución: Este código requiere GPU NVIDIA. Para otras plataformas, use estos forks:

• autoresearch-macos — MacOS
• autoresearch-mlx — MacOS Apple Silicon
• autoresearch-win-rtx — Windows

Direcciones avanzadas

Cómo jugar con GPUs pequeñas

Si no tiene una H100, puede ajustar lo siguiente:

1. Use el dataset TinyStories (dominio más estrecho, efectivo para modelos pequeños).
2. Reduzca vocab_size de 8192 a 2048 o incluso 256 (a nivel de bytes).
3. Reduzca MAX_SEQ_LEN en prepare.py a 256 o menos.
4. Reduzca TOTAL_BATCH_SIZE a 2**14 (aprox. 16K).
5. Configure WINDOW_PATTERN como "L" para usar atención simple.

Seguir expandiendo

Una vez familiarizado, puede:

• Modificar program.md para añadir múltiples Agentes con diferentes roles.
• Probar diferentes conjuntos de datos.
• Incluir métricas de evaluación más complejas.
• Implementar entrenamiento multi-GPU (requiere cambios importantes en prepare.py).

Recursos relacionados

• Repositorio oficial
• Tweet de anuncio de Karpathy
• nanochat: proyecto padre, compatible con más plataformas.
• Guía para principiantes de redes neuronales