Every symbol has a shape.

import numpy as np

X = np.arange(12).reshape(4, 3)
X.shape        # (4, 3)
X[1, 2]        # X₂,₃ is 5

Try it before reading on. Look at the matrix: its rows are examples and its columns are features. Point at an entry with $i$ and $j$ and read the NumPy expression that names it. Then point beyond the last row, and then at $0$. One of those raises an error in Python and the other does not. By the end of the chapter you will read the shape of every object in a formula, check that a product exists, and tell the minimum of a loss from the place where it is reached.

Intuition: a symbol is a promise about shape

A formula in a paper is a sentence in which every symbol makes a promise. A plain italic letter such as $x$ promises one number. A bold letter such as $\mathbf{x}$ promises a list of numbers, and the book always means a column. A capital letter such as $X$ promises a table. A calligraphic letter such as $\mathcal{X}$ promises a stack of tables. If you know the promise, you can read most of a formula without knowing what it computes: you only ask whether the pieces fit.

That is also how you find errors. A product of two tables exists only if their sizes agree in one place. A gradient has one entry for every parameter. An average needs at least one thing to average. Each of these is a check on shape or on count, and none of them needs any arithmetic.

Two decisions run through the whole book and are worth learning now, because they are where a paper and a program part ways:

• Examples are rows, features are columns. The data matrix $X\in\mathbb{R}^{n\times d}$ has $n$ rows, one per example, and $d$ columns, one per feature. An individual example $\mathbf{x}^{(i)}$ is a row of $X$ written as a column vector.
• Mathematics counts from 1, NumPy from 0. The entry in the $i$-th row and $j$-th column is written with indices $i$ and $j$ and stored at X[i - 1, j - 1]. Mixing the two conventions is the commonest way to read the right number from the wrong place.

Definition

Objects and their shapes. The set $\mathbb{R}^{d}$ is the set of columns of $d$ real numbers, $\mathbb{R}^{n\times d}$ the set of tables with $n$ rows and $d$ columns, and $\mathbb{R}^{B\times T\times d}$ the set of stacks of $B$ tables with $T$ rows and $d$ columns each. The statement $\mathbf{x}\in\mathbb{R}^{d}$ is therefore a statement about shape. NumPy writes the same facts as tuples: a vector is (d,), a matrix (n, d), a tensor (B, T, d). A NumPy vector of shape (d,) is one-dimensional; it is not a column of shape (d, 1), and the difference matters in a few operations.

Indices and positions. An entry of a matrix has two indices, $X_{ij}$. An array is stored as one long list, row by row (row-major order). In a matrix with $d$ columns, the entry with zero-based indices $(r, c)$ is at position $r\,d + c$. In a tensor with shape $B\times T\times d$, zero-based indices $(b, t, f)$ sit at position $(b\,T + t)\,d + f$. One step along the last axis moves one position, and one step along the first axis moves a whole slab.

Products and transposes. The transpose $X^{\top}$ swaps rows and columns, so an $n\times d$ matrix becomes $d\times n$. The product $AB$ of an $m\times p$ matrix and a $p\times q$ matrix exists exactly when the inner sizes match, and then its shape is the outer pair, $m\times q$. The matrix–vector product is the special case $q=1$. The product $X^{\top}X$ of a data matrix is always defined and always square, with one row and one column per feature. The elementwise product, written $\mathbf{a}\odot\mathbf{b}$, multiplies entry by entry and needs equal shapes; it is a * b in NumPy, whereas the matrix product is A @ B.

Norms. The norm $\lVert\mathbf{x}\rVert$ is a measure of size. Three are used constantly:

For every $\mathbf{x}\in\mathbb{R}^{d}$ they satisfy $\lVert\mathbf{x}\rVert_\infty\le\lVert\mathbf{x}\rVert_2\le\lVert\mathbf{x}\rVert_1\le d\,\lVert\mathbf{x}\rVert_\infty$, and each is $0$ only for the zero vector. When no subscript is written, $\lVert\mathbf{x}\rVert$ means the Euclidean norm $\lVert\mathbf{x}\rVert_2$.

