Chapter 2: Arrays and Shapes

Every ML library you will touch keeps its numbers in NumPy’s ndarray or something built like it. An image, a batch of token ids and a layer’s weights are all arrays. Many bugs in ML code come from the wrong shape: a (32, 10) where the code expected (10, 32). This chapter is about reading shapes.

An array is its values, its shape, and its dtype. Make one from a list with np.array, or from nothing with np.zeros, np.ones and np.full. np.arange counts in steps, and np.linspace spaces a set number of points between two ends. Random values come from a generator that np.random.default_rng makes; give it a seed and a run can be repeated.

import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]])
a.shape, a.dtype

((2, 3), dtype('int64'))

np.zeros((2, 3))

array([[0., 0., 0.],
       [0., 0., 0.]])

np.full((2, 3), 7)

array([[7, 7, 7],
       [7, 7, 7]])

np.arange(0, 12, 3)

array([0, 3, 6, 9])

np.linspace(0, 1, 5)

array([0.  , 0.25, 0.5 , 0.75, 1.  ])

rng = np.random.default_rng(0)
rng.integers(0, 10, size=4)

array([8, 6, 5, 2])

To read part of an array, use indexing for one value and slicing for a range, one position per axis. A boolean mask picks the values where a condition holds. Fancy indexing picks rows by a list of positions, in any order. Reshape reads the same values into a new shape, and -1 tells it to work out one length for you.

import numpy as npa = np.arange(12).reshape(3, 4)a[1:, ::2]a[a % 2 == 0]a[[2, 0]]a.reshape(2, -1)a.T

Read a shape one axis at a time. Axis 0 is the first number, the rows of a 2-D array; axis 1 is the second, the columns. A slice keeps the axis it slices, so a[1:2] is still 2-D.

A single index drops its axis: a[1] is one row with shape (4,). This is where most people slip, because a[1] and a[1:2] print the same numbers, one pair of brackets apart, and the next line breaks. A mask the same shape as the array gives back 1-D, since the values it picks no longer form a grid; a mask over the rows alone, a[a[:, 0] > 2], keeps whole rows.

import numpy as np
a = np.arange(12).reshape(3, 4)
a[1].shape

(4,)

a[1:2].shape

(1, 4)

a[:, 1].shape

(3,)

a[:, 1:2].shape

(3, 1)

a[a > 5].shape

(6,)

a[a[:, 0] > 2].shape

(2, 4)

Ravel and flatten both lay an array out in one line. Ravel hands back the same memory when it can; flatten always copies. Chapter 3 shows why sharing memory bites. Transpose, written .T, reverses the axes, so a (2, 3) array becomes (3, 2) and its rows become columns.

import numpy as np
a = np.arange(6).reshape(2, 3)
a.ravel()

array([0, 1, 2, 3, 4, 5])

np.shares_memory(a, a.ravel()), np.shares_memory(a, a.flatten())

(True, False)

a.T

array([[0, 3],
       [1, 4],
       [2, 5]])

The habit to build is small: before you run a line, say the shape it will make. When you’re wrong, print .shape and find out why. A model is a long chain of such lines, and a shape error caught in your head costs nothing.

Homework

The packet drills that habit: predict the shape of each line, then write the lines yourself. It ends with a small build, pulling the top-scoring rows out of a score matrix.