Un cadre de recherche en IA autonome par Andrej Karpathy qui permet à un agent IA (Claude/Codex) de modifier, entraîner et évaluer de manière itérative un petit LLM sur un seul GPU pendant la nuit — exécutant environ 100 expériences pendant que vous dormez.
autoresearch — Cadre de recherche LLM autonome par IA
Aperçu
autoresearch est un cadre expérimental d'Andrej Karpathy qui automatise le processus d'itération de la recherche en IA/ML. L'idée centrale est élégamment simple : donner à un agent IA (tel que Claude ou Codex) un code de formation LLM réel et fonctionnel, et le laisser proposer de manière autonome des modifications, exécuter des expériences de formation de 5 minutes, évaluer les résultats et itérer — le tout sans intervention humaine.
Considérez-le comme un laboratoire de recherche IA minimal et autonome qui fonctionne toute la nuit sur un seul GPU, produisant un journal d'environ 100 expériences et (espérons-le) un modèle linguistique progressivement meilleur au matin.
Contexte et Motivation
Karpathy ouvre le README avec une vision sarcastique de l'avenir — un monde où la recherche en IA n'est plus effectuée par des humains mais par des "essaims autonomes d'agents IA fonctionnant sur des mégastructures de clusters de calcul". Le dépôt, écrit-il, est "l'histoire de la façon dont tout a commencé".
La motivation pratique est plus terre-à-terre : l'itération de la recherche est lente car les humains ont besoin de manger, de dormir et d'assister à des réunions. Ce projet remplace l'humain dans la boucle par un agent IA qui peut exécuter des expériences 24h/24 et 7j/7, rendant la recherche ML considérablement plus rapide et plus automatisée.
Comment ça marche
Le flux de travail est une boucle serrée modifier → entraîner → évaluer → conserver/rejeter :
- L'agent lit
program.md— un fichier Markdown contenant les instructions de recherche et le contexte, écrit et maintenu par le chercheur humain. - L'agent modifie
train.py— le seul fichier Python contenant l'architecture du modèle GPT, l'optimiseur (Muon + AdamW) et la boucle d'entraînement. L'agent peut tout changer : architecture, hyperparamètres, paramètres de l'optimiseur, taille du lot, etc. - L'entraînement dure exactement 5 minutes (temps réel, hors démarrage/compilation).
- La métrique
val_bpb(validation bits per byte) est calculée — plus elle est basse, mieux c'est. Elle est indépendante de la taille du vocabulaire, donc les changements architecturaux peuvent être comparés équitablement. - L'agent décide s'il faut conserver ou rejeter le changement, puis répète.
Cela produit environ 12 expériences/heure et environ 100 expériences pendant la nuit.
Structure du dépôt
autoresearch/
├── prepare.py # Fixe : préparation des données unique, entraînement du tokenizer BPE, dataloader, utilitaires d'évaluation
├── train.py # Modifiable par l'agent : modèle GPT, optimiseur, boucle d'entraînement
├── program.md # Modifiable par l'humain : instructions de l'agent et contexte de recherche
├── analysis.ipynb # Notebook pour analyser les résultats des expériences
├── pyproject.toml # Dépendances (gérées via uv)
└── progress.png # Image teaser montrant la progression de l'entraînement
Fichiers clés expliqués
| Fichier | Propriétaire | Objectif |
|---|---|---|
prepare.py |
Humain (fixe) | Télécharge les fragments de données, entraîne le tokenizer BPE, fournit le dataloader et les utilitaires d'évaluation |
train.py |
Agent IA | Implémentation GPT complète + boucle d'entraînement — le bac à sable de l'agent |
program.md |
Humain (itérable) | "Compétence" de recherche / instructions pour l'agent |
Philosophie de conception
1. Un seul fichier à modifier
L'agent ne touche qu'à train.py. Cela maintient la portée gérable et les diffs faciles à examiner. Cela contraint également l'espace d'action de l'agent à des changements ML significatifs plutôt qu'à des changements d'infrastructure/d'outillage.
2. Budget temps fixe
Chaque expérience dure exactement 5 minutes d'entraînement en temps réel (hors démarrage). Cela garantit :
- Toutes les expériences sont directement comparables indépendamment des changements architecturaux (taille du modèle, taille du lot, etc.)
- L'agent trouve la meilleure configuration de modèle pour votre matériel spécifique
- Débit prévisible : ~12 expériences/heure
Le compromis : les résultats ne sont pas portables sur différentes plateformes de calcul (une exécution sur H100 ne peut pas être comparée à une exécution sur A100).
3. Autonome
Pas d'entraînement distribué, pas de fichiers de configuration complexes, pas d'infrastructure de recherche externe. Juste PyTorch + une poignée de petits paquets, un GPU, un fichier, une métrique. Cela rend le projet facile à comprendre, à forker et à développer.
4. program.md comme interface humaine
Plutôt que de coder un agent de recherche à partir de zéro, Karpathy utilise program.md comme une "compétence" légère — un fichier Markdown qui donne à l'agent IA le contexte, les objectifs et les contraintes. L'humain itère sur program.md au fil du temps pour améliorer le "code de l'organisation de recherche".
Détails techniques
Modèle et entraînement
- Basé sur une version simplifiée pour GPU unique de nanochat
- Utilise l'optimiseur Muon + AdamW par défaut (bien que l'agent puisse le changer)
- Entraîne un modèle de style GPT à partir de zéro sur des fragments de données textuelles téléchargés
- Tokenizer BPE entraîné sur les données elles-mêmes via
prepare.py - Métrique d'évaluation : val_bpb (validation bits per byte)
Exigences
- GPU : GPU NVIDIA unique (testé sur H100)
- Python : 3.10+
- Gestionnaire de paquets : uv
Démarrage rapide
# 1. Installer uv (si pas déjà installé)
curl -LsSf https://astral.sh/uv/install.sh | sh
# 2. Installer les dépendances
uv sync
# 3. Préparation des données unique (~2 min)
uv run prepare.py
# 4. Exécuter une expérience d'entraînement unique (~5 min)
uv run train.py
Exécution de l'agent
Démarrez Claude, Codex ou tout agent de codage capable dans le répertoire du dépôt (avec des permissions d'écriture de fichiers), puis lancez :
Examinez program.md et lançons une nouvelle expérience ! Faisons d'abord la configuration.
L'agent lira program.md, proposera une modification à train.py, exécutera l'entraînement, évaluera le résultat et itérera.
Importance et impact
autoresearch est une preuve de concept pour la recherche automatisée en apprentissage automatique à petite échelle. Bien qu'il existe des systèmes AutoML à grande échelle, ce projet est remarquable pour :
- Simplicité : L'ensemble du code significatif est d'environ 3 fichiers
- Transparence : Chaque décision de l'agent est enregistrée et peut être examinée
- Accessibilité : Fonctionne sur un seul GPU grand public/de recherche
- Vision : Il démontre la faisabilité des agents IA menant une véritable recherche ML de manière autonome
Il sert également de modèle pour "programmer votre organisation de recherche IA via Markdown" — un paradigme qui pourrait devenir standard à mesure que les agents de codage IA deviennent plus performants.
Forks notables
- miolini/autoresearch-macos — Support macOS/MPS
Résumé
| Propriété | Valeur |
|---|---|
| Type | Cadre d'agent de recherche IA autonome |
| Utilisation principale | Expérimentation d'entraînement LLM automatisée pendant la nuit |
| Interface de l'agent | program.md (instructions Markdown) |
| Espace d'action de l'agent | train.py (modèle GPT + boucle d'entraînement) |
| Durée de l'expérience | 5 minutes (fixe) |
| Débit | ~12 expériences/heure, ~100 pendant la nuit |
| Métrique | val_bpb (validation bits per byte) |
| Matériel | GPU NVIDIA unique (H100 testé) |
| Licence | MIT |