Minimum against arg min. For a loss $L$, the minimum $\min_{\theta}L(\theta)$ is the smallest value the loss takes; it is a number. The arg min $\argmin_{\theta}L(\theta)$ is the set of places $\theta$ where that value is reached; it is a set, and it may have more than one element. Adding the same constant to every loss changes the minimum and leaves the arg min unchanged. NumPy’s np.argmin is a third thing again: the position, counting from $0$, of the first smallest entry of an array.

Expectation. For values $x_1,\dots,x_k$ with probabilities $p_i\ge0$ that add to $1$,

When the probabilities come from counts $c_i$, they are $p_i=c_i/(c_1+\dots+c_k)$. If every count is $0$, the division is by $0$ and there is no distribution, so the expectation is undefined; it is not $0$. The expectation is a weighted average, and it need not be one of the values: a die never shows $3.5$.

Gradient. For a function $f$ of a parameter vector $\theta\in\mathbb{R}^{d}$, the gradient $\nabla_{\theta}f$ collects one slope for each parameter, so it lies in $\mathbb{R}^{d}$ as well: the gradient has the shape of $\theta$. How such slopes are found belongs to Part III, Calculus. Here only the notation matters, together with one fact about computing: an estimate made with a small step $h$ is an approximation, written with $\approx$, and it is never exactly the gradient.

Mechanics: how to read and check a formula

Objects, indices and positions

The stage at the top of the chapter is the place to practise indices. Switch between the four kinds of object and watch the readout: the shape tuple, the number of entries, the NumPy expression for the chosen entry, its position in the flattened array and the stride along each axis (how many positions one step along that axis moves). With a vector, only one index exists; with a tensor there are three, and the picture shows one slab per example.

Three things deserve a deliberate test. First, point at the last entry of each kind of object and confirm that its position is one less than the number of entries. Second, set an index one beyond its axis and read the verdict: Python raises an error, and the stage says so instead of picking a nearby entry. Third, set an index to $0$. In mathematics that index does not exist; in NumPy a negative index is legal and counts from the end, so a program may silently read the wrong entry. The stage tells those two outcomes apart.

Do the shapes fit?

import numpy as np

X = np.ones((4, 3))
w = np.ones(3)
X @ w          # shape (4,)

Read the rule off the picture and not off a formula: for a product, put the two operands next to each other and look at the sizes that touch. When they are equal they cancel, and what remains is the shape of the answer. The preset with a mismatch shows the failure; the transposed product shows the usual repair, and the Gram preset shows why $X^{\top}X$ never fails. Note that the order matters: the product $XW$ may exist while $WX$ does not.

Three ways to measure a vector

import numpy as np

x = np.array([3, 4])
np.linalg.norm(x, ord=1)       # l1
np.linalg.norm(x)              # l2, the default
np.linalg.norm(x, ord=np.inf)  # l-infinity

The three balls differ in shape, and that is the whole idea. The norm of the vector is the factor by which the unit ball of that norm must be stretched to reach it, so the diamond, the circle and the square give three different answers for the same arrow. The chain of inequalities in the definition is visible: the square contains the circle and the circle contains the diamond. Check the preset on a coordinate axis, where all three norms agree, and the preset on a diagonal, where they are as far apart as they can be.

Minimum, arg min and the position NumPy reports

import numpy as np

thetas = np.arange(-4, 5)
L = (thetas - 2) ** 2 + 1
np.min(L)                # 1: a value
thetas[np.argmin(L)]     # 2: a parameter
np.argmin(L)             # 6: a position

Change the offset and watch which readout moves. Choose the loss with two wells and read the three results side by side: a set with two elements, a single number, and a single position. They answer three different questions, and a program that stores one of them in a variable meant for another is wrong without raising any error.

An average with weights

import numpy as np

