Le plus fou, c’est que je n’ai aucune expérience en apprentissage automatique, je ne connais pas le processus standard d’entraînement des modèles ni de nombreux détails techniques. Ce que j’ai fait, c’est essentiellement demander et fournir des retours à Sol de manière répétée, afin qu’il trouve lui-même les problèmes, conçoive des expériences et itère continuellement.

Auteur de l'article : Anshu

Article traduit, source : ME News

C’est la première fois que j’ai vraiment eu l’impression que l’AGI est déjà là.

J'ai entraîné un modèle de correction automatique propre avec GPT-5.6 Sol. Finalement, ce modèle local de seulement 1,7 milliard de paramètres a légèrement surpassé GPT-5.6 Sol sur l'ensemble de test.

Le plus fou, c’est que je n’ai aucune expérience en apprentissage automatique, je ne connais pas le processus standard d’entraînement des modèles ni de nombreux détails techniques. Ce que j’ai fait, c’est essentiellement demander et fournir des retours à Sol de manière répétée, afin qu’il trouve lui-même les problèmes, conçoive des expériences et itère continuellement.

Le processus est gratuit.

Tout provient d'un problème de frappe de plus en plus grave

Après avoir dialogué longtemps avec l'IA, j'ai remarqué que mes compétences en frappe se dégradent de plus en plus.

J'ai pris l'habitude de taper rapidement sans vérifier attentivement les fautes d'orthographe, l'ordre des lettres ou les lettres manquantes. Plutôt que de réapprendre à taper, j'ai choisi une solution plus adaptée à l'ère de l'IA : continuer à utiliser davantage d'IA pour résoudre ce problème.

La correction automatique traditionnelle modifie continuellement le texte pendant la saisie, ce qui risque de perturber la concentration. Mon idée est de permettre à l'utilisateur de saisir rapidement sans être interrompu, même si le texte contient de nombreuses erreurs, puis de laisser l'IA effectuer un nettoyage global une fois la saisie terminée.

En même temps, je souhaite que ce modèle soit le plus petit possible.

Plus le modèle est petit, plus il est rapide à exécuter, moins il consomme d'énergie, et plus il est adapté à un fonctionnement entièrement local. Que ce soit pour l'efficacité, l'autonomie de la batterie, ou simplement par curiosité expérimentale, je souhaite voir à quel point un modèle local suffisamment petit peut réussir à corriger automatiquement les erreurs.

Alors, j'ai décidé de m'entraîner moi-même.

Faites de Sol un chercheur effectuant automatiquement des expériences.

L'idée de ce projet provient de l'expérience « autoresearch » d'Andrej Karpathy.

I used Codex's /goal mode to design a cyclical workflow for Sol:

Sélectionnez une expérience, exécutez-la et enregistrez les résultats dans le document ; si elle échoue, abandonnez cette piste ; puis planifiez la prochaine expérience, tout en évitant de répéter les erreurs déjà vérifiées.

J'ai seulement fourni quelques exemples d'entrées obligatoires, des objectifs de latence stricts et l'effet final souhaité, puis j'ai laissé Sol fonctionner seul.

Ce qui s'est produit ensuite a dépassé mes attentes.

Sol a d'abord recherché et comparé plusieurs modèles de base candidats, notamment Qwen 3.5, Gemma 4 et Liquid LFM 2.5. Ensuite, il a trouvé sur Hugging Face un ensemble de jeux de données liés à des textes de saisie réels.

Mais les données réelles ne sont pas encore suffisantes.

Pour générer des fautes de frappe plus proches des saisies réelles des utilisateurs, Sol a développé un simulateur de « frappe sur un clavier Mac ». Il utilise une distribution gaussienne pour modéliser les points d'impact des doigts selon la disposition physique du clavier, et génère diverses erreurs courantes, telles que :

• Appuyez sur les touches adjacentes ;
• Letters reversed;
• Répéter la saisie ;
• Caractère manquant ;
• Toucher plusieurs touches simultanément avec les doigts.

Avec le modèle de base, les données textuelles et le simulateur d'erreurs de frappe, Sol a été affiné directement sur mon MacBook à l'aide de MLX.

En moins d'une heure, il a créé un prototype fonctionnel.

Le problème est que la précision de la première version n'est pas idéale.

Premier goulot d'étranglement : le tokenizer ne comprend pas les fautes d'orthographe

