Every machine learning algorithm is a bet — a set of assumptions about structure hidden in data. We learn to make those bets consciously, derive them mathematically, and ask who bears the cost when they're wrong.
Machine learning algorithms are not mathematical facts of nature. They are choices — choices about what to optimize, what to measure, whose data counts. We learn the math and the politics simultaneously. You cannot do one without the other.
Import sklearn. Call .fit(). Get accuracy. Submit homework. Graduate. Never understand what the library is actually doing. Never ask who designed these defaults and why.
Derive the loss function. Implement the gradient update from scratch. Then use the library knowing what it's doing. Then ask: what are the assumptions baked into this algorithm, who does it serve when it's right, and who does it harm when it's wrong?
You implement linear regression before you touch scikit-learn. You derive backprop before PyTorch. Amy Ko's research: reading before writing creates more robust, transferable learning.
Three tracks share core concepts, diverge on depth. Novice: visual intuition + Colab notebooks. Builder: NumPy implementations. Architect: full mathematical derivations + research papers.
Amy Ko: "Understanding ML means understanding uncertainty." Every model is uncertain. Every prediction has a confidence interval. We learn to communicate uncertainty, not pretend it doesn't exist.
Adapted from Jeff Anderson's ungrading practice: you assign your final grade with evidence from your portfolio. Grades are tools for self-assessment, not performance metrics for the instructor's comfort.
All three tracks cover the same core ML concepts every week. They diverge on project depth, mathematical rigor, and tooling. You self-select your track. You can move up at any point. Jeff Anderson's rule applies: spend as much time as possible at the edge of your productive struggle.
You'll use real-world datasets that connect to issues you care about — community health, education, housing, music. You'll learn each algorithm through a concrete problem, visualizing what the model is learning before writing a line of sklearn. Amy Ko's principle: read and understand before you write and execute.
You implement every algorithm from scratch before using the library version. The rule is immutable: you cannot call sklearn.linear_model.LinearRegression() until your NumPy version passes unit tests. You'll see the abstraction layer and understand exactly what it's hiding.
You engage with the mathematical foundations directly. Proofs, derivations, and published research papers are the currency. You'll implement autograd, understand PAC learning theory, and engage critically with current research on fairness and robustness. Amy Ko: "studying computing requires human-centered methods — even for theory."
These are the foundational concepts we master across all 18 weeks. Every algorithm we study is a variation on these themes. If you understand these deeply, you can learn any new ML technique in days.
Every learning algorithm is an optimization problem. The loss function is the compass. We study MSE, cross-entropy, hinge loss — not as recipes but as choices that encode assumptions about the world.
The engine of learning. From batch to stochastic to mini-batch. Convergence guarantees. Adaptive methods. We build intuition first, then rigor. You'll understand why Adam works before you use it.
The central tension of all statistical learning. Underfitting, overfitting, regularization. Understanding why regularization works is more valuable than knowing how to call it.
Why do we minimize MSE for regression and cross-entropy for classification? Because they're the same thing: maximum likelihood estimation under different distributional assumptions. This unifies everything.
All of ML is probability. Bayes, conditional independence, the generative vs. discriminative distinction. Ko: "understanding ML means understanding uncertainty." We make uncertainty visible, not hidden.
Often the highest-leverage skill in applied ML. What you feed the model matters more than which model you choose. And what features exist in a dataset encodes who was worth measuring.
Accuracy is a lie when classes are imbalanced. We study precision, recall, AUC, calibration, and fairness metrics — understanding why they conflict mathematically and ethically.
Universal approximation, but at a cost. Backpropagation, activation functions, architectures. We implement from scratch before PyTorch. The abstraction is earned, not given.
Fairness is not one thing — it's a family of mathematical definitions that are mutually incompatible. Understanding why they conflict is the most important result in the course. There is no free lunch, ethically or mathematically.
This course is designed in direct conversation with Dr. Amy Ko's 25 years of computing education research and Jeff Anderson's classroom practice. Every pedagogical choice has a justification.
Ko's research shows that teaching program reading before program writing creates more robust understanding. We apply this to ML: you analyze, trace, and critique existing algorithms before implementing them. Understanding precedes production.
Ko's work using psychometrics to study CS assessments found they often disadvantage students not because of knowledge gaps but because of assessment design. Portfolio + ungrading sidesteps this entirely — your evidence speaks, not your performance under pressure.
Ko's Gidget research: framing challenges as authentic practice (not failure) keeps learners engaged with deliberate, step-by-step process. Our "2-minute question rule" and tiered project scaffolding are direct applications of this finding.
Jeff Anderson's framework for first-generation students: the meta-skills of college — how to ask for help, form study groups, manage time, communicate with instructors — are taught explicitly, not assumed. This is part of our curriculum.
Anderson distinguishes deep learning (understanding that transfers) from surface learning (passing the test). Every course design choice — first principles, projects over exams, portfolio over grades — is oriented toward deep learning that serves you in 10 years.
Ko's research found justice-focused CS education is empowering but requires student trust and agency. We build that trust through transparent course design, flexible deadlines, and making the power dynamics of the classroom explicit. You are a co-creator, not a consumer.
We begin with the statistical foundations that unify all of ML — probability, distributions, estimation. We build upward through supervised, unsupervised, and deep learning. We end with the open problems: fairness, robustness, and alignment.
Adapted from Jeff Anderson's ungrading practice. The goal is not to perform mastery for a grade. The goal is to build real, transferable understanding you can use in 10 years. Evidence of learning — not test scores — is the currency.
A living document of your learning journey. Process over product. First attempts, failures, revised understanding — all included. Ko: "we study programming with human-centered methods." Apply that to your own learning.
You receive feedback from three sources. The instructor is the smallest source — mirroring professional practice where self-assessment and peer review are the primary quality signals.
At the end of the course, you write a final self-evaluation with evidence from your portfolio. You assign your grade. The instructor reviews and recommends. If the evidence is there, it's confirmed. This is not a trick — it's how trust-based education works.