values = np.array([1, 2, 3, 4, 5, 6])
counts = np.array([1, 2, 3, 4, 5, 6])
p = counts / counts.sum()      # p_i = c_i / total
np.average(values, weights=p)  # about 13/3

The expectation is an ordinary sum, the kind written with sigma in the previous chapter, with weights that add to $1$. Compare it with the value seen most often (the mode): they are different numbers in general, and the expectation need not be a value that ever occurs. Press the no-data preset and see that the stage will not invent a distribution.

The shape of a gradient

import numpy as np

def f(theta):
    return theta[0] * theta[0] + 3 * theta[1] * theta[1]

t1, t2 = 1.0, 2.0
theta = np.array([t1, t2])
grad = np.array([2 * t1, 6 * t2])   # exact, shape (2,)
h = 1e-3
e_j = np.array([1.0, 0.0])
(f(theta + h * e_j) - f(theta)) / h  # an estimate of grad[0]

Treat this as a preview of Part III. Nothing in the stage asks you to differentiate; it shows that the symbol $\nabla_{\theta}f$ names a column with the same number of entries as $\theta$, and that a numerical estimate is only an approximation whose error first falls and then grows as the step shrinks.

Worked examples

Each example is short enough to do by hand, and each can be checked against a stage. The numbers are not the ones in the exercises at the end of the chapter.

A batch of images. A mini-batch holds $B=32$ images, each a grid with $T=7$ rows of $d=5$ numbers. It is a tensor of shape $32\times7\times5$, and it holds $32\cdot7\cdot5=1120$ numbers. In zero-based terms the entry with batch index $b=3$, row $t=1$ and column $f=2$ is at position $(3\cdot7+1)\cdot5+2=112$. Flattening each image to a vector of length $35$ gives a matrix of shape $32\times35$ with the same $1120$ numbers.

Does the product exist? Let $X$ be $9\times4$ and $\mathbf{w}\in\mathbb{R}^{4}$. The inner sizes are $4$ and $4$, so $X\mathbf{w}$ exists and has shape $(9,)$: one number per example. Now let $\mathbf{v}\in\mathbb{R}^{9}$. Then $X\mathbf{v}$ does not exist ($4\ne9$), but $X^{\top}\mathbf{v}$ does: $(4\times9)(9)$ gives $(4,)$, one number per feature. The matrix $X^{\top}X$ is $4\times4$ and $XX^{\top}$ is $9\times9$.

Three norms. For $\mathbf{x}=(3,\,-4)^{\top}$: $\lVert\mathbf{x}\rVert_1=3+4=7$, $\lVert\mathbf{x}\rVert_2=\sqrt{9+16}=5$ and $\lVert\mathbf{x}\rVert_\infty=4$. The chain $4\le5\le7\le2\cdot4$ holds. For $\mathbf{x}=(1,1)^{\top}$ the Euclidean norm is $\sqrt2$, an irrational number that a program can only approximate; the stage keeps it as a radical.

Place against value. Take the loss $L(\theta)=(\theta-1)^2+5$ on the integers from $-2$ to $4$. The smallest value is $5$, reached only at $\theta=1$, so the minimum is $5$ and the arg min is $\{1\}$. In an array that starts at $\theta=-2$, the position that np.argmin returns is $1-(-2)=3$. Adding $10$ to the loss makes the minimum $15$ and leaves $\{1\}$ and the position $3$ untouched.

An expectation from counts. A spinner showed $1$ twice, $2$ once and $4$ once. The total is $4$, the probabilities are $\tfrac12,\tfrac14,\tfrac14$, and $\mathbb{E}[X]=\tfrac12\cdot1+\tfrac14\cdot2+\tfrac14\cdot4=2$. Doubling every count changes nothing, since the probabilities are the same.

Executable reference code

Run the Python examples below to follow the calculations step by step. The comments record what each line returns.

First shapes, indices, positions and products: a vector, a data matrix, a tensor, the conversion between mathematical and NumPy indices, the flattened position of an entry, the transpose, matrix products with their shapes, and the error raised when the inner sizes disagree.