Sol a lu les articles pertinents et a conçu une série de tests, concluant finalement que le principal goulot d'étranglement du modèle ne se trouvait pas dans les données d'entraînement, mais dans le tokenizer, c'est-à-dire le segmenteur.

Les grands modèles linguistiques ne comprennent généralement pas le texte lettre par lettre, mais le divisent d'abord en tokens. Les mots normaux peuvent être décomposés en unités sémantiques stables, mais les fautes d'orthographe détruisent souvent la structure des tokens existantes.

Cela signifie qu'une erreur d'orthographe évidente pour un humain peut, pour le modèle, se transformer en un ensemble de tokens complètement étrangers.

Les modèles ont du mal à « comprendre » réellement les erreurs ; ils ne font que mémoriser mécaniquement les correspondances entre les fautes d'orthographe et les orthographes correctes. Cette approche présente une faible capacité de généralisation et ne permet pas d'exploiter pleinement les connaissances linguistiques initiales du modèle.

Sol a d'abord essayé ByT5 de Google.

ByT5 est un modèle qui ne repose pas sur un tokenizer traditionnel, mais traite directement des séquences de octets. Cette tentative a apporté une amélioration notable, mais étant donné que ByT5 a été publié il y a longtemps et que le modèle possède une connaissance linguistique limitée, ses performances finales n'atteignent toujours pas celles de GPT-5.6 Sol.

Après une étude approfondie, Sol a réalisé que le problème n'avait pas nécessairement besoin d'être résolu en « annulant complètement le Tokenizer ».

Il a choisi T5Gemma, un modèle d'architecture Encoder-Decoder.

Contrairement aux modèles qui prédisent simplement le prochain token, le modèle Encoder-Decoder peut d'abord comprendre complètement l'entrée via l'encodeur, puis générer le texte corrigé grâce au décodeur. Plus important encore, Sol peut également effectuer un post-entraînement supplémentaire sur l'encodeur pour permettre au modèle de mieux identifier les entrées contenant des fautes d'orthographe.

This route significantly raises the model's performance ceiling.

Deuxième goulot d'étranglement : les fonctions de perte traditionnelles encouragent le modèle à « ne pas modifier »

Après le changement d'architecture du modèle, un nouveau problème est apparu.

Le modèle est capable de corriger correctement certaines erreurs, mais il ignore souvent d'autres fautes d'orthographe évidentes. Même en présence d'erreurs dans l'entrée, il tend à les copier telles quelles.

Sol a finalement découvert que le problème provenait de la fonction de perte d'entropie croisée la plus courante.

Dans les données de correction automatique, la plupart des caractères sont déjà corrects, et seuls un très faible pourcentage nécessitent une modification. Si l'on utilise directement l'entropie croisée standard pour l'entraînement, la stratégie la plus sûre pour le modèle sera « de ne modifier le moins possible ».

Parce que copier le texte original permet d'obtenir la bonne réponse dans la plupart des cas, tandis qu'une modification active pourrait entraîner des erreurs.

En d'autres termes, les objectifs d'entraînement traditionnels récompensent le modèle pour rester inchangé.

Pour résoudre ce problème, Sol a développé une fonction de perte personnalisée.

Il aligne d'abord le texte original avec le texte cible au niveau des octets, puis calcule, à l'aide d'un algorithme de programmation dynamique, le chemin d'édition minimal entre les deux textes, identifiant ainsi quelles positions correspondent à une copie, et lesquelles correspondent à de véritables insertions, suppressions ou remplacements.

Sur cette base, Sol a considérablement augmenté le poids d'entraînement correspondant à la « modification correcte », tout en réduisant les gains issus de la simple copie de caractères.

Après plusieurs cycles d'ajustement des paramètres, la précision de correction du modèle a considérablement augmenté.

Troisième goulot d'étranglement : une fois le modèle parti dans la mauvaise direction, il ne peut pas faire machine arrière

Le dernier problème majeur provient du mécanisme de génération autoregressive.

Le modèle, lors de la génération de texte, ne peut prédire le prochain token que sur la base du contenu déjà généré. Dès qu'une erreur survient à une étape antérieure, les générations suivantes s'appuient sur ce résultat erroné, et le modèle ne peut pas réellement revenir en arrière pour corriger.

Théoriquement, il est possible d'entraîner un modèle à « réfléchir » avant de répondre, comme un modèle de raisonnement, mais cela augmenterait considérablement la latence et ne serait pas adapté aux scénarios de correction automatique nécessitant une réponse instantanée.

