Learning ML,
one experiment
at a time.

I started collecting these links while finding my own way into machine learning. The collection grew faster than my understanding. A good course is useful; five open courses can become a very elaborate way to avoid writing code.

This is the route I would use to make that collection useful: pick one starting point, build something small, and let the things you cannot explain guide what you study next. Keep the resource shelf below for when you need it.

01 / Choose your way in

You do not need the perfect curriculum. You need a first course that matches how you like to learn. Both routes below eventually meet at the same place: implementing a model and understanding why it behaves the way it does.

Karpathy’s Neural Networks: Zero to Hero is the series I keep coming back to. It starts with gradients and a tiny automatic differentiation engine, then works toward language models, GPT, and tokenization. There is something satisfying about seeing a large idea emerge from code you can still hold in your head.

My rule for a lesson: reproduce its result, close the reference, and change one thing. A different dataset, a smaller network, a deliberately bad learning rate. If you can predict the effect and explain what actually happened, the lesson has started to stick.

02 / Give the math something to explain

Start with 3Blue1Brown’s three explanations: neural networks, gradient descent, and backpropagation. Watch for the relationship between predictions, error, and the parameters that produced them.

Then try the smallest possible version of learning. Our model has one parameter, w. Its loss is L(w) = w², so the best value is zero. Gradient descent updates it using w ← w − η · 2w, where η is the learning rate.

At a learning rate of 0.1, the parameter moves steadily toward zero. At 0.8, it jumps across the minimum but still converges. At 1.0, it keeps bouncing between two equally bad values. Above 1.0, it moves farther away. These thresholds belong to this particular quadratic; real networks have much more complicated loss surfaces.

This is why I like visual explanations: a symbol becomes a behavior you can test. Backpropagation supplies gradients efficiently; the optimizer uses them to update parameters. They are related jobs, and understanding the distinction makes training code easier to read.

Learn these ideas as they become useful

Linear algebra is the language of the objects you manipulate. Start with 3Blue1Brown’s Essence of Linear Algebra, especially the lesson on linear transformations. Work through Gilbert Strang’s MIT 18.06 when you want lectures and exercises that go deeper. Your first checkpoint: explain what a matrix multiplication does, and track the shape of every tensor in a small network.

Calculus gives you a way to ask how a change in one quantity affects another. Start with derivatives and the chain rule. Differentiate a small expression by hand, then compare the answer with the gradient your code produces. That little agreement is more valuable than recognizing a page of notation.

Probability becomes concrete when a model assigns confidence to a prediction. Check that its probabilities sum to one, inspect confidently wrong examples, and keep training data separate from the data you use to evaluate it. A falling training loss alone does not tell you whether the model learned something useful.

03 / Build toward a question

Choose a project small enough that you can inspect its mistakes. For a classifier, save the inputs it gets wrong. For a character-level language model, read its samples at several training checkpoints. Keep a simple baseline so that “better” means something measurable.

Once you can train and debug a small network, pick a direction that makes you curious. NYU’s 2021 Deep Learning course offers another detailed explanation of the foundations. ARENA 3.0 is a more demanding next step, with exercises in fundamentals, transformer interpretability, and reinforcement learning. I would approach it after getting comfortable with Python, tensors, and basic neural networks.

A detour worth taking: diffusion

I love explanations that let you take an idea apart. Diffusion Explainer lets you explore a Stable Diffusion pipeline visually. Use it alongside a lesson: trace how the text prompt conditions the process and how repeated denoising leads toward an image. The project also has a paper and source code if the explanation itself makes you curious about how it was built.

04 / A separate branch: building with LLMs

My original notes also collected material about Claude, tools, and agents. That is a useful branch of the map: here you are building software around a trained model. You can explore it while learning ML, but an API demo will not teach you how training works.

Start with Anthropic’s Building effective agents. Its distinction is practical: in a workflow, code determines the sequence; in an agent, the model has more control over which steps and tools to use. Start with a small, explicit workflow and evaluate it before giving the model more decisions.

For implementation, move from Claude Cookbooks, which contain focused examples, to Claude Quickstarts, which show more complete applications. Claude Academy is another starting point for guided learning. When you need to connect a model-powered application to tools or data, read the MCP introduction.

Keep the first project bounded: answer questions from a small document collection, show which passage supports the answer, and test questions the documents cannot answer. That gives you something concrete to evaluate before adding more moving parts.

The resource shelf

These are references to return to when a question appears. Choose one course as your main thread; use the rest to fill a specific gap.

Your next session

Open the first lesson of your chosen course. Run its notebook. Change one thing and write down what happened in three sentences: what you expected, what you observed, and what you still do not understand.

That last sentence is the starting point for the next session.