Jupyter / Colab
Live notebooks, executed cell-by-cell — you run every cell yourself.
// how_an_ml_session_works
Anatomy of a machine-learning session.
Notebooks over slides. You load a real dataset, train a model cell-by-cell, and watch the validation curve move when you change a hyperparameter — so over-fitting becomes something you’ve seen, not a definition you’ve memorised.
- subject: machine_learning
- format: notebook_first
- data: real_datasets
- maths: on_demand
Your first session is free. No card.
// watch_the_model_learn
You don’t read about over-fitting. You cause it.
Concepts in ML only stick when you see them move. So we train, plot, tune and re-run in a live notebook — and when the validation curve bends the wrong way, that’s not a failure, that’s the syllabus.
- Notebooks over slides. We work in a live Jupyter or Colab notebook on a real dataset — loading it, plotting it, and watching a model train cell-by-cell rather than reading about it.
- We tune, then re-run. You change a hyperparameter, re-fit, and read the new validation curve — so concepts like over-fitting and regularisation become things you see move, not definitions.
- Maths only when it earns its place. When the gradient or the loss function matters, we drop to the whiteboard and derive it; otherwise we stay in code where it sticks.
experiments.ipynb
// the_60_minute_hour
What a real machine learning hour looks like.
The same deliberate rhythm as every session — tuned to how machine learning is actually learned.
0:00
Pick the question
What should the model predict, and how will we know it’s any good? Naming the target and the metric first keeps the hour honest — a model without an evaluation plan is just a demo.
target + metric, named first0:05
Meet the data
We load and plot before we model. Most “ML problems” turn out to be data problems — leakage, imbalance, a column that means something different than you assumed. Ten minutes here saves the hour.
plot before predict0:15
Train, read, tune
The core loop, with you executing every cell: fit a baseline, read the curves, change one thing, re-fit. You learn to interrogate a model the way practitioners do — one controlled change at a time.
one change per run0:40
Your turn at the controls
You design the next experiment alone — pick the hyperparameter, predict what the curve will do, run it, and defend your reading of the result while I watch quietly.
predict, then run0:52
Save the notebook & recap
The notebook is saved runnable top-to-bottom, we restate what the experiments showed, and your written summary lands by email with one or two things to try before next time.
reproducible + summarised
// the_toolkit
Four tools. Nothing to install.
Everything runs in the browser, and everything we make stays yours afterwards.
scikit-learn first
Deep-learning frameworks come in when your goal genuinely needs them.
Real datasets
Laptop-sized and honest — no GPU required to learn the concepts.
Whiteboard, on demand
When the gradient matters, we derive it by hand — then go back to code.
// honest_answers
Machine Learning questions, answered straight.
The things people actually ask before their first machine learning session.
Do I need a GPU or a powerful laptop?
No. We learn on datasets sized for an ordinary laptop or the free tier of Colab — the concepts of training, validation, regularisation and evaluation transfer unchanged to bigger hardware later. If your own project eventually needs a GPU, the workflow we build runs on Colab’s.
How much maths do I need before starting?
Comfort with basic algebra is enough to start. When a piece of maths genuinely matters — what a gradient is, why a loss function has that shape — we derive it together on the whiteboard at the depth your goal needs: intuition for practitioners, the full working for students being examined on it.
Which libraries and frameworks do you teach?
scikit-learn is the core teaching tool because its API makes the concepts visible. NumPy and pandas underpin everything. When your goal calls for deep learning we bring in PyTorch or TensorFlow — but only once the fundamentals are solid, because frameworks change and fundamentals don’t.
Can you help with my thesis, work project or Kaggle competition?
Yes — a real project is the best possible session material. We use your dataset and your deadline, and the same honesty rule as coursework applies: I guide the method, challenge your evaluation, and debug with you, while the work itself stays yours to defend.
Is it theory-first or code-first?
Code-first, theory on demand. You’ll cause over-fitting in a notebook before you’re asked to define it, because a definition lands differently once you’ve watched the validation curve turn. The theory then has something to attach to.
// start_here
Bring a real machine learning problem.
The fastest way to understand a session is to have one. Pick the thing you’re actually stuck on and we’ll work it together — no slides, no script.
Your first session is free. No card. Cancel any time.