L'IA et mes notes : quand la technologie trahit la mémoire

Le défi initial : des notes dispersées

Trois semaines après m'être plongé dans l'apprentissage du machine learning, j'ai rencontré un obstacle inattendu. Ce n'était pas la complexité des modèles ou des mathématiques qui posait problème, mais la gestion de mes notes. J'avais pris soin de rédiger mes réflexions dans mes propres mots, en créant des analogies qui me parlaient et en notant des questions à approfondir plus tard. Cependant, la structure de mes notes laissait à désirer.

Mes notes étaient disséminées dans plusieurs applications et formats. Certaines se trouvaient dans Notion, d'autres dans Google Docs, et quelques-unes dans des fichiers texte épars. Cette absence de cohérence m'obligeait à passer les vingt premières minutes de chaque session d'étude à reconstituer le contexte. Qu'avais-je déjà compris ? Où en étais-je resté ? Quelle explication avait été la plus éclairante ? J'avais l'impression de devoir réapprendre ma propre pensée avant de pouvoir progresser.

Dans un moment de frustration, j'ai tenté une approche qui semblait évidente. J'ai ouvert une conversation avec une IA, y ai collé mes notes, et ai demandé de l'aide pour étudier. Contre toute attente, cela a fonctionné mieux que prévu. Les réponses de l'IA étaient alignées avec ma façon de penser, et j'avais enfin l'impression d'avoir un outil qui s'adaptait à moi, plutôt que l'inverse.

Pour la première fois, mon apprentissage semblait fluide et continu, plutôt que fragmenté.

L'apparition des premiers problèmes

Au début, le système semblait fonctionner sans accroc. L'IA utilisait mes notes pour expliquer les concepts de manière compréhensible, me faisant gagner du temps. Tout semblait en ordre.

Puis, des incohérences ont commencé à apparaître. Parfois, l'IA utilisait un exemple que je ne reconnaissais pas. D'autres fois, elle omettait des détails que j'étais certain d'avoir notés. Ces erreurs n'étaient pas flagrantes, mais elles étaient suffisamment décalées pour être remarquées si l'on y prêtait attention.

J'ai d'abord pensé que c'était de ma faute. Peut-être que je n'avais pas formulé mes notes clairement. Peut-être avais-je oublié ce que j'avais écrit.

Puis, une réponse de l'IA m'a fait tiquer. J'avais demandé une explication d'un concept basé sur mes notes, un concept que j'avais déjà bien compris. L'IA a donné une réponse claire et structurée, mais elle a cité une formule qui, selon elle, provenait de mes notes.

J'ai fait une pause, car je savais que cette formule n'était pas dans mes notes. J'ai vérifié, et elle n'était pas cachée quelque part où je l'aurais oubliée. Elle n'existait tout simplement pas.

C'est à ce moment-là que le problème est devenu impossible à ignorer. La réponse n'était pas manifestement fausse, elle semblait même correcte. Si je n'avais pas été attentif, j'aurais probablement accepté cette réponse sans la remettre en question.

Ce type d'erreur est insidieux. Ce n'est pas quelque chose que l'on peut détecter immédiatement, mais cela peut altérer silencieusement votre compréhension sans que vous vous en rendiez compte.

Revoir l'organisation des notes

Avant de corriger l'IA, il était essentiel de revoir mes notes. Jusqu'à ce moment-là, j'avais perçu le problème comme externe. L'IA était incohérente, donc j'avais supposé que le problème venait de ses réponses. Mais en examinant ma configuration, il est devenu évident que je ne fournissais pas à l'IA une base fiable.

Mes notes manquaient de structure cohérente. Certaines étaient rédigées en paragraphes, d'autres en listes à puces. Certaines contenaient des analogies, d'autres non. Même lorsque deux notes traitaient de sujets similaires, elles étaient formatées de manière complètement différente. Il était logique que j'aie du mal à naviguer dans mes propres notes. S'attendre à ce qu'un système d'IA les interprète de manière cohérente était encore plus irréaliste.

J'ai décidé de tout transférer vers Markdown. Non pas parce que c'est un outil puissant, mais parce qu'il impose la simplicité. Texte brut, formatage léger, et juste assez de structure pour rendre les choses prévisibles.

Chaque note suivait désormais le même schéma : un concept en haut, une courte explication, une analogie personnelle, et une section pour les points encore flous. Ce n'était pas parfait, mais c'était cohérent. Et cette cohérence était plus précieuse que tout le reste.

Ce qui m'a surpris, c'est à quel point cela a amélioré les choses, même avant de réintégrer l'IA. Les notes sont devenues plus faciles à parcourir, à revisiter, et à développer. Je ne perdais plus de temps à réinterpréter mes propres écrits.

J'ai également ajouté des métadonnées en haut de chaque fichier, comme le sujet et le niveau de difficulté. Cela n'a pas changé ma façon d'utiliser directement les notes, mais cela les a rendues plus faciles à organiser une fois que je les ai considérées comme une collection plutôt que comme des fragments isolés.

En rétrospective, cela a été le premier véritable changement. Le système n'a pas commencé avec l'IA. Il a commencé par rendre l'entrée suffisamment structurée pour être utilisable.

Au-delà de l'interface de chat

Jusqu'à ce point, j'utilisais encore l'IA via une interface de chat. Cela fonctionnait pour des interactions rapides, mais les limitations sont vite devenues évidentes. Chaque fois que je voulais poser une question, je devais à nouveau coller mes notes ou compter sur le contexte restant dans la conversation.

Cela ne ressemblait pas à un système. C'était comme recommencer à chaque fois.

