How to learn Artificial intelligence
This curriculum takes you from zero AI knowledge to a deep, technical understanding of modern artificial intelligence across four carefully sequenced stages. Each stage builds on the last — first developing intuition and vocabulary, then mathematical and algorithmic foundations, then deep learning mastery, and finally frontier research topics and critical perspectives.
Foundations & Big Picture
New to itUnderstand what AI is, where it came from, why it matters, and develop an intuitive mental model of how machines can appear to think — without needing any math or code.
▸ Study plan for this stage
Pace: 4–5 weeks, ~25–30 pages/day, reading 5 days per week — The Alignment Problem is ~400 pages of narrative-driven prose, so a relaxed daily pace keeps comprehension high for a beginner.
- The Alignment Problem itself: the core challenge of making AI systems do what humans actually intend, not just what they are literally told or rewarded for
- Reward hacking and specification gaming: how AI agents exploit loopholes in their objective functions, producing unintended and sometimes dangerous behavior
- Supervised learning and training data: how machines learn patterns from labeled examples, and why the quality, diversity, and bias of that data shapes everything the model does
- Reinforcement learning basics: agents, environments, rewards, and policies — the intuitive loop by which AI systems learn through trial and feedback
- Value alignment and human values: why encoding nuanced human preferences into a mathematical objective is extraordinarily difficult, and what goes wrong when it fails
- AI safety as a field: the distinction between near-term harms (bias, misuse) and long-term existential concerns, and why researchers treat both seriously
- The role of human feedback: how techniques like RLHF (Reinforcement Learning from Human Feedback) attempt to ground AI behavior in human judgment
- Historical arc of AI: key milestones Christian weaves through the narrative — from early rule-based systems to modern deep learning — and how each era introduced new alignment challenges
- In your own words, what IS the alignment problem? Give a concrete real-world example drawn from the book where an AI system pursued its objective in a way its designers did not intend.
- What is 'reward hacking,' and why does it emerge even when engineers design reward functions carefully and in good faith?
- How does the quality and composition of training data influence what values and biases an AI system learns? What examples does Christian use to illustrate this?
- What is the difference between an AI system that is *capable* and one that is *aligned*? Why does increasing capability without alignment make the problem more urgent, not less?
- How does Christian distinguish between near-term AI harms (e.g., biased hiring algorithms, facial recognition errors) and longer-term safety concerns? Do you find his framing convincing — why or why not?
- After reading the book, how would you explain to a non-technical friend why 'just program it to do the right thing' is not a simple solution to the alignment problem?
- **The Misaligned Robot Exercise:** Think of three everyday human instructions (e.g., 'clean my house,' 'win the game,' 'make me happy') and write down at least two ways a literal-minded AI could technically satisfy each instruction while completely missing the point. This builds intuition for specification gaming.
- **Personal Value Audit:** List 10 values you hold (e.g., fairness, honesty, privacy). Then try to write a simple rule or scoring system that captures each one. Notice where the rules break down or conflict — this mirrors the challenge engineers face when encoding human values into objective functions.
- **News Hunt:** Find two recent news articles about AI systems behaving unexpectedly or causing harm (bias in hiring tools, content moderation failures, chatbot misbehavior). Map each story onto a concept from The Alignment Problem: Is it a data problem? A reward problem? A specification problem? Write a short paragraph connecting the article to the book.
- **Chapter Concept Map:** After finishing each major section of the book, draw a simple diagram (on paper or a tool like Miro or Excalidraw) connecting the key idea of that section to at least one real-world AI system you've heard of. By the end, you'll have a visual map of the whole book.
- **The 'What Should It Optimize For?' Challenge:** Pick a familiar app or service (a social media feed, a navigation app, a music recommender). Write down what you think it is *actually* optimizing for vs. what you *wish* it optimized for. Reflect on how that gap relates to Christian's central thesis.
- **Reflective Reading Journal:** Keep a running document where, after each reading session, you write 2–3 sentences answering: 'What surprised me?' and 'What question does this raise that the book hasn't answered yet?' Review the full journal when you finish — your unanswered questions will guide your learning in future stages.
Next up: The Alignment Problem gives you a vivid, story-driven sense of *what* can go wrong and *why* it matters — the next stage will open the hood on *how* AI systems actually work mechanically, giving you the technical vocabulary to engage with those risks at a deeper level.
A lucid, jargon-free tour of AI's core ideas, history, and limitations written by an active researcher. The perfect first book to build honest intuition before diving into technical detail.
Tells the story of modern machine learning through the lens of making AI safe and beneficial. Reading it second grounds your intuition in real systems and real stakes, motivating everything that follows.
Mathematical & Algorithmic Foundations
New to itAcquire the essential math (linear algebra, probability, calculus intuition) and classical AI algorithms needed to understand how learning systems actually work under the hood.
▸ Study plan for this stage
Pace: 8–10 weeks, ~20–25 pages/day, 5 days/week — work through "Mathematics for Machine Learning" in three natural phases: Part 1 (Chapters 1–5, Mathematical Foundations: ~weeks 1–4), Part 2 (Chapters 6–9, Central Machine Learning Problems: ~weeks 5–7), and a review/consolidation week (~weeks 8–10) to rev
- Linear algebra essentials: vectors, matrices, matrix multiplication, inverses, and determinants (Ch. 2)
- Vector spaces, linear independence, basis, rank, and orthogonality (Ch. 2–3)
- Matrix decompositions: eigendecomposition, SVD, and their geometric interpretations (Ch. 4)
- Multivariate calculus: gradients, partial derivatives, the chain rule, and Jacobians/Hessians (Ch. 5)
- Probability theory: random variables, distributions, joint/conditional probability, Bayes' theorem, and expectation/variance (Ch. 6)
- Continuous optimization: gradient descent, convexity, Lagrange multipliers, and constrained optimization (Ch. 7)
- Linear regression as a foundational ML problem: least-squares, maximum likelihood estimation, and Bayesian perspectives (Ch. 9)
- Dimensionality reduction via PCA: variance maximization, projection, and the role of SVD (Ch. 10)
- Given a system of linear equations, how do you determine whether a unique solution exists, and what role does the matrix rank play in that determination?
- What does an eigenvector/eigenvalue pair tell you geometrically about a linear transformation, and why does this matter for PCA and SVD?
- How does the chain rule extend to multivariate functions, and why is it the mathematical backbone of backpropagation in neural networks?
- What is the difference between a frequentist and a Bayesian interpretation of probability, and how does Bayes' theorem update a prior belief given new data?
- Why does gradient descent work, and under what conditions (e.g., non-convexity, learning rate choice) can it fail to find a global minimum?
- How does Principal Component Analysis use the covariance matrix and SVD to reduce dimensionality while preserving maximum variance?
- Implement matrix operations (multiplication, inverse, determinant) from scratch in Python using only NumPy arrays — then verify against NumPy's built-in functions to build intuition for what the library is doing under the hood.
- Manually compute the eigendecomposition of a small 2×2 and 3×3 matrix by hand, then visualize the eigenvectors overlaid on the original data cloud using Matplotlib to see the geometric meaning.
- Code a simple multivariate gradient descent optimizer from scratch (no ML libraries) and apply it to minimize a quadratic bowl function, experimenting with different learning rates to observe convergence vs. divergence.
- Derive and implement ordinary least-squares linear regression using the closed-form normal equations (X^T X)^{-1} X^T y, then compare results with gradient-descent-based regression on a small dataset.
- Implement PCA from scratch using SVD on a real dataset (e.g., the Iris dataset): center the data, compute the covariance matrix, extract principal components, project the data, and plot the 2D result.
- Work through every end-of-chapter exercise in Parts 1 and 2 of the book, writing out solutions by hand before checking — pay special attention to the probability chapter (Ch. 6) proofs involving Bayes' theorem and Gaussian distributions.
Next up: Mastering these mathematical and algorithmic foundations — especially optimization, probability, and linear algebra — provides the precise vocabulary and mechanical intuition needed to understand how modern machine learning models (neural networks, SVMs, decision trees) are designed, trained, and analyzed in the next stage.
A freely available, rigorous yet accessible textbook covering exactly the linear algebra, probability, and calculus that underpin every modern AI algorithm. Start here to remove math anxiety.
The definitive AI textbook used in universities worldwide. Read after the math primer — it covers search, logic, planning, probabilistic reasoning, and learning with the depth needed to call yourself fluent in classical AI.
Machine Learning & Deep Learning
Some backgroundMaster the theory and practice of machine learning and neural networks, from linear models through convolutional and recurrent networks, and be able to build and train real models.
▸ Study plan for this stage
Pace: 16–20 weeks total, divided across three books: Book 1 ("The Hundred-Page Machine Learning Book") — 2–3 weeks, ~20–25 pages/day (it's concise but dense; re-read sections as needed); Book 2 ("Deep Learning" by Goodfellow) — 6–8 weeks, ~15–20 pages/day (theory-heavy; slow down for math-intensive chapte
- Supervised, unsupervised, and semi-supervised learning paradigms — the taxonomy Burkov lays out in Chapter 1 as the foundation for everything that follows
- Bias–variance tradeoff, regularization (L1/L2), and model selection via cross-validation, covered rigorously in Burkov and revisited with code in Géron
- Core classical algorithms — linear/logistic regression, SVMs, decision trees, random forests, and gradient boosting — their math in Burkov and Goodfellow, their scikit-learn implementations in Géron
- The mathematics of neural networks: forward propagation, loss functions, backpropagation, and the chain rule, developed formally in Goodfellow Chapters 6–8
- Optimization algorithms — SGD, momentum, RMSProp, Adam — and the practical challenges of training deep networks (vanishing/exploding gradients, learning rate schedules), covered in Goodfellow Chapter 8 and applied in Géron
- Regularization for deep networks: dropout, batch normalization, early stopping, and data augmentation, as treated in Goodfellow Chapter 7 and demonstrated in Géron's Keras chapters
- Convolutional Neural Networks (CNNs) — architecture intuition (filters, pooling, receptive fields), landmark models (LeNet, VGG, ResNet, Inception), and transfer learning, detailed in Goodfellow Chapter 9 and hands-on in Géron Chapters 14
- Recurrent Neural Networks, LSTMs, and GRUs for sequential data — the vanishing gradient problem in RNNs and how gating mechanisms solve it, covered in Goodfellow Chapter 10 and implemented in Géron Chapter 15
- After reading Burkov's concise treatment, can you explain the bias–variance tradeoff in your own words and describe two concrete techniques to reduce each type of error?
- Goodfellow dedicates chapters to optimization: what are the key differences between SGD, Adam, and RMSProp, and in what scenarios would you prefer one over another?
- Can you derive, step by step, how backpropagation uses the chain rule to compute gradients in a multi-layer network, as formalized in Goodfellow Chapters 6–8?
- Having worked through Géron's CNN chapters, can you explain why convolutional layers are more parameter-efficient than fully connected layers for image data, and implement a CNN in Keras from scratch?
- What problem do LSTMs solve compared to vanilla RNNs, and how do the input, forget, and output gates mechanically address the vanishing gradient problem?
- After completing all three books, can you describe an end-to-end ML pipeline — from raw data through feature engineering, model selection, training, regularization, and evaluation — and implement it using scikit-learn and TensorFlow/Keras?
- Burkov sprint (Weeks 1–3): After each chapter of 'The Hundred-Page Machine Learning Book', write a one-page summary in your own words. Then implement every algorithm mentioned (linear regression, logistic regression, SVM, k-means) from scratch in NumPy — no sklearn — to force engagement with the math.
- Goodfellow math drills (Weeks 4–11): For each of Chapters 6, 7, and 8, work through the derivations on paper. Specifically, manually derive the backpropagation update equations for a 2-layer network, then verify your result by comparing numerical gradients (finite differences) against your analytical gradients in code.
- Géron code-along with extensions (Weeks 12–19): Run every Jupyter notebook from the book's official GitHub repo, but don't just execute — after each chapter, add one extension: try a different optimizer, swap in a different regularization technique, or change the architecture, and record what improves or degrades performance.
- CNN transfer learning project: Using Géron Chapter 14 as a guide, take a pretrained model (e.g., ResNet50 via Keras Applications), fine-tune it on a small custom image dataset (e.g., from Kaggle), and document the effect of freezing vs. unfreezing different numbers of layers on validation accuracy.
- RNN/LSTM time-series project: Implement the sequence modeling examples from Géron Chapter 15 on a real dataset (e.g., weather or stock data). Compare a vanilla RNN, an LSTM, and a GRU on the same task, plotting training curves and final test metrics for each.
- Concept consolidation — teach-back sessions: After finishing each book, record a 10-minute verbal explanation (or write a blog-post draft) of the three concepts you found hardest. Use only your own words and diagrams — no copying from the text. This forces retrieval practice and reveals remaining gaps.
Next up: Mastering the supervised learning foundations, deep network architectures, and hands-on training workflows in these three books equips the reader with the mental models and practical skills needed to tackle more specialized and cutting-edge topics — such as attention mechanisms, Transformers, generative models, and reinforcement learning — which build directly on the CNN, RNN, and optimization con
A concise but surprisingly complete survey of machine learning algorithms and concepts. Its brevity makes it the ideal bridge between the broad AIMA textbook and the deep-learning-focused books that follow.
The canonical graduate-level textbook on deep learning, covering everything from backpropagation to generative models. Reading it third in this stage ensures you have the ML vocabulary to absorb its rigorous treatment.
Pairs theory with practical, runnable code. Reading it alongside or just after Goodfellow converts abstract knowledge into working skills — essential for true deep understanding.
Frontier Topics & Critical Perspectives
Going deepEngage with the cutting edge — large language models, reinforcement learning, and the profound philosophical and societal questions that define where AI is headed.
▸ Study plan for this stage
Pace: 3–4 weeks, ~20–25 pages/day (the book is ~200 pages of core text); read each chapter twice — once for comprehension, once to annotate arguments and counterarguments
- The 'gorilla problem' — why a species that creates a more powerful intelligence may lose control of its future
- Standard Model of AI vs. the new model: machines that optimize fixed objectives vs. machines that are uncertain about human preferences
- Provably beneficial AI: the three core principles (altruistic, uncertain, deferential) and why uncertainty is the key safety ingredient
- Inverse Reward Design and Cooperative Inverse Reinforcement Learning (CIRL) as technical mechanisms for value alignment
- The alignment problem: why specifying human values precisely enough for an optimizer is extraordinarily hard
- Instrumental convergence: why almost any sufficiently capable AI will develop sub-goals like self-preservation and resource acquisition regardless of its terminal goal
- Societal and geopolitical risks: concentration of AI power, autonomous weapons, surveillance, and economic disruption
- Russell's policy proposals: international governance, off-switches, and the role of uncertainty in keeping AI corrigible
- In Russell's framework, why is a machine that is *certain* about human preferences more dangerous than one that is uncertain, and how does that uncertainty enable corrigibility?
- What is the 'standard model' of AI that Russell critiques, and what specific failure modes does optimizing a fixed objective produce (e.g., reward hacking, side effects)?
- Explain instrumental convergence in your own words: what convergent sub-goals does Russell identify, and why do they emerge across wildly different terminal goals?
- How does Cooperative Inverse Reinforcement Learning (CIRL) differ from classical reinforcement learning, and why does Russell argue it is a more principled foundation for safe AI?
- What are Russell's three principles for beneficial machines, and how does each principle address a distinct failure mode of the standard model?
- What governance and policy interventions does Russell advocate for, and what does he see as the limits of purely technical solutions to AI safety?
- **Argument mapping:** After finishing each major section of *Human Compatible*, draw a one-page argument map — identify Russell's central claim, his supporting premises, the objections he anticipates, and his rebuttals. Compare maps across sections to trace how the argument builds.
- **Rewrite the objective:** Choose a real-world AI application (e.g., a content recommendation system or a hiring algorithm). Write out its implicit fixed objective, then identify at least three ways an optimizer could satisfy that objective while violating the spirit of human intent — this is Russell's 'specification gaming' problem made concrete.
- **CIRL thought experiment:** Design a toy two-agent scenario (human + robot) and write out in plain language what the robot's belief distribution over human preferences looks like before and after observing one human action. Trace how the robot's behavior should change as it updates — this internalizes the CIRL loop.
- **Debate both sides:** Write two 300-word position statements — one defending Russell's claim that AI poses an existential-level risk, and one offering the strongest possible counterargument. Use only evidence and reasoning grounded in *Human Compatible* for the pro-Russell side.
- **Policy brief:** Draft a one-page policy memo to a fictional national AI oversight body. Drawing on Russell's governance proposals, recommend three concrete regulatory measures, explain the technical rationale behind each, and acknowledge the geopolitical obstacles Russell himself raises.
- **Concept connection journal:** Keep a running log as you read: each time Russell references a concept from earlier AI study (e.g., utility functions, Markov decision processes, reinforcement learning), write two sentences connecting his critique to the foundational idea — this consolidates the full curriculum arc.
Next up: Mastering Russell's critique of the standard model and his alignment framework gives the reader the philosophical vocabulary and technical intuition needed to engage with primary research literature — papers, preprints, and technical reports — on large language models, RLHF, and AI governance, the natural frontier beyond a structured reading curriculum.
The definitive text on RL, the paradigm behind AlphaGo and ChatGPT's fine-tuning. Placed here because it requires comfort with probability and neural networks built in earlier stages.
Russell — co-author of AIMA — makes a rigorous case for rethinking AI's foundational objectives. A fitting capstone that connects technical mastery to the deepest open questions in the field.