44 % à l'ARC-AGI-1 pour 67 Cents : le Transformer Entraîné de Zéro en 1h30 sur une Seule RTX 5090
Salut HaWkers, le 1er septembre 2026 un billet intitulé "44% on ARC-AGI-1 in 67 cents" est monté en tête de Hacker News et a fini la journée avec 621 points et 158 commentaires. Son auteur, Mithil Vakde, diplômé en génie physique de l'IIT Bombay en 2023, a entraîné de zéro un transformer ordinaire de 75 millions de paramètres, en à peu près 1h30, sur une seule RTX 5090 louée, et il a marqué 44 % sur l'ensemble public d'évaluation de l'ARC-AGI-1. Le coût total de calcul a été de 67 cents de dollar. Le même modèle fait 7 % à l'ARC-AGI-2.
Vous pensez qu'il faut un cluster de GPU pour faire de la recherche pertinente en intelligence artificielle ? Dans cet article je montre ce qu'est l'ARC-AGI et pourquoi il résiste aux LLM, quelle a été la recette technique de Vakde, comment fonctionne l'entraînement en temps de test qui soutient le résultat, où ce chiffre se place dans le tableau à côté du TRM, du HRM, de o3 et de Gemini 3.1 Pro, et comment tout reproduire pour le prix d'un café.
Ce Qu'est l'ARC-AGI et Pourquoi Il Résiste aux LLM
L'ARC, sigle d'Abstraction and Reasoning Corpus, a été créé par François Chollet en 2019 dans l'article "On the Measure of Intelligence". Chaque tâche est un casse-tête visuel : vous recevez deux ou trois paires de grilles colorées, entrée et sortie, et vous devez découvrir la règle de transformation pour l'appliquer à une nouvelle grille. Les grilles font au maximum 30 sur 30 cellules et comptent dix couleurs. Un humain en résout la plupart en quelques minutes, sans aucun entraînement.
Tout l'intérêt du benchmark, c'est que chaque tâche a sa propre règle. Il n'existe pas de motif à mémoriser, et c'est exactement pour cela que les modèles de langage, entraînés à reproduire des motifs vus sur internet, ont souffert si longtemps avec lui. L'ARC Prize, lancé en juin 2024 avec plus d'un million de dollars de prix, a transformé le jeu de données en compétition publique.
Le point de bascule est arrivé en décembre 2024, quand OpenAI a présenté o3 : 75,7 % sur l'ensemble semi-privé de l'ARC-AGI-1 avec environ 20 dollars par tâche, et 87,5 % dans la configuration à fort calcul, avec un coût estimé à des milliers de dollars par tâche. J'ai raconté cette histoire en détail dans le billet sur o3 et la nouvelle ère des modèles de raisonnement. Résoudre l'ARC-AGI-1 a cessé d'être la question. La question est devenue : à quel coût ?
C'est dans ce contexte que 67 cents devient un chiffre intéressant.
Ce Que Mithil Vakde a Fait en 1h30
L'idée centrale de mdlARC, le nom du dépôt, est simple à décrire et difficile à bien exécuter. Chaque paire entrée-sortie d'une tâche devient une séquence de tokens. Un petit transformer est entraîné de zéro, de façon autorégressive, sur ces séquences, et l'entraînement a lieu en temps de test : le modèle voit les exemples d'entraînement et les entrées des tâches d'évaluation, jamais les réponses, et il apprend tout pendant l'épreuve elle-même.
Le README du dépôt résume le calcul : 75 millions de paramètres, un transformer standard, environ 2 heures sur une RTX 5090 louée sur vast.ai et un coût total approximatif de 0,67 dollar. La version précédente du même projet marquait 27,5 % en dépensant 1,80 dollar en moins de 3 heures sur une A100 de Google Colab. Le saut à 44 % vient d'une liste de changements que toute personne qui entraîne des modèles aujourd'hui reconnaît :
- Architecture moderne : SwiGLU à la place de GELU, RMSNorm à la place de LayerNorm.
- Échelle modeste : 8 couches au lieu de 4.
- Embeddings positionnels 3D avec RoPE, pour que le modèle comprenne la ligne, la colonne et la position dans la paire.
- Embeddings additifs par tâche, qui laissent l'apprentissage traverser des tâches différentes.
- Optimiseur NorMuon à la place d'AdamW.
- Flash attention avec entraînement à longueur variable et noyaux de flex attention.
- Supervision uniquement sur la sortie : le modèle apprend à prédire seulement la grille de réponse, pas celle d'entrée.
- Moins d'augmentations de données, ce qui a fait baisser le coût et, selon l'auteur, amélioré l'efficacité en échantillons.
Les données d'entraînement mélangent l'ARC-AGI-1, les tâches de l'ARC-AGI-2 qui ne recouvrent pas le premier et ConceptARC. Les augmentations sont des permutations de couleur et les huit symétries diédrales, rotations et miroirs. À la fin, le modèle génère plusieurs réponses pour chaque tâche et soumet les deux plus fréquentes, ce qui correspond à la limite de tentatives autorisée par l'ARC.
La Recette Technique : la Grille Devient une Séquence de Tokens
Pour comprendre pourquoi un transformer de texte arrive à résoudre un casse-tête visuel, il vaut la peine de regarder la tokenisation. Chaque cellule devient un token de 0 à 9, qui est la couleur. Deux tokens supplémentaires marquent la fin de la ligne et la fin de la grille, pour que le modèle sache où la géométrie s'arrête.
# Chaque cellule de la grille devient un token de 0 à 9 (la couleur).
# Deux séparateurs marquent fin de ligne et fin de grille, comme dans mdlARC.
NOUVELLE_LIGNE = 10
FIN_GRILLE = 11
def grille_vers_tokens(grille: list[list[int]]) -> list[int]:
"""Aplatit une grille ARC en une séquence 1D de tokens."""
tokens = []
for ligne in grille:
tokens.extend(ligne) # couleurs 0-9
tokens.append(NOUVELLE_LIGNE) # saut de ligne explicite
tokens.append(FIN_GRILLE) # signal de fin pour le modèle
return tokens
def paire_vers_sequence(entree, sortie):
"""Concatène entrée et sortie : le modèle n'est supervisé que sur la sortie."""
return grille_vers_tokens(entree) + grille_vers_tokens(sortie)
exemple = paire_vers_sequence([[0, 1], [1, 0]], [[1, 0], [0, 1]])
print(exemple)
# [0, 1, 10, 1, 0, 10, 11, 1, 0, 10, 0, 1, 10, 11]Remarquez que la sortie n'est pas une image, c'est une séquence. Cela permet de réutiliser tout ce que l'industrie a construit pour les modèles de langage, de flash attention à RoPE, sur un problème qui n'a rien de linguistique. Ce fut l'un des débats les plus longs du fil Hacker News : un transformer autorégressif entraîné sur des grilles est-il un LLM ? La réponse de l'auteur a été qu'une séquence de tokens n'a pas besoin d'être une séquence de mots.
L'Entraînement en Temps de Test, Ce N'est Pas de la Triche ?
C'est la question la plus répétée dans la discussion, et elle mérite une réponse technique. Le modèle est entraîné sur les entrées des tâches d'évaluation, mais il ne voit jamais les sorties. L'analogie de l'auteur : vous naissez pendant l'examen, vous recevez un ensemble d'entraînement et vous apprenez tout de zéro pendant que l'examen se déroule. C'est de l'apprentissage transductif, et c'est la même famille de technique qui a gagné l'ARC Prize en 2024 et en 2025.
D'ailleurs, le test-time training est le cousin du test-time compute que j'ai expliqué dans le billet sur comment o3 fait passer le raisonnement à l'échelle au moment de l'inférence. La différence, c'est qu'au lieu de dépenser plus de tokens à réfléchir, le modèle dépense des gradients à apprendre des exemples de la tâche.
Le mécanisme qui fait marcher tout ça sans fuite, ce sont les augmentations. Comme chaque tâche n'a que deux ou trois exemples, l'entraînement multiplie ces exemples en appliquant des transformations qui préservent la règle : tourner la grille, la refléter, échanger les couleurs entre elles. Si la règle est "peins en bleu la plus grande forme", elle reste valable après une rotation de 90 degrés avec les couleurs permutées.
import random
import numpy as np
def augmenter(grille: np.ndarray, graine: int) -> np.ndarray:
"""Génère une variation de la grille qui préserve la règle de la tâche."""
rng = random.Random(graine)
g = grille.copy()
# 1) Symétrie diédrale : une des 8 combinaisons de rotation et de miroir
g = np.rot90(g, k=rng.randint(0, 3))
if rng.random() < 0.5:
g = np.fliplr(g)
# 2) Permutation de couleurs : mélange les couleurs 1-9 et garde le fond 0
couleurs = list(range(1, 10))
rng.shuffle(couleurs)
carte = {0: 0, **{ancienne: nouvelle for ancienne, nouvelle in zip(range(1, 10), couleurs)}}
return np.vectorize(carte.get)(g)
originale = np.array([[0, 1, 2], [3, 0, 4]])
print(augmenter(originale, graine=42))La même permutation doit être appliquée à l'entrée et à la sortie de la même paire, sinon la règle casse. Au moment de répondre, le processus est inversé : le modèle génère la sortie sous chaque augmentation, le code défait la transformation et les réponses qui reviennent le plus l'emportent. C'est un vote, et c'est la raison pour laquelle le modèle soumet les deux grilles les plus fréquentes :
from collections import Counter
def voter_deux_reponses(candidates: list[tuple]) -> list[tuple]:
"""Reçoit les sorties générées sous plusieurs augmentations, déjà remises
dans l'orientation d'origine, et renvoie les 2 plus fréquentes.
L'ARC accepte 2 tentatives par tâche."""
comptage = Counter(candidates)
return [grille for grille, _ in comptage.most_common(2)]
# Chaque candidate est la grille sous forme de tuple de tuples, pour entrer dans le Counter
candidates = [
((1, 0), (0, 1)),
((1, 0), (0, 1)),
((0, 1), (1, 0)),
((1, 0), (0, 1)),
((1, 1), (0, 0)),
]
print(voter_deux_reponses(candidates))
# [((1, 0), (0, 1)), ((0, 1), (1, 0))]Sur le soupçon que l'ensemble public serait plus facile que le privé, l'auteur a répondu dans le fil que la même méthode l'a placé dixième sur l'ensemble privé de Kaggle. Ce n'est pas la même chose qu'un résultat vérifié par l'ARC Prize, et il faut le dire clairement, mais c'est un signe que le chiffre n'est pas un artefact de fuite.
Où Cela se Place dans le Tableau : TRM, HRM, NVARC et Gemini 3.1 Pro
Le résultat fait jeu égal avec deux modèles dont on a beaucoup parlé en 2025 et qui dépendent de la récursion pour raisonner. Le HRM, Hierarchical Reasoning Model, a 27 millions de paramètres et a marqué 40,3 % à l'ARC-AGI-1. Le TRM, Tiny Recursive Model, du laboratoire Samsung SAIL de Montréal, a annoncé 7 millions de paramètres avec 45 % à l'ARC-AGI-1 et 8 % à l'ARC-AGI-2. Vakde fait une remarque intéressante sur le TRM : le modèle est annoncé à 7M, mais les poids d'embedding entraînés avec lui dépassent les 100 millions, ce qui le place dans une gamme proche de celle de mdlARC.
À l'autre bout se trouvent les LLM de frontière. Gemini 3.1 Pro, en février 2026, a atteint 77,1 % à l'ARC-AGI-2 avec un coût de 0,962 dollar par tâche en mode de calcul maximal. Et le vainqueur de l'ARC Prize 2025, l'équipe NVARC, de NVIDIA, est arrivé à 24,03 % sur l'ensemble privé de l'ARC-AGI-2 en dépensant environ 0,20 dollar par tâche, avec un Qwen de 4 milliards de paramètres et beaucoup de données synthétiques.
Un petit script rend la comparaison de coût honnête, parce que l'unité qui compte n'est pas le coût total, mais combien coûte chaque tâche résolue :
# Coût par réussite = coût par tâche / taux de réussite.
# Les coûts par tâche de o3, NVARC et Gemini 3.1 Pro sont ceux publiés par l'ARC Prize ;
# celui de mdlARC est le coût total divisé par les 400 tâches de l'ensemble public.
approches = {
# nom : (benchmark, réussite en %, coût par tâche en $)
"mdlARC (Vakde, RTX 5090)": ("ARC-AGI-1 public", 44.0, 0.67 / 400),
"o3 mode efficient (déc. 2024)": ("ARC-AGI-1 semi-privé", 75.7, 20.0),
"NVARC (ARC Prize 2025)": ("ARC-AGI-2 privé", 24.03, 0.20),
"Gemini 3.1 Pro high (févr. 2026)": ("ARC-AGI-2 semi-privé", 77.1, 0.962),
}
for nom, (bench, reussite, cout_tache) in approches.items():
cout_par_reussite = cout_tache / (reussite / 100)
print(f"{nom:32} {bench:24} {reussite:5.1f}% "
f"{cout_tache:.5f} $/tâche {cout_par_reussite:.4f} $/réussite")Ce que le calcul montre, c'est qu'il existe deux jeux différents. Les LLM jouent le jeu du score absolu, et l'ARC-AGI-1 est résolu pour eux. mdlARC, le TRM et le HRM jouent le jeu de l'efficacité en échantillons : combien de raisonnement abstrait peut-on extraire d'un petit modèle, de zéro, sans aucun pré-entraînement sur internet. À l'ARC-AGI-2, ces petits modèles en sont encore à un chiffre, et Vakde lui-même reconnaît que l'ARC-AGI-3, avec ses environnements interactifs, exigerait des modèles bien plus grands.
Ce Qu'a Discuté le Fil Hacker News
Au-delà du débat sur la triche, trois points valent d'être notés.
Le premier concerne le coût. Un commentateur a averti que le "0,67 dollar" est trompeur si quelqu'un extrapole linéairement et imagine que 100 dollars donneraient 65 %. L'auteur a reconnu que le chiffre illustre l'efficacité, pas une échelle linéaire.
Le deuxième porte sur ce que les LLM apprennent vraiment. Pour Vakde, les modèles de frontière arrivent à l'ARC par post-entraînement synthétique : ils apprennent à résoudre des tâches d'ARC, pas à raisonner de façon abstraite en général. C'est une critique ancienne du benchmark, et c'est l'une des raisons pour lesquelles l'ARC Prize a lancé l'ARC-AGI-3 le 25 mars 2026, avec des environnements interactifs où l'agent doit découvrir l'objectif tout seul.
Le troisième porte sur le monde réel. Un commentaire a soulevé le problème du cadrage : la méthode exploite peut-être la taille limitée de l'ARC et échouerait sur des distributions réelles. L'auteur l'a reconnu en partie et a renvoyé la réponse à des travaux futurs. C'est une limite honnête, et elle doit entrer dans toute lecture enthousiaste du résultat.
Comment Reproduire pour 67 Cents
Le dépôt est sous licence MIT et la marche à suivre tient dans un terminal. Sur vast.ai, une RTX 5090 à la demande coûte autour de 0,33 dollar l'heure en septembre 2026, ce qui boucle le calcul des 2 heures. La carte a 32 Go de GDDR7, et l'auteur demande CUDA au-dessus de 12.8, de préférence 13.
# Clone le dépôt (licence MIT) ; avant, créez un venv et installez
# torch, numpy, numba, matplotlib et flash-attn
git clone https://github.com/mvakde/mdlARC.git
# Télécharge et monte les datasets : ARC-AGI-1 + ConceptARC + tâches filtrées de l'ARC-AGI-2
cd mdlARC/dataset_building_scripts
python download_and_group.py
python build_datasets.py arc1 --add-conceptarc --with-filtered
cd ..
# Optionnel : efface les données brutes et le fichier de solutions pour prouver qu'il n'y a pas de fuite
# rm -r assets_tmp
# rm assets/solutions.json
# rm -r dataset_building_scripts
# Entraînement + inférence. Modes : low, medium ou high
python run_script.py highL'étape optionnelle qui efface les données brutes et le fichier de solutions avant l'entraînement existe pour prouver qu'il n'y a pas de fuite, et elle vaut la peine d'être lancée si vous comptez publier votre chiffre. Le script d'entraînement a trois modes, low, medium et high, et l'auteur a désactivé le log de la fonction de perte pour gagner en vitesse.
Si vous ne voulez même pas dépenser les 67 cents, les modes low et medium réduisent le budget de calcul et le code tourne sur un GPU local, plus lentement. Ce qui n'est pas possible, c'est de tourner sur CPU en un temps raisonnable : flash attention est un prérequis.
Efficacité Contre Échelle : Ce Que Cela Change Pour Ceux Qui Développent
L'ARC Prize 2026 est en cours avec plus de 2 millions de dollars de prix. La piste de l'ARC-AGI-2 paie 700 mille dollars, et la règle de Kaggle est dure : 240 tâches en 12 heures avec quatre GPU L4, quelque chose comme 0,42 dollar par tâche, sans internet et avec du code ouvert obligatoire. Le grand prix exige 85 % sur l'ensemble privé. Dans ce régime, un Gemini 3.1 Pro à 0,962 dollar par tâche n'entre même pas dans la salle. C'est exactement le régime où un transformer de 75 millions de paramètres entraîné en 2 heures prend tout son sens.
Trois lectures pratiques pour vous qui développez.
La première, c'est que la frontière de recherche accessible reste ouverte. Une personne, une carte louée et un dépôt MIT ont fait jeu égal avec le laboratoire de Samsung et avec l'état de l'art non-LLM de 2025. Si vous voulez entrer dans la recherche en IA, l'ARC est un terrain où 67 cents d'expérience tiennent dans le budget de n'importe qui.
La deuxième porte sur la recette. SwiGLU, RMSNorm, RoPE, flash attention et les optimiseurs de la famille Muon ne sont pas l'exclusivité des modèles géants ; ils rapportent autant sur 75 millions de paramètres que sur 75 milliards. Si vous maintenez un petit modèle en production, un classifieur, un générateur d'embeddings, un transformer de séries temporelles, il vaut la peine de revoir l'architecture avec cette liste en main. J'ai parlé de ce mouvement dans le billet sur les small language models et l'IA accessible, et mdlARC en est l'exemple le plus extrême jusqu'ici.
La troisième porte sur la suite. Vakde affirme être certain que 65 % est atteignable dans le cadre du transformer et invite qui veut à essayer. L'ARC-AGI-2 reste à un chiffre pour cette famille de modèles, et l'ARC-AGI-3 est un autre jeu. La question que le billet laisse en suspens est la même que celle du fil : le chemin vers le raisonnement général passe-t-il par la mise à l'échelle de ce que nous avons déjà, ou par la découverte de ce qui fait qu'un petit modèle apprend avec deux exemples ? En 2026, pour la première fois, on peut tester les deux hypothèses avec l'argent d'un café.
Allez, on y va! 🦅
📚 Vous Voulez Suivre Ce Qui Arrive?
Cet article a couvert le transformer à 67 cents qui a marqué 44 % à l'ARC-AGI-1, mais l'écosystème change chaque semaine et tout ne devient pas un article ici.
Sur X je partage ce que je teste, les coulisses des projets et les nouveautés qui apparaissent avant de devenir un post.
Suivez-Moi Là-Bas
💡 Du contenu quotidien sur le développement, la carrière et les outils que j'utilise vraiment