Free through lesson 3

Math for Programmers for Beginners

From exponents, logarithms, and sequences to vectors and matrices, derivatives and gradient descent, and probability and statistics. Across 30 lessons, you'll get to the point where you can read the formulas behind machine learning and algorithms and turn them into code yourself. No walls of proofs. You compute by hand first, then hand the work to NumPy, and every output shown comes from actually running the code.

Start from lesson 1 Unlock every course

Curriculum

The 30 lessons are split into 6 chapters. Working through them in order from chapter 1 is recommended, but feel free to dip into just the parts that interest you. * This is not a course full of proofs. The priority is understanding what each formula is a tool for. * Most samples run right in your browser (they use only the standard library). For lessons that need numpy or scipy, try them with python3 on your own machine.

Chapter 1 — Working with Numbers (lessons 1–5)

Reread math notation as Python code, and gather the tools for measuring growth: exponents, logarithms, and sequences. Finally, you'll run into float errors firsthand and learn to tell which digits of a number you can trust.

1

Reading Math Notation as Python

Translate variables, functions, Σ, Π, and subscripts directly into code, and pin down the gap between math's 1-based and Python's 0-based indexing.

Free
2

Exponents: Repeated Multiplication from One Level Up

See in numbers how fast 2^n grows. Verify the exponent rules with real values, and write compound interest and half-life with the same formula.

Free
3

Logarithms: Counting How Many Steps It Takes

Measure that log2(n) is "how many times you can divide by 2." See three uses: digit counts, log scales, and log-likelihood.

Free
4

Sequences and Recurrences: Loops and Recursion Are the Same Thing

Write arithmetic and geometric sequences both as a general term and as a recurrence. Confirm that sum formulas fold a loop into one line, and see why nested loops are n^2.

🔒 Basic
5

Error: Why Doesn't 0.1 + 0.2 Equal 0.3 in a float?

See what a float really is: a binary fraction. Trigger catastrophic cancellation yourself, and settle on isclose for comparisons and Decimal for money.

🔒 Basic

Chapter 2 — Linear Algebra (lessons 6–12)

Compute vectors and matrices by hand all the way through, using plain Python lists. After writing dot products, matrix multiplication, inverses, and eigenvalues yourself, you'll finally replace the same work with a single line of NumPy.

6

Vectors: Lists of Numbers and Their Length

A vector is just a list. Compute the L2 norm by hand, normalize to a unit vector, and use distance to find a nearest neighbor.

🔒 Basic
7

Vector Operations and Linear Combinations

Addition, subtraction, and scalar multiplication all work element by element. See that a linear combination is a prediction formula, and tell the elementwise product apart from the dot product.

🔒 Basic
8

Dot Products and Cosine Similarity

Confirm that the sign of the dot product tells you the angle. Rank documents by closeness with cosine similarity, which removes the effect of length.

🔒 Basic
9

Matrices, and Matrix Times Vector

A matrix is a list of lists. Verify by hand that matrix times vector is "a dot product with each row," and watch a rotation matrix move a vector.

🔒 Basic
10

Matrix Multiplication Is Composing Transformations

Write matrix multiplication as a triple loop and learn the shape rules. Confirm that the order of multiplication changes the answer, and see what the identity matrix does.

🔒 Basic
11

Inverse Matrices and Systems of Linear Equations

Build a 2x2 inverse by hand and see that a determinant of 0 means no unique solution. Write Gaussian elimination and run into an ill-conditioned problem.

🔒 Basic
12

Eigenvalues, Eigenvectors, and How to Write Them in NumPy

Look for vectors whose direction doesn't change when multiplied by a matrix. Work through the characteristic equation and power iteration by hand, then hand the same calculation to NumPy.

🔒 Basic

Chapter 3 — Derivatives (lessons 13–18)

Start by finding slopes numerically, then work through the chain rule, partial derivatives, and gradients by hand. Finally, run gradient descent in plain Python and watch it land exactly on the least-squares answer.

13

Slope and Rate of Change: Computing Derivatives Numerically

Go from average rate of change to instantaneous slope. Measure how things break as h shrinks, and learn the fix: central differences.

🔒 Basic
14

Derivative Rules and Where They're Used

