Deep Learning · 75 figures

Interactive figures

Every figure in the track. Each one is a small experiment: drag, slide, and watch the numbers. The link under each figure takes you to the lesson that explains it.

Lesson 1 · MLPs and universal approximation

Fit $x^2$ with ReLU units. The aqua curve is the target $f$ ; the blue curve is the network $N$ ; the thin blue lines are its single units $c_k\operatorname{relu}(x - x_k)$ ; the violet knots set the weights; the magenta bar is the largest error. Predict first: if you double the number of units $K$ , by what factor does the largest error fall? Then move the slider from 2 to 4 to 8. Try $\sin \pi x$ , and the step, which is not continuous: its error never falls below $1/2$ . Outside $[0, 2]$ the network is a straight line.

In context: Lesson 1

Pieces multiply with depth. Move the slider $k$ . Top left: the deep network $t^{(k)}$ (blue) with $k$ hidden layers of 2 units has $2^k$ pieces. Top right: a network with one hidden layer and the same $2k$ units (grey) can have at most $2k + 1$ pieces; here it passes through $2k + 1$ points of the aqua target $t^{(k)}$ . It is exact for $k \le 2$ and then fails (largest error in magenta). Bottom: pieces against units on a log scale; the yellow line is the current $2k$ .

In context: Lesson 1

Three layers, with and without ReLU. A grid of inputs in $[-1.5, 1.5]^2$ goes through three layers $2 \to 2 \to 2 \to 2$ . With "none", the image after every layer is a grid of parallelograms, and the readout shows the single affine map that does the same job. Switch to ReLU and look at layer 1 first: the parts of the plane where a unit is negative are flattened onto an axis. The yellow segment $p$ – $q$ (drag its ends in the input view) stays straight only without ReLU; the midpoint test measures the gap between the image of the midpoint and the midpoint of the images.

In context: Lesson 1

Lesson 2 · Training a network

Train a network in your browser. Press Play (or +100 steps). The background shows the predicted class: blue for class 0, yellow for class 1, pale where the network is unsure. The chart shows the training loss and the validation loss on a log scale; at the start both are near $\log 2 \approx 0.69$ , the loss of a 50/50 guess. Then try: (1) the spiral with SGD, then with Adam, width 16 and 3 layers; (2) a learning rate above 3 with SGD: the loss stops falling or jumps around; (3) moons with noise 0.6, width 16, 3 layers, Adam, $\eta = 0.01$ , batch 32, for a few thousand steps: the training loss keeps falling while the validation loss turns up. That is overfitting.

In context: Lesson 2

Mini-batch gradients on a linear regression. The violet point is the parameter $w = (w_1, w_2)$ ; the grey ellipses are level sets of the training loss, with its minimum $w^*$ in aqua. The thick orange arrow is the full gradient step; the thin arrows are 50 mini-batch steps. Predict first: if you make $B$ four times larger, how much smaller does the spread get? Move the slider and compare with the chart, where the measured spread (dots) follows the line $\sqrt{\operatorname{tr}\Sigma / B}$ . Drag $w$ close to $w^*$ : the full gradient almost vanishes, but the mini-batch steps still scatter.

In context: Lesson 2

Find the stability limit. Move the learning rate $\eta$ . The blue parabola is the loss; the violet points are the iterates $w_0, w_1, \dots$ (magenta when they diverge). The chart shows $|w_t|$ on a log scale: a straight line with slope $\log|1 - \eta\lambda|$ . Use the presets: a small step is slow, $\eta = 1/\lambda$ jumps to the minimum in one step, between $1/\lambda$ and $2/\lambda$ it zig-zags but converges, and above $2/\lambda$ it diverges.

In context: Lesson 2

Two losses for one logit. Top: the losses, cross-entropy (solid) and squared error after a sigmoid (dashed), in blue. Bottom: their gradients $d\ell/dz$ in orange. Move $z$ into the magenta band, where the model is confidently wrong: the BCE loss grows like $|z|$ and its gradient stays near $-1$ , while the MSE loss is flat near $0.5$ and its gradient is close to 0. Switch the target to $y = 0$ to see the mirror image.

In context: Lesson 2

Lesson 3 · Backpropagation

In context: Lesson 3

Lesson 4 · Activations and initialization