import numpy as np

# Conventions: a vector is a column of d numbers; a data matrix X has n EXAMPLES as rows and d FEATURES as columns.
# Mathematics counts from 1 (X_{ij}, i = 1..n, j = 1..d); NumPy counts from 0, so X_{ij} is X[i - 1, j - 1].
X = np.arange(12).reshape(4, 3)  # n = 4 examples, d = 3 features; the entry in row r, column c is 3 * r + c
x = np.array([2.0, -1.0, 0.5])  # a vector in R^3
w = np.array([1.0, 0.0, -1.0])
W = np.arange(6).reshape(3, 2)
a = np.array([1.0, 2.0, 3.0])
b = np.array([4.0, 5.0, 6.0])
X3 = np.arange(24).reshape(2, 3, 4)  # a tensor: B = 2 examples, T = 3 positions, d = 4 features

n = X.shape[0]  # the number of examples (rows)
d = X.shape[1]  # the number of features (columns)
B, T, d3 = X3.shape
shape_vector = x.shape  # (3,): a one-dimensional array, NOT a column (3, 1)
shape_matrix = X.shape  # (4, 3)

i, j = 2, 3  # a mathematical (1-based) example number and feature number
entry = X[i - 1, j - 1]  # X_{2,3} is X[1, 2] = 3 * 1 + 2 = 5
row = X[i - 1, :]  # the whole example i, a vector with d = 3 entries
column = X[:, j - 1]  # the whole feature j, a vector with n = 4 entries
flat_position = int(np.ravel_multi_index((i - 1, j - 1), X.shape))  # row-major: (i - 1) * d + (j - 1) = 5
same_entry = X.ravel()[flat_position] == entry  # True: the flattened array lists row 1 first, then row 2, ...

Xt = X.T  # the transpose swaps the axes: shape (3, 4)
Xw = X @ w  # (4 x 3)(3) -> (4,): one number per example
XW = X @ W  # (4 x 3)(3 x 2) -> (4, 2)
G = X.T @ X  # (3 x 4)(4 x 3) -> (3, 3): one row and one column per feature
dot = a @ b  # the dot product: 1*4 + 2*5 + 3*6 = 32.0, a scalar
hadamard = a * b  # the elementwise product, written with a circled dot in the notation
indicator = (x > 0).astype(int)  # the indicator 1[x_j > 0], entry by entry

try:
    X @ np.ones(4)  # X has d = 3 columns but this vector has 4 entries: the inner dimensions differ
    mismatch = 'no error'
except ValueError:
    mismatch = 'ValueError'

element_of_tensor = X3[1, 2, 3]  # the last element: 1 * 12 + 2 * 4 + 3 = 23
tensor_slice_shape = X3[1].shape  # one example of the batch: (3, 4), T positions with d features each

indices = []
for i in range(1, n + 1):  # the mathematical index range 1, ..., n; the matching row is X[i - 1]
    indices.append(int(X[i - 1, 0]))

print(shape_vector, shape_matrix, int(entry), row.tolist(), column.tolist(), flat_position, bool(same_entry))
print(Xt.shape, Xw.tolist(), XW.shape, G.shape, float(dot), hadamard.tolist(), indicator.tolist(), mismatch)
print(n, d, B, T, d3, int(element_of_tensor), tensor_slice_shape, indices)

Then norms and the three meanings of minimum: the three norms with the chain of inequalities, the Euclidean norm of a vector whose length is not a whole number, and min, argmin and np.argmin told apart on a table with a tie.

import math
from fractions import Fraction

import numpy as np

# Norms. For x = (3, 4) every norm is a whole number; for (1, 1) the l2 norm is sqrt(2), an irrational number that no double stores exactly.
x = np.array([3.0, 4.0])
l1 = np.linalg.norm(x, ord=1)  # |3| + |4| = 7
l2 = np.linalg.norm(x)  # sqrt(3**2 + 4**2) = 5
linf = np.linalg.norm(x, ord=np.inf)  # max(|3|, |4|) = 4
chain = bool(linf <= l2 <= l1)  # ||x||_inf <= ||x||_2 <= ||x||_1 for every vector

