There are many types of education. When learning to ride a bike you learn by doing. When your mum shouts at you to stay away from the road you learn socially that the road is a dangerous place. And when you’re a med student learning all 642 (thanks, Wikipedia) skeletal muscles in the human body, you learn by rote memorisation.
If you’ve ever studied foreign language vocabulary, the theory part of a driving test, or crammed for an end-of-year exam that you didn’t really care about, you’ve learned by rote memorisation. And it sucks. It sucks because it takes inordinate amounts of time and unless you’re extremely engaged with the content, it’s boring as hell.
Unfortunately, for certain classes of information rote memorisation is unavoidable. As a student of Chinese I’m invested in rote memorisation so for the past month I’ve been working on a side project, CardFlash, that aims to make rote memorisation:
- More fun
Fortunately many clever people have put a lot of time into #2. It turns out rote memorisation can be made vastly more efficient using Spaced Repetition. From Wikipedia:
Spaced repetition is a learning technique that incorporates increasing intervals of time between subsequent review of previously learned material in order to exploit the psychological spacing effect.
the spacing effect is the phenomenon whereby animals (including humans) more easily remember or learn items when they are studied a few times spaced over a long time span rather than repeatedly studied in a short span of time.
In short the idea is that you only review items that you are “just about to forget”. This way you don’t waste time reviewing items that you can easily recall. How do we know when you are “just about to forget” an item? To do this we need a model of how the brain forgets things. In this article I’ll look at a few different models (we could call them spaced repeition algorithms), from naive to a-bit-less-simple, that I investigated while creating CardFlash.
1. Back of the deck
This is the most naive possible algorithm. If you’ve ever studied with flashcards, you’ve probably used this algorithm at some point. It goes like this:
- You take the top flashcard from your deck of cards, and try and answer the prompt (eg: “What is the capital of Kyrgyzstan?”)
- You check the answer and wether you answer correctly or not, you put the flashcard at the bottom of the deck
Obviously this is not a very efficient algorithm. There will inevitable be some questions you can answer easily and some you can’t. This algorithm gives the same weight to both. A simple improvement would be the following…
2. Back of deck / Front of deck.
Though still very naive, this algorithm takes into consideration whether you get the answer wrong or right. It assumes that if you got it wrong, you should review it again soon. It goes like this:
- Take the top flashcard from your deck, and try and answer the prompt
- Check the answer. If correct, place card at the bottom of the deck. If incorrect, put the flashcard in underneath the top card in the deck.
3. Time dependent
One problem with the above two algorithms is that the time between reviews depends on the size of the deck. If you keep answering prompts correctly, the flashcards keep going to the back. Whether you have a 100 or 1000 card deck will affect how frequently you review items. This is at odds with the spacing effect since the spacing effect says that the probability you have forgotten an item depends on the time since you last reviewed that item. Here is a slightly better algorithm that takes this into consideration, and is the first algorithm that you need software to help you with (unless you a master with the stopwatch).
- Review a card.
- If correct, review again in 1 hour. If incorrect review again in five seconds.
4. Past result dependent
Introducing time dependancy gets us closer to how the brain actually forgets, but obviously you don’t need to review something once every hour for the rest of your life to remember it. This is where spaced repetition comes in. Each time you review something correctly, the time until you forget it should increase. Likewise if you review something incorrectly, you should probably look at it again soon, since you’re finding it difficult. Here’s a chart showing the projected “forgetting curve” after each repetition:
By recording the interval between reviews for a particular card we can scale this interval to make it longer (in the case of a correct answer) or shorter (incorrect) to schedule the next review. Here’s the algorithm:
- Review a card.
- If correct, review again in 2x the previous interval’s time. So if you last reviewed it an hour ago, schedule the next review in 2 hours. If incorrect review again in 0.5x the previous interval’s time.
This is the first algorithm that seems to work and gives a sense of “intelligently” scheduling reviews. Having said that, there are still many improvements we can make here.
5. Past result(s) dependent
The previous algorithm only considered two things. 1) The duration of the last interval and 2) Whether you answered correctly or not. However when reviewing flashcards, you get a sense that some cards are intrinsically “easy” and some are “hard”. If you are reviewing an “easy” card, perhaps 2x interval increase is too little. Perhaps we could be more efficient by increasing the interval 4x. Let’s create a measure of difficulty, d that is a number from 0 to 1 representing the number of times you answered that card correctly (eg. a card with d = 0.5 is one you answered correctly 50% of the time). Here is an improved algorithm that takes difficulty into account:
This algorithm is what the current incarnation of CardFlash uses, with slight differences in the constants. However it is still a very simple algorithm and there is a lot of scope to get more advanced…
6. Introducing more factors
As long as the deck that the student is studying is of a consistent type of questions, why not introduce “deck difficulty”? This would be a number from 0 to 1 that represents the student’s performance on the deck as a whole. This would modify the interval scaling to ensure that the student could expect to get a certain portion of reviews correctly, regardless of the difficulty of the deck.
Another useful measure is overall student ability. You can take the performance of the student and use this to modify scheduled intervals for all cards. This way, for example, you could ensure that a student will always get approximately 90% of reviews correct. Finding the “secret sauce” of how to best mix student ability, deck difficulty, card difficulty and last review outcome would be the challenge here.
So far we’ve looked at some simple possible algorithms for improving the arduous task that is rote memorisation. There are many ways to improve these algorithms and find a closer approximation of the brain’s “forgetting curve”. However efficiency is only one half of the rote memorisation problem. If you are not motivated to learn, the cleverness of the algorithm is moot. Fundamentally, learning software needs to be fun, rewarding, and give a solid sense of progression. If you’re interested in checking my progression in tackling this problem, check out CardFlash at cardflashapp.com. All feedback welcome!