URL: https://linuxfr.org/users/anaseto/journaux/mes-peripeties-avec-la-repetition-espacee Title: Mes péripéties avec la répétition espacée Authors: anaseto Date: 2017年06月10日T16:49:57+02:00 License: CC By-SA Tags: tcl et répétition_espacée Score: 71 Bonjour Nal, Aujourd'hui, je viens pour te raconter mes péripéties avec la répétition espacée et la naissance de *morji*, un logiciel de [répétition espacée](https://fr.wikipedia.org/wiki/R%C3%A9p%C3%A9tition_espac%C3%A9e), tout comme [mnemosyne](https://fr.wikipedia.org/wiki/Mnemosyne_(logiciel)) ou [anki](https://fr.wikipedia.org/wiki/Anki), mais comme alternative minimaliste en mode texte dans le terminal. Avant de te raconter le pourquoi du comment de morji, je vais te raconter un peu le concept de répétition espacée, ainsi que te montrer un peu le principe des algorithmes qui font marcher l'idée. La répétition espacée : qu'est-ce donc ? ========================================= L'idée de la répétition espacée part d'un constat expérimental : lorsqu'on apprend quelque chose, peu importe quoi, on a besoin de réviser pour ne pas l'oublier, et l'intervalle entre révision et révision peut s'allonger avec le temps — l'expérience suggère une progression exponentielle. Si je t'apprends le nom d'une plante aujourd'hui et que je te repose la question dans un mois, tu auras sans doute oublié d'ici là. Si je te repose la question demain, il y a des chances que tu t'en souviennes, et si je te repose la question une semaine après, il y a de bonnes chances aussi ; si après ceci j'attends un mois pour t'embêter de nouveau... et bien probablement aussi ! Tu me diras, rien de bien extraordinaire là-dedans. Peut-être pas, et encore... Mais ce qui est sûr, c'est que, du coup, il faut une certaine organisation si l'on veut retenir un maximum de choses tout en faisant un minimum d'efforts. Le drame, c'est que choisir manuellement à l'intuition ce qu'il faut réviser et quand, c'est pas toujours évident. Un peu d'automatisation ! ------------------------- C'est là qu'on se dit, et si on pouvait faire faire ce travail à une machine ? Il se trouve que ça s'applique pas facilement à tout type de connaissance, mais il y a des cas où on peut, en particulier lorsque les faits à se remémorer se structurent facilement en cartes-mémoires du type question/réponse. Par exemple : ``` Question: nom de plante avec de gros piquants dangereux qui pousse dans le désert Réponse: cactus ``` L'interaction (version naïve) se fait ainsi : - le programme nous pose la question ; - on réfléchit à la réponse ; - on affiche la réponse ; - on dit à la machine si on s'en souvenait. Si on s'en souvenait (on a pensé à « cactus »), la machine calcule alors la date de la révision suivante en tenant compte de l'intervalle entre les deux révisions précédentes. Sinon (on a pensé à « rose » ou « chardon » ou à rien du tout), les intervalles repartent de zéro pour ce fait, qu'il faut remémoriser. Ces idées ont donné naissance à des algorithmes. Le premier semble être le [Système Leitner](https://fr.wikipedia.org/wiki/Syst%C3%A8me_Leitner), qui date des années 70 et qui ne semble pas être vraiment utilisé aujourd'hui dans des logiciels, mais qui par contre avait l'avantage de pouvoir s'utiliser à la main avec des boîtes. Cet algorithme classait les faits par groupes (les boîtes) : le premier groupe contenait les faits non mémorisés ou oubliés, le second les faits mémorisés qui ont été révisés une fois, et ainsi de suite. Plus le numéro de groupe était élevé, moins la carte était révisée, suivant une méthode de calcul artisanale qui utilisait une taille maximale pour chaque groupe : le premier groupe était de taille 1, le deuxième de taille 2, puis 5, puis 8, etc. C'est seulement lorsqu'un groupe était « plein » qu'il fallait réviser des cartes de ce groupe pour les faire passer au groupe suivant. L'inconvénient du procédé, même implémenté dans un logiciel (parce que les boîtes ça prend de la place mine de rien), c'est qu'il est un peu binaire. Des fois on se souvient presque (on a pensé « kaktus »), ou alors on se souvient, mais on a eu beaucoup de mal, ou alors c'était trop facile. Du coup, l'idée est venu de demander à l'utilisateur d'évaluer lui-même sa performance, soit à l'aide d'un nombre entre 0 et 5 (mnemosyne ou SuperMemo), soit de façon plus qualitative (anki). En fonction du résultat, l'intervalle de révision suivant est ajusté par le logiciel qui maintenant a une idée de la difficulté que présente ce fait particulier pour l'utilisateur. Vers des algos plus évolués : exemple de SM2 -------------------------------------------- Un deuxième algo plus évolué est alors apparu, appelé SM2, du nom de SuperMemo2, logiciel pas libre qui a lancé l'idée. Depuis, son algo s'est compliqué sensiblement pour tenir compte finement du fait que certains faits sont liés entre eux et autres subtilités, et le logiciel est probablement devenu une usine à gaz, mais l'idée de fond reste la même. En fait, les logiciels mnemosyne et anki utilisent simplement une version modifiée de SM2 qui marche bien en pratique et leurs auteurs semblent sceptiques sur les versions suivantes de l'algo (ça va jusqu'à SM11 ou plus). Il y a aussi un [mode Emacs](https://www.emacswiki.org/emacs/FlashCard) qui fait de la répétition espacée et qui permet d'utiliser SM5, même si par défaut ça utilise encore le système Leitner si les infos sur le site ne sont pas obsolètes. Il y a aussi [Org-Drill](http://orgmode.org/worg/org-contrib/org-drill.html) (Emacs encore) qui fait du SM5 par défaut. L'algorithme SM2 original est une simple traduction des idées ci-dessus : si `I(n)` représente l'intervalle entre la `(n-1)`-ième répétition et la `n`-ième, alors : - `I(1) = 1` - `I(2) = 6` - Pour `n> 2` : `I(n) = I(n-1) * facilité`. `facilité` est un paramètre propre au fait qui évolue au fil des notes successives données à chaque révision. Initialement il vaut 2.5, puis il évolue autour en fonction des notes. Le paramètre a une valeur minimale de 1.3, pour éviter des révisions trop fréquentes d'un même fait : en pratique elles correspondent à des faits non-compris ou mal posés dont il faut revoir la présentation. Par exemple, anki propose 4 choix lors d'une révision : - On a oublié : l'intervalle est remis à zéro, la facilité laissée telle quelle ; si on a oublié ça veut pas forcément dire que c'était dur, des fois on oublie, c'est tout. - Ok, mais c'était dur : la facilité est diminuée (de 0.15 il me semble pour anki), et le nouvel intervalle tiendra compte de ceci. - Ok, juste comme il faut : la facilité ne change pas. - Ok, mais trop facile : la facilité augmente (0.10 pour mnemosyne, 0.15 pour anki de mémoire). Le détail de l'algorithme original et de la modification du paramètre de facilité peut être trouvé [à la source](https://www.supermemo.com/english/ol/sm2.htm) (site qui, dit en passant, contient beaucoup d'articles intéressants sur la mémoire, bien que parfois un peu biaisés sans doute). *Remarque annexe sur le document :* Faut faire gaffe, car il y a une petite subtilité : le 5ème et 6ème points sont inversés dans mnemosyne et anki, c'est-à-dire qu'on ne modifie pas la facilité lorsqu'on a oublié. Ceci semble logique, car si on a oublié totalement un fait, ça veut pas forcément dire qu'en le réapprenant on va avoir des difficultés et, de plus, ajuster la facilité en variant les réponses affirmatives semble suffisant et plus raisonnable : l'algo original (si tant est que ce ne soit pas juste un bug du document) a tendance à faire plomber trop vite le taux de facilité suite à des échecs successifs lors de l'apprentissage d'une carte. Quelques améliorations ---------------------- Un souci avec le SM2 original, c'est qu'il suppose que l'utilisateur va apprendre tous les jours plus ou moins la même quantité de faits. En effet, si un jour on apprend 20 faits, et un autre on en apprend 50, ça veut dire que ces 20 faits seront révisés, à moins d'être oubliés, toujours aux mêmes dates avec les mêmes intervalles, et de même pour les autres 50 aussi : on se retrouve donc avec une charge de révision très inégale suivant les jours. Même en étant disciplinés, il arrive parfois de ne pas pouvoir faire ses révisions pendant plusieurs jours, par exemple, et créer ainsi sans faire exprès ce genre d'inégalités de charge. Les logiciels anki et mnemosyne introduisent un peu d'aléatoire dans l'algorithme pour résoudre ce problème. Plutôt que de faire réviser les 50 cartes le même jour, elles seront réparties sur les jours autour, avec une incertitude qui dépend de l'intervalle (5% pour mnemosyne, sauf pour les petits intervalles où des valeurs spéciales sont codées en dur). Il y a d'autres petites subtilités pour être un peu résistant aux vacances ou autres cas spéciaux : par exemple, si on se souvient d'un fait qu'on était censé réviser il y a une semaine, le nouvel intervalle doit tenir compte de la date de la vraie répétition, pas seulement de la date théorique mais, en même temps, si l'utilisateur a du mal, on peu préférer être plus conservateur sur le nouvel intervalle qu'en théorie : lors du calcul anki compte les jours de retard avec un poids plus faible qui dépend de la note ; mnemosyne se contente d'être conservateur si la note correspond à « c'était dur ». C'est des ajustements de bon sens, mais sans théorie vraiment derrière, pour autant que je sache. Une petite simulation ! ----------------------- Pour se faire une idée de la charge de révision que l'on accumule, j'ai fait une petite simulation sur plus d'un an (500 jours). Tous les jours, 15 nouvelles cartes apprises, et quelques pourcentages pris un peu au flair (ça varie sans doute beaucoup suivant la façon de voter de la personne et le sujet) : chaque jour, 5% de cartes oubliées (mais réapprises le jour même de l'oubli), 2% classées difficiles, et 1% classées faciles. Au total, 7500 cartes sont mémorisées. On se retrouve avec un nombre de cartes à réviser par jour pour la semaine suivante qui ressemble à : ``` 88 88 76 85 86 79 56 ``` Un petit calcul permet de prévoir l'ordre de grandeur du résultat : en supposant de voter toujours « Ok, je m'en souviens bien », ça correspond à des intervalles (à randomisation et ajustements près) de 1, puis 6, puis à partir d'ici multiplier l'intervalle par 2.5, ce qui donne en moyenne entre 5 et 6 révisions par carte sur l'intervalle de 500 jours, donc en multipliant par le nombre de cartes nouvelles par jour, ça donne entre `5 * 15 = 75` et 90. Comme en pratique on oublie quand même des cartes, et la facilité c'est souvent un peu moins de 2.5, c'est en fait un peu plus, mais c'est le bon ordre de grandeur. Quelques types de cartes-mémoires --------------------------------- Tout à l'heure, j'ai donné un exemple simple de question/réponse avec un cactus. Les logiciels gèrent en général plus de types de cartes-mémoire. En particulier, des faits que l'on veut être capable de retenir dans les deux sens. Par exemple, imaginons qu'on veut retenir le nom des capitales, on veut une question du genre : ``` Question: France Réponse: Paris ``` Mais peut-être qu'il peut être intéressant aussi d'avoir la question à l'envers aussi : ``` Question: Paris Réponse: France ``` En pratique on s'aperçoit souvent que ce n'est pas parce qu'on sait répondre à une question dans un sens qu'on sait le faire dans l'autre ! Les amateurs de langues le savent bien :) C'est pour cela que mnemosyne et anki sont capables de générer deux cartes-mémoires à partir d'un seul fait pour gérer ce genre de cas de façon commode. Une autre façon parfois pratique de représenter une question peut être le texte à trous : ``` Question: [...] est la capitale de la France. Réponse: Paris ``` Mais aussi : ``` Question: Paris est la capitale de [...]. Réponse: la France ``` Pour ce genre de cartes, en pratique on écrit quelque chose comme : ``` Question: [Paris] est la capitale de [la France]. Réponse: la France ``` ...Et le logiciel génère à partir de ce seul fait les deux cartes-mémoires. D'un point de vue de l'algorithme, ça pose la question intéressante d'éviter de se voir demander les deux cartes le même jour, ce qui risquerait de fausser un peu la révision et la note attribuée à la deuxième carte. En pratique on utilise des solutions plus ou moins ad-hoc où on s'arrange pour ne pas mettre les deux le même jour. Morji ===== [morji](https://bardinflor.perso.aquilenet.fr/morji/intro-fr) c'est donc encore un autre logiciel de répétition espacée utilisant un SM2 modifié, comme anki et mnemosyne, mais dans le terminal et avec un minimum de dépendances. « Mnemosyne » est le nom d'une déesse grecque de la mémoire, « anki » signifie mémorisation en japonais ; pour rester dans le thème et faute de meilleures idées, « morji » signifie « se souvenir » en [lojban](https://fr.wikipedia.org/wiki/Lojban). Une nimage d'abord ------------------ ![https://bardinflor.perso.aquilenet.fr/morji/morji-screenshot.png](https://bardinflor.perso.aquilenet.fr/morji/morji-screenshot.png) Le début de l'histoire --------------------- J'étais jusqu'à il y a peu un utilisateur relativement satisfait de mnemosyne. L'interface est plutôt simple, son concept de tags pour organiser les faits est flexible et, dans l'ensemble, le logiciel est assez orthogonal. Il a quelques défauts, parfois un peu lent pour certaines opérations, c'était quand même un peu trop clickodrome pour moi et, devoir écrire mes cartes sans vim, c'était un peu dur ; mais dans l'ensemble, c'est sympa. D'habitude j'utilise OpenBSD sur un fixe, mnemosyne est dans les paquets, donc tout va bien. Mais j'ai aussi une autre machine (un ordinateur portable) sur laquelle, pas de chance, OpenBSD détectait pas bien la carte réseau, du coup j'ai installé un Void Linux (il s'agissait de pas être trop dépaysé). Et là, c'est le drame. Mnemosyne n'était pas dans les dépôts. Paf. Je prends mon courage à deux mains, et j'essaie de compiler le truc. Je regarde les dépendances, certaines sont pas dans les dépôts. Qu'à cela ne tienne, c'est du python, j'installe ça avec pip... Après plusieurs itérations à installer de nouveaux paquets, c'est l'échec cuisant. Je commence à redouter des incompatibilités de versions, python 2 ou 3, je teste des trucs ; ça fait bien deux heures, j'abandonne et me dis que, quand même, les packageurs, c'est un peu des super héros, et que je serais mal barré sans eux. Ça m'a fait un peu peur, parce que, bon, l'idée de me retrouver un jour avec ma base de données mnemosyne et toutes ses données d'apprentissage sans pouvoir l'utiliser, ça fait un peu mal. Alors, comme je connaissais un peu les algorithmes, SM2 et tout ça, je savais que c'était quand même pas très compliqué et, comme j'avais pas besoin de tant de *features* que ça, je me suis lancé. Les *features* -------------- morji gère juste les trois types de cartes-mémoires que j'ai décrites avant : dans un sens, à double sens et textes à trous. Il ne gère pas l'html, ni le javascript, mais il permet de faire du balisage sémantique simple pour mettre des couleurs, du gras ou de l'italique. Par exemple, la ligne suivante dans le fichier de configuration : ``` markup keyword colored red ``` Définit le tag `keyword` qui permettra de rendre du texte en rouge. On l'utilise ainsi dans le contenu d'une question : ``` Que veut dire [keyword mot-clé]? ``` qui rend `mot-clé` en rouge. morji utilise un système de tags similaires à celui de mnemosyne. On peut donc associer à chaque fait un ou plusieurs tags. Ensuite, on active ou désactive des tags pour choisir quels thèmes réviser ou apprendre. Ça permet par exemple de mixer les thèmes pendant les révisions — chose que je trouve stimulante perso —, puis au moment d'apprendre de nouvelles cartes sélectionner un seul tag. Il est possible d'importer d'un coup une liste de faits depuis un fichier avec des champs séparés par des tabulations, un peu comme avec mnemosyne. **Remarque technique :**. morji n'est pas un projet de recherche, du coup il stocke moins de statistiques dans la base de données. Je ne sais pas si c'est surtout ça, ou le fait que mnemosyne stocke certaines informations plus ou moins en double pour des raisons qui restent un peu mystérieuses pour moi (éviter de recalculer des choses, peut-être), mais ma base de données mnemosyne est passée de presque 50M à 10M avec morji ; pratique pour faire des backups quand on a une connexion pas trop rapide :) Les trucs qu'il n'y a pas ------------------------- Actuellement, morji ne gère pas de fichiers externes (images, son). A priori, il serait cependant facile si besoin de l'étendre via le fichier de configuration (qui est un script Tcl même si ça se voit pas) pour lancer un visionneur d'images externe, par exemple, à défaut d'un truc parfaitement intégré. Il n'y a pas non plus de navigateur de cartes-mémoire. En pratique, ça correspond à cas d'utilisation très rare — en tous cas pour moi — puisque, a priori, le principe c'est qu'on va pas chercher des faits soi-même, c'est le logiciel qui le fait pour nous ; ceci dit, parfois ça pourrait être commode, mais je n'ai pas trouvé encore une solution simple qui me plaise. En attendant d'en trouver éventuellement une, pour faire des substitutions en masse ou ce genre de choses, il est possible d'utiliser un script (morji est scriptable en Tcl) ; l'interface pour faciliter cela proprement n'est pas encore vraiment fixée ni documentée (en dehors de commentaires dans le code et d'exemples), mais ne devrait pas trop changer, donc en pratique il y a moyen de se dépatouiller si besoin. Sous le tapis ------------- Là, c'est parti pour une petite section un peu technique, pour ceux qui ont eu la patience de me lire jusqu'ici :) Comme j'ai un peu raconté tout ce qu'il faut savoir sur SM2, les faits et les types de cartes-mémoires, etc. je me dis que tu veux peut-être savoir à quoi ressemble le schéma de la base de données utilisée par morji, qui est en fait une traduction idée pour idée des concepts. Il y a quatre tables : une pour les faits, une pour l'information spécifique à chaque carte-mémoire, une pour les tags, une qui fait la relation entre quels faits ont quels tags, et puis c'est tout. Je vais juste raconter un peu les deux premières, pour qu'on revoie les concepts de l'algo SM2. Celle des faits, `facts`, stocke donc, entre autres, une question et une réponse : ``` sql CREATE TABLE IF NOT EXISTS facts( uid INTEGER PRIMARY KEY, question TEXT NOT NULL, answer TEXT NOT NULL, notes TEXT NOT NULL, -- oneside/twoside(recognition/production)/cloze... type TEXT NOT NULL ); ``` En fait, on retrouve bien le champ pour la question et la réponse. Il y a de plus un champ pour des notes additionnelles dont je n'ai pas parlé avant (mais c'est dans la nimage plus haut), et qui sert à afficher des trucs en plus dans la réponse pour les faits à deux sens, indépendamment du sens (par exemple un lien vers la source de l'information). Le champ `type` nous dit s'il s'agit d'un fait à un sens, à deux sens ou d'un texte à trous. La table contenant l'information d'apprentissage de chaque carte mémoire est un peu plus compliquée : ``` sql CREATE TABLE IF NOT EXISTS cards( uid INTEGER PRIMARY KEY, -- last repetition time (null for new cards) last_rep INTEGER, -- next repetition time (null for new cards) next_rep INTEGER CHECK(next_rep ISNULL OR last_rep < next_rep), easiness REAL NOT NULL DEFAULT 2.5 CHECK(easiness> 1.29), -- number of repetitions (0 for new and forgotten cards) reps INTEGER NOT NULL, fact_uid INTEGER NOT NULL REFERENCES facts ON DELETE CASCADE, -- additional data whose meaning depends on facts.type fact_data TEXT NOT NULL ); ``` Les champs `last_rep` et `next_rep` contiennent les dates de la dernière répétition et la répétition suivante, respectivement (leur différence est donc l'intervalle théorique entre les deux répétitions). Le champ `easiness` contient la facteur de `facilité` de toute à l'heure, et `reps`, c'est le nombre de répétitions, donc le `n` des formules. Enfin, `fact_uid` signale le fait auquel fait référence la carte, et `fact_data` donne des informations supplémentaires : par exemple, est-ce le verso ou le recto qu'il faut montrer ? Un truc à remarquer aussi, c'est la valeur par défaut de 2.5 pour la facilité et la contrainte sur le minimum, qui font écho à l'algorithme. Petite anecdote pour la fin --------------------------- Je crois que j'ai déjà prononcé le mot Tcl un peu avant. Eh oui, morji est écrit en Tcl. En fait, quand j'ai commencé à écrire morji, j'ai vite compris que ça allait être essentiellement des requêtes SQLite et pas grand-chose de plus. Or, pendant que je me mettais à jour sur SQLite, mon attention a été attiré, un peu par hasard, par le fait que SQLite avait été initialement prévu comme [une extension Tcl](https://sqlite.org/tclsqlite.html), avant de devenir ce qu'on connaît aujourd'hui ; du coup ça m'a intrigué, j'ai découvert que l'interface Tcl pour SQLite était vraiment sympa et leur système de tests unitaires aussi. Ajouté au fait que Tcl est un langage léger présent sur à peu près toutes les plateformes, eh bien, j'ai pas pu résister :) *Anecdote : au début j'envisageais d'écrire morji en Go, du coup je voulais* l'appeler « gogoratu » — « se souvenir » en basque —, parce que c'était rigolo, mais du coup, après, la blague tombait un peu à l'eau :) Voilà, c'est tout ! **Liens :** [site de morji](https://bardinflor.perso.aquilenet.fr/morji/intro-fr), avec documentation en html ; [page github](https://github.com/anaseto/morji) du projet.

AltStyle によって変換されたページ (->オリジナル) /