# The same l2 norm exactly: the squared norm is a rational number, and an integer square root decides whether the norm is rational.
sum_of_squares = Fraction(3) ** 2 + Fraction(4) ** 2
root = math.isqrt(25)
exact_l2 = Fraction(root) if root * root == sum_of_squares else None  # Fraction(5, 1)
diagonal = np.linalg.norm(np.array([1.0, 1.0]))  # 1.4142135623730951, the nearest double to sqrt(2)
diagonal_squared_is_two = diagonal * diagonal == 2.0  # False: squaring the rounded root does not return exactly 2

# arg min versus min. The loss on a grid of candidate parameters: L(theta) = (theta**2 - 1)**2 + 1 has TWO minimisers, -1 and 1.
thetas = np.arange(-4, 5)
L = (thetas**2 - 1) ** 2 + 1
best_value = np.min(L)  # the minimum VALUE: 1
best_position = int(np.argmin(L))  # the 0-based POSITION of the FIRST minimum: 3
best_theta = thetas[np.argmin(L)]  # the parameter at that position: -1 (the other minimiser, 1, is not reported)
all_minimisers = thetas[L == best_value].tolist()  # [-1, 1]: argmin as a SET
p = np.array([0.1, 0.5, 0.4])
most_likely = int(np.argmax(p))  # the position of the largest entry: 1

# Conventions: log is the natural logarithm; bits need log2.
nats = np.log(math.e)  # 1.0
bits = np.log2(8.0)  # 3.0

print(float(l1), float(l2), float(linf), chain, exact_l2, float(diagonal), diagonal_squared_is_two)
print(int(best_value), best_position, int(best_theta), all_minimisers, most_likely, float(nats), float(bits))

Finally the notation of averages, sums over an axis and the gradient: an expectation from counts with exact fractions, the failure of the division by zero, a conditional probability as a ratio, sums along each axis, and a finite difference that only approximates the gradient.

from fractions import Fraction

import numpy as np

# Expectation of a finite distribution: E[X] = sum_i p_i x_i, with p_i >= 0 and sum_i p_i = 1.
# Counts become probabilities by dividing by their total: p_i = c_i / sum(c). The division is the taught step, and it is only defined for a non-zero total.
values = np.array([1, 2, 3, 4, 5, 6])  # the faces of a die
counts = np.array([1, 2, 3, 4, 5, 6])  # how often each face was seen
p = counts / counts.sum()  # 1/21, 2/21, ..., 6/21 (floating point)
sum_of_p = float(p.sum())  # about 1.0
expectation = np.average(values, weights=p)  # sum(p * values): about 13/3 = 4.333...
exact_p = [Fraction(int(c), int(counts.sum())) for c in counts]
exact_expectation = sum(pi * int(v) for pi, v in zip(exact_p, values))  # Fraction(13, 3), exact
exact_sum_of_p = sum(exact_p)  # Fraction(1, 1)

fair = [Fraction(1, 6)] * 6
fair_expectation = sum(pi * int(v) for pi, v in zip(fair, values))  # Fraction(7, 2): a die never shows 3.5

try:
    Fraction(0, int(np.zeros(6).sum()))  # all counts zero: the total is 0, so there is no distribution
    zero_total = 'no error'
except ZeroDivisionError:
    zero_total = 'ZeroDivisionError'

# Probability notation as arithmetic on a small table of joint counts: P(A | B) = P(A and B) / P(B).
mask = values > 4  # the event A: the die shows more than 4
p_A = np.sum(p[mask])  # P(A) = (5 + 6) / 21
p_AB = Fraction(5, 21)  # P(A and B) with B = "the face is odd": only face 5 is odd and above 4
p_B = Fraction(1 + 3 + 5, 21)  # P(B) = 9/21
p_A_given_B = p_AB / p_B  # Fraction(5, 9)

