CMU 10-301: Introduction to Machine Learning
10-301 is CMU's undergraduate introduction to machine learning — decision trees, linear and logistic regression, neural networks and backpropagation, generalization, and learning theory basics — cross-listed with 10-601 for graduate students. It's the gateway course of the world's first machine learning department.
Fennie is independent and not affiliated with Carnegie Mellon University. This is an unofficial study guide.
Build my 10-301 study planWhat makes it hard
The homeworks demand three fluencies on the same deadline: mathematical derivation, implementation from scratch, and conceptual short-answer — and they fail on different schedules. The math prerequisites (linear algebra, probability, multivariable basics) are used without ceremony from week one, and exam questions favor 'what happens if' reasoning over recall.
What you'll cover
- • Decision trees and k-NN
- • Linear and logistic regression
- • Neural networks and backpropagation
- • Optimization and gradient descent
- • Generalization and overfitting
- • Learning theory basics
The 10-301 study guide
How to study for CMU 10-301, step by step.
- 1
Patch the math before it's load-bearing
Matrix manipulation, gradients, and probability get used from week one without review. An honest audit in the first week — and immediate rehab of whatever's rusty — prevents every later unit from being taxed.
- 2
Re-derive lecture results cold
Following a derivation and producing one are different abilities, and homeworks test the second. After each lecture, close the notes and reproduce the key derivations from scratch.
- 3
Budget homeworks as three deadlines in one
The written math, the coding, and the conceptual questions fail on different schedules. Start the implementation earliest — debugging gradient code always takes longer than planned.
- 4
Implement small and verify numerically
When coding backprop or gradient descent, test gradients numerically on tiny examples before scaling. The habit converts invisible math bugs into visible diffs and saves entire evenings.
- 5
Practice 'what happens if' reasoning
Exams favor perturbation questions: what changes if the learning rate doubles, if a feature duplicates, if the tree grows deeper? For every model, practice predicting behavior under change, not just describing it.
- 6
Run the gauntlet on a Fennie Daily Plan
Upload the 10-301 syllabus and Fennie paces derivation practice and homework milestones to the deadlines, with quizzes generated from the actual course materials in the what-if style the exams favor. Free to start.
Start my 10-301 plan free
How Fennie helps with 10-301
Fennie's Daily Plans pace 10-301's triple-threat homeworks — math, code, and concepts on one deadline — with derivation practice scheduled daily and milestones set per assignment. Chat through a stuck gradient derivation or why a model overfits, building the what-if reasoning the exams favor over recall.
FAQ
Is 10-301 hard?
It's a serious course from the department that invented the field: homeworks combine derivations, from-scratch implementation, and conceptual questions, and the math prerequisites are load-bearing from day one. Students with honest linear algebra and probability foundations who start homeworks early do well.
What's the difference between 10-301 and 10-601?
They're the same course cross-listed — 301 for undergraduates, 601 for graduate students — sharing lectures and material. Enroll under whichever number matches your status; the content and the workload folklore are identical.
What should I know before 10-301?
Linear algebra (21-241 level), probability, multivariable calculus basics, and solid Python. The course rebuilds ML from first principles, but it assumes the math underneath is frictionless — rusty foundations are the most common source of struggle.
Pass 10-301 with a plan, not a cram
Upload your 10-301 materials and Fennie generates a Daily Plan paced to your deadline — plus chat, flashcards, and quizzes built from the actual course content.
Get started freeMore CMU courses
15-112 — Fundamentals of Programming and Computer Science
15-112 is CMU's famous fast-paced introduction to programming in Python — control flow, functions, data structures, recursion, OOP, and efficiency — ending in an open-ended term project. Its public course website and the related CMU CS Academy platform give it a search footprint far beyond Pittsburgh.
15-110 — Principles of Computing
15-110 is CMU's gentler introduction to computing — Python programming plus computing concepts like data representation, algorithms, and the limits of computation — designed for students who aren't CS majors or who want a runway before 15-112. It's one of the largest courses on campus.
15-122 — Principles of Imperative Computation
15-122 teaches imperative programming with correctness front and center — contracts, loop invariants, and reasoning about code in the C0 teaching language before transitioning to real C — covering data structures from stacks and queues through hash tables, trees, and graphs. It's the second course of the CMU CS core.
15-150 — Principles of Functional Programming
15-150 teaches functional programming in Standard ML — types, recursion and induction, higher-order functions, and reasoning about programs as mathematical objects — alongside 15-122 in the CMU CS core. For most students it's the first time programming and proof become the same activity.