Sol a finalement trouvé une solution plus élégante : le Beam Search, également appelé recherche par faisceau.

Le modèle ne sélectionne plus à chaque étape une seule voie avec la probabilité la plus élevée, mais conserve simultanément plusieurs branches de génération possibles, explorant en parallèle différents résultats de correction. À la fin de la recherche, il sélectionne la trajectoire complète ayant la probabilité logarithmique cumulée la plus élevée.

Cela équivaut à remplacer l'inférence mono-thread par une recherche parallèle.

Beam Search améliore nettement les résultats finaux, mais introduit un problème d'expérience : les utilisateurs ne voient aucun résultat tant que la recherche n'est pas terminée.

Sol a ensuite fait une observation très intelligente.

Après chaque itération de recherche, vous pouvez comparer toutes les branches conservées. Tant que ces branches partagent le même début, ce « préfixe commun le plus long » apparaîtra nécessairement dans le résultat final.

Ainsi, le système peut afficher immédiatement ce contenu à l'utilisateur.

Au fur et à mesure que la recherche progresse, les chemins les plus faibles sont progressivement éliminés, et le préfixe commun des branches restantes devient de plus en plus long. Finalement, l'utilisateur ne voit pas des résultats apparaissant brusquement en une seule fois, mais un texte de correction généré continuellement.

Sol a transformé l'ensemble du processus en une pipeline d'inférence MLX personnalisée, utilisant le GPU du MacBook pour le décodage parallèle.

Finalement, le premier token affiche un délai de sortie d'environ 40 ms, ce qui est suffisamment rapide, et tout le processus est entièrement effectué localement.

Résultat final : modèle de 1,7 milliard de paramètres dépasse GPT-5.6 Sol

L'évaluation finale utilise le « taux de réduction des erreurs » comme indicateur ; plus la valeur est élevée, plus le modèle corrige d'erreurs dans l'entrée.

Les résultats de l'évaluation sont les suivants :

• Correction automatique d'Apple : 49,66 %
• GPT-5.6 Luna : 82,47 %
• GPT-5.6 Terra : 87,64 %
• GPT-5.6 Sol : 90,56 %
• Notre modèle de 1,7 milliard de paramètres entraîné : 91,02 %

Ce petit modèle local a finalement surpassé GPT-5.6 Sol avec une légère avance.

J'ai également vérifié attentivement s'il existait une fuite de données ou une forme de "triche" du modèle. Lors des tests, nous excluons activement les mots présents dans les données d'entraînement afin de vérifier que le modèle ne se contente pas de mémoriser mécaniquement les correspondances entre erreurs et réponses.

Le coût final du projet est :

Une réinitialisation du quota de modèle et une dépense en espèces de 0 $

Ce qui m’a vraiment impressionné, ce n’est pas seulement le score final

Au cours du projet, de nombreuses expériences non encore développées ont été menées, notamment dans des domaines tels que l'apprentissage par comparaison, le GRPO, le DPO et le masquage dynamique.

Tous les essais n'ont pas abouti, mais Sol a su lire activement les documents, identifier les problèmes, formuler des hypothèses, concevoir des expériences, analyser les résultats et planifier les prochains essais en se basant sur les échecs précédents.

Pour moi, ce qui est vraiment impressionnant, ce n'est pas le fait qu'un modèle de 1,7 milliard de paramètres dépasse GPT-5.6 Sol.

Plus important encore, une personne sans aucune expérience en apprentissage automatique peut désormais utiliser l'IA pour mener à bien des expériences qui nécessitaient auparavant une équipe de recherche spécialisée.

Je ne maîtrise pas toutes les connaissances sous-jacentes, ni n'ai conçu à l'avance une trajectoire technique complète. Je sais simplement quel problème je veux résoudre, puis je pousse continuellement Sol à chercher des réponses.

Il ne se contente pas d'écrire du code, mais assume également les rôles de chercheur, d'ingénieur et de concepteur d'expériences.

Cela pourrait bien être le moment où j’ai pour la première fois réellement « ressenti l’AGI ».

Ne laissez pas le manque d'expérience vous empêcher de commencer à expérimenter.

Lorsque l'IA peut aider les particuliers à franchir les barrières professionnelles, de nombreux projets technologiques qui semblaient autrefois inaccessibles pourraient déjà ne plus être si éloignés.