# Sums and means over an axis, with the index convention stated: a.sum(axis=0) adds DOWN the rows.
a = np.array([[1, 2, 3], [4, 5, 6]])
total = np.sum(a)  # 21
by_column = a.sum(axis=0).tolist()  # [5, 7, 9]: one sum per column (feature)
by_row = a.sum(axis=1).tolist()  # [6, 15]: one sum per row (example)
product = np.prod(a)  # 720
mean = np.mean(a)  # 3.5

# The gradient of f(theta) = theta1**2 + 3 * theta2**2 has the SAME SHAPE as theta, and a finite difference only approximates it.
t1, t2 = 1.0, 2.0
theta = np.array([t1, t2])
grad = np.array([2 * t1, 6 * t2])  # (2, 12), exact for these values
same_shape = grad.shape == theta.shape  # True


def f(theta):
    return theta[0] * theta[0] + 3 * theta[1] * theta[1]  # the same operations, in the same order, as the stage


h = 1e-3
e_j = np.array([1.0, 0.0])  # the first coordinate direction
estimate = (f(theta + h * e_j) - f(theta)) / h  # about 2.001: close to 2 but not equal
error = float(estimate - grad[0])  # about 0.001: the step h shows up in the error

x_abs = abs(-2.5)  # |x| = 2.5
A = {1, 2, 3}
member = 2 in A  # x in A

print(float(sum_of_p), float(expectation), exact_expectation, exact_sum_of_p, fair_expectation, zero_total)
print(float(p_A), p_A_given_B, int(total), by_column, by_row, int(product), float(mean))
print(grad.tolist(), same_shape, round(float(estimate), 3), round(error, 3), x_abs, member)

Explore: the notation table

The table lists the symbols of the book with how each is read aloud, what it means, the shape of what it names, the Python that writes the same thing and where the idea is developed later. Search it by a word, narrow it by category, and use it when a later chapter shows a symbol you do not recognise. Every Python snippet marked as runnable appears in the reference code above.

These questions have definite answers; check each against the stages above.

• In the shape stage, choose a matrix with more rows than columns and point at the last entry. How many entries are there, and what is the position of the last one? Does the same hold for a tensor?
• Set the matrix index $i$ to $0$ and then to one more than the number of rows. Which of the two raises an error in Python, and why can the other be worse?
• In the product stage, find sizes for which $X\mathbf{w}$ fails but $X^{\top}\mathbf{w}$ works. What does that say about which of the two sizes is the number of examples?
• In the norm stage, find a vector for which all three norms are equal. Then find one for which the Euclidean norm is not a whole number, and read how the stage writes it.
• In the arg min stage, choose the flat bottom and read the three results. How many elements does the arg min have, and which one does np.argmin report?
• In the expectation stage, choose the fair die. Is the expectation one of the faces? Then set one count to $0$ and the others unchanged: what happens to the probability of that face?
• In the gradient stage, choose the smallest step and then the largest. Which error is smaller? Is it the smallest step that gives the best estimate?
• In the table, search for “norm” and then for a word that does not occur. What does the table say, and how do you get the full list back?

Common mistakes

Numerical considerations

Everything in the stages is exact except where it says otherwise. In a program, three habits are worth learning from the start.

Comparing two floating-point numbers with == is the same trap in a smaller setting. The Euclidean norm of $(1,1)$ is $\sqrt2$, which no double represents exactly; squaring the computed value gives a number that is close to $2$ and often not equal to it. Compare with a tolerance, as np.isclose does, or keep exact values while you can, as the stages do.

Two more habits: an average of an empty batch should be handled explicitly and reported as undefined instead of letting a division by zero propagate as nan; and a Euclidean norm squares every entry before adding, so a vector with entries near $10^{200}$ overflows to infinity even though its length is a perfectly ordinary double. np.linalg.norm([1e200, 1e200]) returns inf (with a warning), while math.hypot(1e200, 1e200), which scales before squaring, returns about $1.41\times10^{200}$.