Choose an activation and an initialization. A 50-layer MLP of width 200 runs on 32 random inputs, and the figure updates after each change. The top chart shows the mean square of the pre-activations (forward, blue) and of the gradients $\partial\mathcal{L}/\partial z_l$ (backward, orange) at each layer, on a log axis. The dashed aqua lines are the variance recursion of section 3. The bottom chart is the histogram of the activations $\sigma(z_l)$ at the layer you select. Try ReLU with Xavier, then with He. Then try tanh with a large gain and look at the histogram: most units are saturated.

In context: Lesson 4

Pick an activation and move the input scale $s$ . The curve is $\sigma(x)$ (blue), its derivative is $\sigma'(x)$ (orange), and the magenta band marks where $|\sigma'(x)| < 0.05$ : there the unit is saturated (or dead) and passes almost no gradient. The grey bell is the distribution of the input $z \sim N(0, s^2)$ . The panel shows the two numbers that enter the variance recursion, $\mathbb{E}[\sigma(z)^2]/s^2$ (forward) and $\mathbb{E}[\sigma'(z)^2]$ (backward). Compare tanh at $s = 0.5$ and at $s = 3$ .

In context: Lesson 4

Press Play with "identical" start, then with "identical + δ". A network with 2 inputs, 2 hidden tanh units and 1 output learns XOR by gradient descent. The plane shows, for each hidden unit, its bias $b_i$ and its outgoing weight $v_i$ during training: unit 1 (violet) and unit 2 (yellow). With an identical start the two paths lie on top of each other for ever and the loss stops near 0.67. A tiny difference δ grows until the units separate and the loss falls to 0. Smaller δ takes longer.

In context: Lesson 4

Lesson 5 · Normalization and residuals

Drag the blue dots, then press the shift and scale buttons. Row 2 (training mode, batch statistics) does not move when you shift or scale the whole batch. Now press Training step a few times. In eval mode (row 3, magenta) BatchNorm uses the running statistics $\hat\mu, \hat\sigma^2$ (the magenta band in row 1). After one step they are still far from the batch, so the same input gives a very different output. Blue = forward values computed with the batch; magenta = the train/eval mismatch.

In context: Lesson 5

Move the depth and the size $s$ . Both stacks use the same layer derivatives $a_l = \pm s$ . The plain product $\prod a_l$ has size $s^L$ : a straight line on the log axis, down for $s < 1$ and up for $s > 1$ . The residual product $\prod (1 + a_l)$ stays near 1 for small $s$ . Now choose all + and a large $s$ : the residual product grows too. The identity path helps only while the branches are small.

In context: Lesson 5

Change the depth, then switch to the residual stream. These are measurements at initialization (PyTorch encoder blocks, width 64, Xavier init, random data, mean of 5 seeds). The post-LN gradient of the last block stays near 0.35 for every depth. The pre-LN one shrinks like $1/\sqrt{L}$ : the column "pre $\cdot\sqrt L$ " stays near 0.5. In the second view, the pre-LN residual stream grows about linearly with depth, while post-LN keeps it at 1.

In context: Lesson 5

Lesson 6 · Regularization

In context: Lesson 6

Move the logit gap $\Delta$ and watch the dot on the loss curve. The left chart compares the smoothed target $q$ with the prediction $p$ . With smoothing (aqua curve), the loss has a minimum $H(q) > 0$ at a finite gap $\Delta^*$ (the dashed lines); beyond it the gradient pushes the gap back down. Without smoothing (grey) the loss keeps falling as $\Delta \to \infty$ . Set $\varepsilon = 0$ to see that case.

In context: Lesson 6

Change the number of steps and the gradient size $G$ . The chart shows how much the decay term alone shrank each weight (the run with decay minus the run without). With AdamW, both weights shrink by about $t\,\eta\lambda$ (the two aqua lines almost overlap). With Adam + L2, the weight with no gradient (solid) is pulled to 0 within about 100 steps, while the weight with large gradients (dashed) shrinks about 10 times less than under AdamW.

In context: Lesson 6

Move the number of steps $t$ . The violet path is gradient descent from 0 (the dots are steps); the aqua dashed curve is the ridge solution for all $\lambda$ , and the aqua dot is ridge with $\lambda = 1/(\eta t)$ . Both first move along the steep direction of the loss (large eigenvalue $s_1$ ) and reach $w^\star$ along the flat direction ( $s_2$ ) only later. The right chart shows the two filter factors; the dots mark $s_1$ and $s_2$ .

In context: Lesson 6

Lesson 7 · Convolutional networks

Move the yellow window over either image (hover, tap, or focus the figure and use the arrow keys). The panel shows the dot product of the kernel $W$ with the pixels under the window. Then pick another kernel or edit one entry. Notice: edge-x answers only on vertical edges, edge-y only on horizontal edges, and both are 0 where the image is constant. Output colours: blue = positive, magenta = negative. The image is padded with zeros, so the feature map has the same size, $28\times28$ .

In context: Lesson 7

Lesson 8 · RNNs and LSTMs

Step through BPTT. Press Forward step three times: each cell computes its blue state $h_t$ from the cell on its left. Then press Backward step: the orange gradient $g_t = \partial L/\partial h_t$ moves to the left, and each arrow multiplies it by $w\,(1 - h_t^2)$ . The defaults are the worked example of section 4. Now set $w = 2$ : the factors stay below 1 because large states saturate tanh. Set $w = 1.5$ and a small pulse $x_1 = 0.05$ : the factors are above 1 (magenta) and the gradient grows.

In context: Lesson 8

How far back can a gradient travel? The curves show $\|\partial h_T / \partial h_{T-n}\|_2$ against the lag $n$ , on a log axis, for a hidden state of size 16. The dashed orange curve is the linear RNN, the solid one the tanh RNN; the grey line is $\rho^n$ and the dotted line is the bound $\|W\|_2^n$ . Move $\rho$ across 1 and watch the linear curve leave the blue (vanishing) region for the magenta (exploding) one. Then raise the input scale $s$ : saturation pulls the tanh curve down, even when $\rho > 1$ . Switch to the random $W$ : now $\|W\|_2 \approx 1.7\rho$ , and the linear curve first rises before it falls.

In context: Lesson 8

The LSTM keeps a gradient alive through the forget gate. The top shows the cell at step $t$ ; the small blue bars are the values of the 8 units of each gate, and the yellow box is the forget gate. The chart shows $\|\partial c_t / \partial c_0\|_2$ in orange: solid for all paths, dashed for the cell path alone. Try $b_f = 0$ , $1$ and $3$ . The mean forget gate moves from about 0.5 to 0.74 to 0.95, and after 50 steps the gradient moves from about $10^{-10}$ to $10^{-4}$ to about 1.

In context: Lesson 8

Lesson 9 · Attention

Drag the yellow query in the left plane. The scores are dot products with the violet keys; the table shows them and their softmax weights. In the right plane the blue output $o$ is the weighted average of the grey values; the rings show the weights. Try a short query and a long query: a longer query (or a smaller temperature $\tau$ ) makes the weights nearly one-hot and the output jumps to one value. Notice that the keys decide the weights, but the values decide where the output lands.

In context: Lesson 9

The whole $T \times T$ matrix of one head, for six tokens and head size 2 (this figure is shared with linear-algebra lesson 15, which writes $d_h$ for $d_k$ and uses the column convention). Left: the scaled scores; right: the weights $A$ . Click a row to pick a query; its output is drawn as the weighted average of the values. Move the scale $\beta$ to 0: every row becomes uniform. Turn on the causal mask: the upper triangle of $A$ becomes 0.

In context: Lesson 9

Move the head size $d_k$ and switch the scaling. Top: the 16 softmax weights of one query, sorted. Bottom: the median size of the softmax Jacobian $\|J\|_F$ over many random draws, with the scaling and without it; the yellow dot is the current draw. Without scaling, a larger $d_k$ gives larger logits, one weight close to 1, and a Jacobian close to 0: almost no gradient reaches the queries and keys. With scaling, the picture is the same for every $d_k$ .

In context: Lesson 9

Lesson 10 · Positional encodings

Move the position $t$ . The heatmap shows the encodings of 64 positions (columns) in 32 dimensions (rows): orange is positive, blue is negative. The yellow column and the clock hands show position $t$ : fast pairs turn quickly, slow pairs hardly move. The chart shows the dot product of $PE(t)$ with every other position. Notice that the bump moves with $t$ but keeps its shape: the dot product depends only on the offset $s - t$ .

In context: Lesson 10

Each dot is one pair of a RoPE head; its height is the wavelength (positions per turn, log scale). Pairs above the aqua line $L$ never complete a turn in training. With $s = 4$ and no change, the magenta pairs see angles they never saw. Switch to "position interpolation": no magenta dots remain, but the fastest pair now turns only $1/s$ rad between neighbours. Switch to "base scaling": the fast pairs stay as they were and the slowest pair is slowed by exactly $s$ .

In context: Lesson 10

Lesson 11 · Transformers and ViT

Click a box (or tab to it and press Enter) to see its formula, its parameter count and its FLOPs. The blue arrows carry the residual stream; each label is the shape of the tensor on that arrow, for the batch size $B$ , length $T$ , width $D$ and heads $H$ you choose. Boxes with weights are violet; the selected box is yellow. Notice that every arrow between boxes has the same shape $(B, T, D)$ : only the inside of the attention ( $T \times T$ weights per head) and of the MLP (width $4D$ ) is different. Switch to post-LN to see where the LayerNorms move.

In context: Lesson 11

Choose the patch size $P$ and click a patch of the image. The right panel is the sequence the transformer sees: the violet [CLS] token first, then the patches in reading order. The yellow frame shows where your patch lands in the sequence. Notice how fast the token count grows when $P$ gets smaller: halving $P$ gives 4 times the tokens and about 16 times the size of each attention matrix. Switch to a $384 \times 384$ image with the same $P$ : the patches stay the same size, but there are more of them.

In context: Lesson 11

Press Next token several times. A tiny hand-made model with one attention head writes a sentence. Each step adds one row to the cache of keys and values (the new row is yellow). The bars next to the cache are the attention weights of the newest token: it reads every cached row, but it computes only its own key and value. Below the cache: the probabilities of the next token at temperature $\tau$ . Set $\tau$ near 0 (greedy) or to 2, and compare the counters "with cache" and "without cache": the second grows like $t^2$ .

In context: Lesson 11

Lesson 12 · Training dynamics

Compare the two runs. Both use the same peak learning rate. In this toy model the curvature falls from 20 to 2 during the first steps. The magenta run uses the peak learning rate from step 0: $\eta_t\lambda_t$ starts far above the dashed edge 2 and $|w_t|$ explodes. The blue run warms up linearly and stays below 2 at every step. Shorten the warmup until the blue run fails too, and find the largest constant $\eta$ that is safe without warmup.

In context: Lesson 12

Lost updates. A weight $w_0$ gets the same update $u$ for 1,000 steps. The aqua line is an fp32 master weight; the 16-bit weight is magenta when every update is lost and blue otherwise. Try u = 0.6 ulp: each update is rounded up to a full ulp and the 16-bit weight moves too fast. Then switch to loss scaling: the orange histogram shows gradient sizes; move $s$ until no gradient becomes 0 or inf (magenta), and switch to bf16 to see why it needs no scaling.

In context: Lesson 12

Lesson 13 · Graph neural networks

Press One round and watch the value spread. Node colour shows the value of the node (blue = forward values; darker = larger). The start is an impulse at one node. Click a node to select it: the yellow ring marks the nodes it can see after the rounds done so far (its $K$ -hop neighbourhood). Notice that a node stays at 0 until the number of rounds reaches its distance to the impulse. Switch to sum aggregation and see the values grow at the high-degree nodes.

In context: Lesson 13

Press Refine to run one round of colour refinement on both graphs. Colours here are 1-WL colour classes (the number in each node is the colour id); one colour table is shared by both graphs. The table below lists each colour, the signature it was made from, and how many nodes of each graph have it (counts that differ are magenta). With path vs triangle + edge, round 1 gives equal histograms (both have degrees 1, 1, 2, 2, 2), but round 2 separates them. With two triangles vs hexagon, every node keeps one colour forever: 1-WL, and so every message-passing GNN, sees no difference.

In context: Lesson 13

Move the slider $k$ (the number of applications of $\hat A$ ). The graph has three communities (blue, aqua, violet), and each node has a noisy 2-D feature. The right panel shows the features of all nodes. A few steps remove the noise inside each community and the three groups separate. Many steps push every node towards one common direction (the dashed ray), scaled by $\sqrt{\tilde d_i}$ : the nodes then differ only by their degree. The first chart splits $H$ into three parts, as fractions of $\|H\|$ on a log scale: the spread inside the communities (noise, magenta), the spread between them (signal, aqua), and the smooth part $u_1u_1^\top H$ , which carries only degree information (blue). The second chart shows the accuracy of a nearest-class-mean classifier (a linear probe) on the features: it rises from 0.75 to 1, then falls towards chance as the smooth part takes over.

In context: Lesson 13

Lesson 14 · Self-supervised learning

Drag the points on the unit circle. Each blue point is an image embedding $u_i$ and each aqua point is a text embedding $w_i$ , all of length 1. The first table is the cosine similarity $s_{ij} = u_i^\top w_j$ (darker = larger, aqua outline = matching pair); the second is the softmax of each row of $S/\tau$ (the probability that image $i$ picks caption $j$ ). Notice: with aligned pairs the diagonal wins and the loss is small; with collapsed embeddings every row is uniform and the loss is $\log N$ ; a smaller $\tau$ makes the rows sharper. The bound $\log N - \mathcal L$ never exceeds $\log 4 \approx 1.39$ .

In context: Lesson 14

Press Play to train a tiny encoder. Ten images have two noisy views each (a filled and a hollow blue dot, joined by a line); a linear encoder maps them to the unit circle. With alignment only, the two views of each image meet, but all points also slide to one spot: collapse. With alignment + uniformity, the pairs stay close and the images spread around the circle. The magenta arrow is the mean embedding $\bar z$ ; its length $R = \|\bar z\|$ is near 1 after collapse and near 0 when the embeddings are well spread.

In context: Lesson 14

Move the temperature slider. One anchor has a positive with similarity $s_+$ and seven negatives. The bars show the share of the total push that each negative gets ( $p_j$ divided by the sum over the negatives). At $\tau = 1$ the push is spread over all negatives; at $\tau = 0.05$ almost all of it goes to the hardest one. Lower $s_+$ below the hardest negative and watch $\tau\ell$ approach the hinge $\max(0, \max_j s_j - s_+)$ .

In context: Lesson 14

Move the mask ratio. The left panel is the image, cut into $14 \times 14 = 196$ patches. The middle panel is what the encoder sees: only the visible patches (masked patches are grey). The right panel fills the masked pixels by repeated averaging of neighbouring pixels: a "reconstruction" with no learning at all. Notice: at 25% masking this smooth fill is already good (relative error about 0.08), so the task teaches little; at 75% the error is about 3 times larger, and whole shapes are lost. A model must understand the picture to do better. The magenta curve is this error against the mask ratio; the readout gives the number of encoder tokens and the cost relative to the full image.

In context: Lesson 14

Lesson 15 · Mixture of experts

Drag the router vectors. Here the colors name the four experts: blue, orange, aqua and violet. Each dot is a token, colored by its first choice; the shaded regions show where each expert wins. The bars are the loads, with the capacity $C$ as a dashed line. Assignments above the capacity are dropped and shown in magenta. Try one expert wins: one expert gets most tokens and many are dropped. Then set $k = 2$ (rings show the second choice) and raise the capacity factor.

In context: Lesson 15

Press "1 descent step" a few times. The left chart shows the dispatch shares $f_i$ and the mean probabilities $P_i$ ; the aqua line is the uniform share $1/E$ . The right chart shows one token's probabilities and the orange gradient $\frac{E}{T}p_{t,j}(f_j - \bar f_t)$ on its logits: positive (pushed down) for the busy expert 1, negative for the idle ones. Watch the loss fall to about 1 as the loads become equal.

In context: Lesson 15

Lesson 16 · State-space models

Two computations, one answer. Press Next step a few times. In the recurrence view the state moves one step: $x_k = \bar a\,x_{k-1} + \bar b\,u_k$ . Switch to the convolution view: the violet kernel, flipped, sits under the blue input, with $K_0$ under $u_k$ , and $y_k$ is the sum of the products. The blue dots (recurrence) always sit inside the aqua rings (convolution). The defaults are the worked example of section 4. A larger $\Delta$ or a more negative $a$ makes the kernel shorter.

In context: Lesson 16

Poles, steps and kernels. Drag the violet eigenvalues $\lambda$ in the left panel (the faint points are the conjugates). The right panel shows $z = e^{\Delta\lambda}$ , one step of the recurrence, inside the aqua unit circle. The chart shows the kernel $K_j$ (thick) and each mode's term (dashed). Move a pole to the left: it decays faster. Move it up: it oscillates faster. Raise $\Delta$ : every $z$ moves toward 0 and the kernel gets shorter in steps. Try one unstable: a pole with $\operatorname{Re}\lambda > 0$ maps outside the circle (magenta) and its term grows.

In context: Lesson 16

Selection by hand. Each token has an input $u_t$ and a logit $z_t$ (slider); $\Delta_t = \operatorname{softplus}(z_t)$ . The yellow bars show the gate $\bar B_t = s(z_t)$ , the blue line the state. In the worked example the large input $u_2 = 5$ gets $z_2 = -3$ , a tiny $\Delta$ , and is mostly ignored: its weight in the last state is 0.024. Try reset at token 4: one large $z$ copies $u_4$ into the state, and the very negative $z$ after it keep it. With same z the weights depend only on the distance to the end, as for a fixed kernel.

In context: Lesson 16

A scan for $L = 8$ . Each box shows which elements it has combined: "2–5" means $e_2 \bullet \dots \bullet e_5$ . Press Next round: the combines of the round are yellow. Hillis–Steele needs 3 rounds ( $\log_2 8$ ) and 17 combines. The sequential loop needs 7 rounds and 7 combines. Blelloch needs more rounds but only $O(L)$ combines. The last row is $x_t$ , and it equals the plain loop.

In context: Lesson 16

Lesson 17 · Generalization

Drag the violet start $w_0$ . The violet path is gradient descent; it always moves along $(1, 2)$ , perpendicular to the aqua line of zero-loss solutions, so it lands on the point of the line closest to $w_0$ . From $w_0 = 0$ this is the minimum-norm solution $X^+y = (1, 2)$ (black). The dashed grey segment is the part of $w_0$ that gradient descent never changes. The orange arrow is the first step $-\eta\nabla\mathcal{L}(w_0)$ . Try $\eta$ above 0.4: the path diverges. Then switch on Adam (blue): it moves along $(1, 1)$ and lands on a different solution.

In context: Lesson 17

Move the ridge $\lambda$ and the label noise $\sigma$ . We fit $n = 40$ noisy points with $p$ frozen random ReLU features and plot the median test error over 6 random draws. The orange curve is the minimum-norm fit ( $\lambda = 0$ ): a U for $p < n$ , a peak at $p = n = 40$ , and a second descent. The aqua curve is ridge with your $\lambda$ : the peak disappears. Set $\sigma = 0$ : the peak gets smaller but stays, because the part of the target that the features cannot represent acts like noise. Set $\sigma = 1$ : now a larger $\lambda$ is needed.

In context: Lesson 17

Choose $n$ and move $p$ . First chart: the smallest singular value of a random $n\times p$ Gaussian matrix (orange: median of 9 draws) against $p/n$ , and the large- $n$ prediction $|\sqrt p - \sqrt n|$ (aqua). It dips to almost 0 at $p = n$ . Second chart: the variance factor $\sum_i 1/s_i^2$ (orange, median) and its exact mean (aqua), which is infinite for $p \in \{n-1, n, n+1\}$ . The yellow line marks your $p$ .

In context: Lesson 17

Change the slow-feature scale $c$ and the noise $\sigma$ , and move the stopping time $t$ . A linear model with 150 fast features and 5 slow features (variance $c^2$ ), $n = 200$ , trained by gradient descent from 0 (computed exactly with the filter factors, average of 20 draws). The orange curve is the test error; the blue and violet curves are the parts from the fast and the slow weights. The shaded bands show how many steps each group needs, $1/(\eta s_i^2)$ . With $c = 0.05$ : down to 4.47, up to 7.77, and down to 0.87. With $c = 0.5$ the speeds are close and the bump disappears.

In context: Lesson 17

Switch between training loss, training accuracy and test accuracy, and move the epoch. The same MLP (64–512–512–10, Adam) is trained on 500 images of the scikit-learn digits with true labels, with 50% random labels and with 100% random labels. All three reach 100% training accuracy; random labels need about three times as many epochs. Only the true labels give a good test accuracy. With 50% random labels, the test accuracy first rises to 0.90 (epoch 9) and then falls to 0.60 while the network memorizes the wrong labels.

In context: Lesson 17