16 September 2026 · learningspaced-repetitionroadmap
How to learn machine learning effectively (and actually remember it)
Most people finish an ML course and cannot use it a month later. This post covers what to learn in which order, how to practice so the concepts stay, and a weekly schedule you can keep with 30 to 45 minutes a day.
Learning machine learning effectively means being able to use a concept weeks after you learned it, without reopening the video. Finishing a course is not the goal, because most people who finish one cannot write a training loop or explain why their loss is stuck a month later. The material was understood at the time and then lost. This post is about the second half of the problem: how to learn so that the concepts are still there when you need them, and in what order to learn them so nothing assumes something you skipped.
Why you forget most of it within a week
Memory for new material decays fast unless it is used. After a lecture on gradient descent you retain most of it that evening, a fraction of it the next day, and a small piece a week later. This is not a personal failing. It is how memory works for anything you were shown once and never had to produce yourself.
Videos and books make it worse in a specific way. While you are watching, every step looks obvious because someone else is doing it. That feeling is recognition, and recognition is not the same as recall. Recall is closing the tab and writing the update rule, or explaining why the learning rate matters, with nothing in front of you. Most self-taught learners test themselves with recognition (does this look familiar?) and are surprised when recall fails in an interview or a project.
So the plan below has two parts: learn things in an order where each piece has what it needs, and practice in a way that forces recall instead of recognition.
Learn in an order where nothing is assumed
Most people stall because a concept assumed three others they never met. The order that avoids that is:
- Python until you can write a function, a class, and a loop over a list of tuples without looking anything up. Two to three weeks if you code in another language, longer from zero.
- The math ML uses, not the math a degree covers: vectors, matrices, matrix multiplication, the dot product, derivatives, the chain rule, mean, variance, and basic probability. That list is short on purpose. Everything else can be learned the day you need it.
- PyTorch basics: tensors, shapes, automatic differentiation, and writing a training loop by hand before you ever use a helper library.
- ML foundations: linear and logistic regression, loss functions, gradient descent and its variants, overfitting and how to detect it, train/validation/test splits, and evaluation metrics.
Only after stage 4 do transformers, convolutional networks, or diffusion models make sense, because each of them is those four stages combined in a new shape. If you want every concept in these stages named in teaching order, the roadmap post lists them.
One concept at a time matters more than the source you use. A concept is something like "the learning rate" or "cross-entropy loss", small enough to learn, practice, and test in one sitting. A concept is not "neural networks".
Practice before you feel ready
The single biggest change most learners can make is to practice on each concept the same day they learn it, before it feels solid. Three kinds of practice work for ML in particular:
- Turn the equation into code. Read the gradient descent update rule, then write it as three lines of PyTorch with no autograd. Then do the reverse: read a training loop and write the equation it implements.
- Predict before you run. Before executing a cell, write down the shape of the output tensor, or the value the loss should roughly take. Being wrong here is where the learning happens.
- Break it on purpose. Set the learning rate 100 times too high, remove the normalization, swap the loss. Watch what happens and explain it in one sentence.
Reading and watching feel productive because they are fast. Practice feels slow because you keep failing, and that failure is the point. A concept you struggled to reproduce is the one you will still have in a month.
Use active recall, not rereading
Active recall means producing the answer from memory instead of checking whether it looks right. For each concept, after the practice above:
- Close everything and explain the concept out loud in under a minute, as if to a friend who codes but has not seen it.
- Write the core equation or the core code from memory. Compare, fix, and note what you got wrong.
- Keep a short list of questions per concept ("why divide by the square root in Adam?", "what does a validation loss that rises while training loss falls mean?") and answer them cold.
If you cannot do this for a concept, you have not learned it yet, and no amount of rewatching will change that. Go back to the practice step.
Space your reviews
Spaced repetition means reviewing a concept at growing intervals: the next day, then three days later, then a week, then two weeks. Each successful recall pushes the next review further out. Each failed recall pulls it back in. The result is that easy concepts cost you almost nothing and hard concepts get the attention they need.
Doing this by hand works with a plain notebook or a spreadsheet: one row per concept, a column for the next review date, and a rule that a miss resets the interval. Ten minutes a day of review is enough to keep everything you have learned in the last few months. The QuiddityML app does this scheduling automatically from your exercise results, which is why QuiddityML pops a concept into review sooner when you miss its exercises, but the schedule matters more than the tool.
Build one small project per stage
A project is where the concepts get connected, and where you find out which ones you only recognized. Do not save one giant project for the end. Do one per stage, small enough to finish in a weekend:
- After Python: a script that loads a CSV, computes a few statistics, and plots them.
- After math: implement linear regression with gradient descent using only NumPy.
- After PyTorch basics: the same linear regression, then a two-layer network on a toy dataset, with a training loop you wrote.
- After ML foundations: a real classification dataset, with a proper train/validation/test split, a baseline, and a written note on what overfit and what fixed it.
Each project should produce something you can explain in three sentences, because that is how you will describe it in an interview.
A weekly schedule you can keep
Consistency beats intensity. A plan you keep for three months at 30 minutes a day beats a plan you keep for two weekends at six hours. A week that works for most people:
| Day | What | Time |
|---|---|---|
| Mon to Thu | One new concept: read or watch, then practice on it the same session | 30 to 45 min |
| Fri | Review only: active recall on everything due this week | 20 to 30 min |
| Sat | Project work on the current stage's project | 60 to 90 min |
| Sun | Off, or a second review if a lot is due | 0 to 20 min |
Put the review days in your calendar first. New material is the part people never skip, and review is the part that decides whether the new material survives.
Common mistakes
- Tutorial hell. Finishing course after course with no project and no recall practice. If you have finished two courses and cannot write a training loop from memory, stop starting courses.
- Skipping the math entirely, or drowning in it. The list in stage 2 is what you need. A full linear algebra course before your first model is a common way to quit.
- Jumping straight to transformers. Attention is a few matrix multiplications and a softmax. If those two are not solid, the paper will not make sense and you will conclude you are not smart enough, which is the wrong conclusion.
- No review. Learning without spaced review is renting the concept for a week.
- Measuring progress in hours watched. Measure it in concepts you can reproduce cold.
Related questions
How long does it take? With 30 to 45 minutes a day and the schedule above, the four stages take most people four to six months, less if Python and the math are already there.
Do you need a degree? For most applied roles, no. A portfolio of the stage projects plus the ability to explain the concepts cold gets further than a certificate.
What about a course? Use one if it helps you stay on schedule, but treat it as the source of concepts, not the proof of learning. The proof is the recall and the projects.