Je voulais un système plus cohérent, où mes notes faisaient déjà partie de la configuration, plutôt que quelque chose que je devais réintroduire à chaque session. C'est ce qui m'a poussé à dépasser le chat et à utiliser l'API.

En termes simples, cela signifiait écrire un petit script qui envoie mes notes et mes questions directement au modèle et reçoit des réponses en retour. Pas de fenêtre de chat, pas de copier-coller manuel, juste une demande structurée et une réponse structurée.

Le changement en soi n'était pas aussi compliqué qu'il y paraît, mais cela a modifié ma façon de penser l'interaction. Au lieu de considérer l'IA comme un interlocuteur, elle est devenue un composant autour duquel je pouvais construire.

Il y avait quelques éléments pratiques à prendre en compte rapidement. La clé de l'API se comporte comme un mot de passe, donc elle doit être manipulée avec précaution. Et puisque l'utilisation est facturée par demande, il est facile de sous-estimer la rapidité avec laquelle les coûts peuvent s'accumuler si l'on ne fait pas attention.

Une fois tout configuré, j'ai adopté l'approche la plus simple possible. J'ai chargé toutes mes notes, les ai envoyées avec chaque question, et laissé le modèle répondre.

Pendant un certain temps, le système a fonctionné exactement comme je l'attendais.

Puis cela a recommencé à se détériorer.

Les limites du système

À mesure que mes notes s'accumulaient, le système a recommencé à montrer des signes d'incohérence.

Je posais la même question et recevais des réponses légèrement différentes. Parfois, des détails que je savais être dans mes notes n'apparaissaient tout simplement pas. Ce n'était pas évident au début, mais le schéma est devenu difficile à ignorer. Plus j'ajoutais de notes, moins les réponses semblaient fiables.

C'est alors que j'ai découvert le concept de la fenêtre de contexte.

Le modèle ne peut traiter qu'une quantité limitée de texte à la fois. Tout ce que vous envoyez—vos notes, votre question, et même des parties de la conversation précédente—doit tenir dans cette limite. Si ce n'est pas le cas, une partie est tout simplement ignorée.

Il n'y a pas d'avertissement lorsque cela se produit. Le modèle ne vous dit pas qu'il a manqué quelque chose. Il répond simplement en fonction de la portion qu'il a pu lire.

Une fois que j'ai compris cela, l'incohérence a pris sens. Le modèle n'ignorait pas mes notes. Il ne pouvait tout simplement pas les voir toutes.

La limite elle-même est mesurée en tokens, pas en mots. Les tokens sont des morceaux de texte plus petits, et ils s'accumulent plus rapidement que vous ne le pensez, surtout avec du matériel technique. Quelques pages de notes peuvent rapidement se transformer en milliers de tokens.

Ce qui signifie que l'envoi de toutes mes notes avec chaque question n'était pas seulement inefficace. Cela allait finalement échouer, peu importe quoi.

Cette réalisation a changé le problème. Il ne s'agissait plus de rendre l'IA "meilleure". Il s'agissait de travailler dans une contrainte que je n'avais pas comprise auparavant.

La vraie question est devenue : comment m'assurer que le modèle voit les bonnes informations sans essayer de lui montrer tout ?

Une approche plus ciblée

Une fois que j'ai compris que le modèle ne pouvait pas tout voir à la fois, le problème est devenu plus clair. Je n'avais pas besoin qu'il lise toutes mes notes à chaque fois. J'avais juste besoin qu'il lise les bonnes parties.

Jusqu'à ce moment-là, mon approche avait été simple : envoyer tout et laisser le modèle s'en débrouiller. Cela fonctionnait lorsque les notes étaient petites, mais cela a échoué dès qu'elles ont dépassé ce que le système pouvait gérer.

J'ai donc inversé l'approche.

Au lieu d'envoyer toutes mes notes, j'ai commencé par les rechercher d'abord. Lorsque je posais une question, le système cherchait les sections les plus pertinentes, les extrayait et n'envoyait que ce contexte plus petit et ciblé au modèle.

Ce petit changement a fait une différence notable.

Les réponses sont devenues plus cohérentes, et plus important encore, elles ont commencé à ressembler à mes notes à nouveau. Les explications reflétaient la manière dont j'avais écrit les choses, y compris les analogies qui avaient eu du sens pour moi lorsque je les avais apprises pour la première fois.

Cette approche est souvent appelée génération augmentée par récupération, mais l'idée elle-même est simple. Vous récupérez d'abord l'information pertinente, puis générez une réponse basée sur celle-ci.

Ce qui m'a frappé, c'est que la méthode ne rendait pas le modèle plus intelligent. Elle le rendait juste plus ancré. Au lieu de s'appuyer sur ce qu'il "savait", il était désormais ancré dans ce que j'avais réellement écrit.

Cette distinction importait plus que je ne l'avais prévu.

Le moment de la révélation

Même après avoir corrigé la récupération, il y avait encore quelque chose qui ne semblait pas tout à fait juste.

En général, les réponses étaient ancrées dans mes notes. Elles reflétaient mes explications, mes analogies et la manière dont j'avais construit ma compréhension. Mais de temps en temps, quelque chose glissait qui n'appartenait pas.

Une réponse a rendu cela évident.

J'avais demandé au système d'expliquer la rétropropagation en utilisant mes notes. Cela a bien commencé, en parcourant l'idée d'une manière qui correspondait à la façon dont je l'avais écrite. Puis, à mi-chemin, il a introduit une formule mathématique détaillée.

Je me suis arrêté immédiatement. J'avais...