Connections to engineering and machine learning

• Data matrices. A table of $n$ examples and $d$ features is $X\in\mathbb{R}^{n\times d}$. A model $X\mathbf{w}$ gives one prediction per example, and the first thing to check in a pipeline is that X.shape[1] equals len(w).
• Batches of sequences. A language model works on tensors of shape $B\times T\times d$: a batch, positions and features. Most shape bugs in deep-learning code are an axis in the wrong place, which is why shapes belong in comments and in assertions.
• The Gram matrix. $X^{\top}X$ is a $d\times d$ table with one row and column per feature. It reappears in least squares, in covariance and in principal components, which later parts take up.
• Regularisation. The penalties $\lVert\mathbf{w}\rVert_1$ and $\lVert\mathbf{w}\rVert_2^{2}$ are the first two norms of the weights. The diamond and the circle in the norm stage are the reason the first tends to produce zero weights and the second only small ones.
• Training is an arg min. Fitting a model means finding $\theta$ in $\argmin_{\theta}L(\theta)$. The minimum value tells you how good the fit is, the arg min tells you what the parameters are, and when the loss has a flat direction the arg min is a whole set.
• Losses are expectations. A population loss is $\mathbb{E}[\ell(\theta;X)]$ and the loss on a batch is its estimate by an average over the examples in the batch. The expectation notation is the language of Part IV, Probability, and the averages over examples are the sums of the previous chapter.
• Gradient descent. The update $\theta\leftarrow\theta-\eta\,\nabla_{\theta}L$ only makes sense because the gradient has the shape of $\theta$. When a program raises a shape error in an update, the first suspect is a gradient with a different shape.

Exercises

Answer each question and press Check. A wrong answer tells you which mistake it looks like. After one attempt you may open a worked solution.

Summary and checkpoints

• A symbol promises a shape: italic for a number, bold for a column vector $\mathbf{x}\in\mathbb{R}^{d}$, a capital for a table, a calligraphic capital for a stack of tables. The data matrix $X\in\mathbb{R}^{n\times d}$ has examples as rows and features as columns.
• Mathematics counts from $1$ and NumPy from $0$: the entry with indices $i,j$ is X[i - 1, j - 1]. Arrays are stored row by row; an entry at zero-based $(r,c)$ of a matrix with $d$ columns is at position $r\,d+c$. A negative index wraps; an index past the end raises an error.
• A product $AB$ exists when the inner sizes agree and has the outer pair as its shape. The transpose swaps the sizes. $X^{\top}X$ is always $d\times d$.
• The norms $\lVert\mathbf{x}\rVert_1$, $\lVert\mathbf{x}\rVert_2$ and $\lVert\mathbf{x}\rVert_\infty$ are three measures of size with $\lVert\mathbf{x}\rVert_\infty\le\lVert\mathbf{x}\rVert_2\le\lVert\mathbf{x}\rVert_1\le d\,\lVert\mathbf{x}\rVert_\infty$.
• The minimum is a value, the arg min is a set of places, and np.argmin is the position of the first smallest entry.
• $\mathbb{E}[X]=\sum_i p_ix_i$ with $p_i=c_i/\sum c$; it is undefined when there are no observations.
• The gradient $\nabla_{\theta}f$ has the shape of $\theta$, and a finite-difference estimate is an approximation with a best step.

Checkpoints. You can move on when you can, without the stage:

1. Say the shape of $X$, of $X^{\top}$, of $X\mathbf{w}$ and of $X^{\top}X$ for a data matrix with $n$ examples and $d$ features.
2. Convert a mathematical pair of indices to the NumPy expression and to the flattened position.
3. Decide whether a product of two shapes exists and give the shape of the result, or the two sizes that disagree.
4. State the three norms and the order of their sizes.
5. Distinguish the minimum, the arg min and np.argmin, and say which of the three changes when a constant is added to the loss.
6. Compute an expectation from counts and say when it does not exist.