Verify the power, sum, and product rules with numerical derivatives. Learn the derivatives of exp, log, and sigmoid, and see that a slope of 0 marks the optimum.

🔒 Basic
15

Composite Functions and the Chain Rule

Follow nested functions as outer derivative times inner derivative. Compute a three-layer stack by hand and write it in the same form as backpropagation.

🔒 Basic
16

Partial Derivatives and Gradients

A partial derivative moves just one variable. Measure that the gradient, the partial derivatives lined up, points in the direction of steepest increase.

🔒 Basic
17

Running Gradient Descent by Hand

Just subtract learning rate times gradient from the parameters. Watch it on one variable, extend to two, and match the least-squares answer.

🔒 Basic
18

Learning Rate, Divergence, and Local Minima

Run the same problem changing only the learning rate. Measure divergence, how the starting point changes the answer, and how mismatched scales stall progress.

🔒 Basic

Chapter 4 — Probability (lessons 19–23)

Start from "count it and you get the answer," then move on to conditional probability, Bayes, expected value, variance, and common distributions. Each time, you'll check on the spot how seeded random simulations close in on the theoretical values.

19

Probability Basics: Count, Then Simulate

List the whole sample space and count. Watch simulations approach the theoretical value, and test for independence with a formula.

🔒 Basic
20

Conditional Probability and Bayes' Theorem

P(A|B) means "recount inside the world of B." Compute how likely a positive result from a 99%-accurate test is to be right, and see how prevalence changes the conclusion.

🔒 Basic
21

Expected Value and Variance

Expected value is the sum of "value times probability." Confirm with simulation that it converges, and see that the two variance formulas agree.

🔒 Basic
22

Common Distributions: Bernoulli, Binomial, Poisson

0 or 1, k out of n, how many per unit time. Compute three distributions and measure how big a difference chance alone can produce.

🔒 Basic
23

The Normal Distribution and the Central Limit Theorem

Compute the shares within ±1σ, ±2σ, and ±3σ. Measure how dice averages approach a normal distribution and how the standard deviation shrinks as 1/√n.

🔒 Basic

Chapter 5 — Statistics (lessons 24–27)

Covers everything from descriptive statistics that summarize the data you have to estimation and hypothesis testing that infer the population behind it. You'll write a permutation test yourself to get a p-value, and finish by solving correlation and regression with the least-squares formula.

24

Descriptive Statistics: Mean, Median, Variance

See how outliers drag the mean around. Learn the difference between dividing by n and by n-1, and use quartiles as a rule of thumb for outliers.

🔒 Basic
25

Samples, Populations, Standard Error, and Confidence Intervals

The sample mean wobbles every time. Estimate that wobble with the standard error, build 1,000 95% confidence intervals, and measure the coverage.

🔒 Basic
26

Hypothesis Testing and p-Values

Write a permutation test yourself to get a p-value. See how p changes with effect size, and measure the danger of multiple comparisons.

🔒 Basic
27

Correlation and Regression

See that the correlation coefficient has the same form as a normalized dot product. Fit a line with the least-squares formula and confirm that R^2 is the correlation squared.

🔒 Basic

Chapter 6 — Wrapping Up (lessons 28–30)

Build 4 classic cases of misreading numbers yourself, so you learn firsthand where judgment goes wrong. Finally, practice turning formulas from papers and docs into code, and get a map of which courses to take next.

28

Common Misreadings: Traps with Averages, Rates, and Correlation

Simpson's paradox, the averaging illusion, spurious correlation, and averaging rates. Reproduce four traps with real numbers.

🔒 Basic
29

Reading Formulas and Turning Them into Code

Copy MSE, softmax, standardization, and cross-entropy into Python just as the formulas are written. Also learn how to fix the spots that break when written naively.

🔒 Basic
30

Review and Where to Go Next

Chain least squares, gradient descent, and confidence intervals into one program. Verify a cheat sheet of tools, and sort out which course uses which.

🔒 Basic

Once you finish all 30 lessons, it's time to be the one using these tools. Work with data in Python & Machine Learning for Beginners, look inside the training loop in PyTorch & Deep Learning for Beginners, measure complexity in Algorithms for Beginners, and connect numbers to decisions in Practical Data Analysis Course. Each one picks up where this course leaves off. A membership unlocks every course.