Arrays, shapes, and pixels

An array's shape says how many values it holds along each direction. The dataset keeps the same images in three forms. digits.images has shape (1797, 8, 8): 1,797 images, each 8 rows of 8 pixels. digits.data has shape (1797, 64): the same images, each laid out as one row of 64 values, which is called flattened. y has shape (1797,): one label per image. All three are in the same order, so image number 5 in one form is image number 5 in the others.

Run and say what each number in each shape counts.

Selecting one example removes the example dimension, leaving an eight-by-eight grid. Each entry measures brightness, not a probability and not a class number. A value near zero is dark; a value near sixteen is bright. The label is a separate integer. The index selects both image and label, preserving their pairing. Printing a grid is an inspection step, not training.

Run and look for brighter values outlining the digit whose label is printed.

A nested loop turns bright pixels into # and darker pixels into dots. The conditional expression chooses one value: use # if the condition is true, otherwise use a dot. This threshold is for display only; it discards shades. The real model will still receive the original scaled brightness values. The outer loop ends each row with a newline, keeping the image's spatial arrangement visible.

Run and compare the preview with the numerical grid from the previous stage.

Reshape reorganises dimensions without changing the number of values. The first eight flattened entries are the first image row, followed by the next row. Flattening does not average the image and does not discard all but one brightness. The order becomes part of the model's input contract: feeding the same values in a scrambled order would describe a different image. The equality check compares with the dataset's provided flattened row.

Run and compare the first row with the first eight values.

A model expects a table: one row per image, one column per pixel. Even for a single image, it wants a table with one row, called a batch of one. X[0] picks one image as a plain row of 64 values, shape (64,). X[:1] is a slice, as in the lists lesson, so it keeps the table form: one row of 64, shape (1, 64). X[0].reshape(1, 64) turns the plain row into the same one-row table. The trailing comma in (64,) is just how Python writes a shape with a single number.

Run and identify which outputs describe tables suitable for a classifier.

The original brightness range is zero through sixteen, so dividing once by sixteen maps it to zero through one. NumPy applies division to every entry. The divisor comes from this dataset, not from a universal image rule. MNIST images commonly use 0-255 and require their own preparation. Training, development, final-test, and later drawings must follow the same scale for a particular model. Dividing an already normalised drawing again is a silent input error, not extra cleaning.

Run and check both minima and maxima. Explain why the sample midpoint becomes 0.5.

y == wanted compares every label with 8 at once and gives an array of True and False, one per image. np.where(...) returns the positions where the answer is True; the [0] after it picks the list of positions out of what np.where returns. Using those positions on y shows only 8s, which confirms the positions are right. Later you will use exactly this to find the images a model got wrong, with the condition predictions != y_dev.

Run and confirm that every displayed selected label matches wanted.

These scores are made up, to show how to pick a winner. Each row belongs to one image, and each column to one possible answer. np.argmax(scores, axis=1) finds, in each row, the position of the largest score; axis=1 means look along each row. It returns positions, 1 and 0 here, not the answers themselves. classes[winner_positions] turns positions into the labels they stand for: position 1 means 5, position 0 means 2. Models report their answers in exactly this way, as a position in a list of classes, so keep the two apart. Scores that add up to one look like chances, but a high score is not a promise that the answer is right.

Predict the two winning columns and then map them to labels before running.

This stage brings the checks together for one image: its label, its shape as a batch of one, and its brightness range. An assert line stops the program with an error if its condition is False, so a wrong shape or range cannot slip through unnoticed. Matplotlib, imported as plt, is the library for drawing pictures and charts. plt.imshow draws the 64 values as an 8 by 8 grey picture; vmin=0 and vmax=1 fix 0 as black and 1 as white, so two pictures can be compared fairly. No model is involved: checking the input comes before any training.

Run and inspect the image in Output. Change index to view several examples, including an ambiguous one.