Data Manipulation

Dive into Deep Learning · §1.1

Storing & transforming data with tensors
The n-dimensional arrays that every model in this book is built on.

The tensor: our basic data structure

Motivation

• An n-dimensional array of numbers
  generalizes the NumPy ndarray.
• Runs on GPUs and other accelerators.
• Records operations for automatic differentiation.

Rank = number of axes; shape = size per axis.

01

Getting Started

creating & inspecting tensors

Create a vector, then inspect it

Getting Started

arange(n) builds a 1-D tensor of evenly spaced values:

x = np.arange(12)
x

array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10., 11.])

x.shape

(12,)

numel() → total elements. shape → size along each axis. We ask for float32 because nearly all neural-net math is in floating point.

randn breaks symmetry; lists pin exact values

Getting Started

For weight init, randn draws from \mathcal{N}(0, 1):

np.random.normal(0, 1, size=(3, 4))

array([[-1.0732179 ,  1.4494689 , -0.9780016 , -0.69197655],
       [ 0.30483028,  2.2523196 , -0.2745827 ,  0.2653999 ],
       [ 2.984504  ,  0.7354883 , -1.3070105 ,  0.9972589 ]])

Or type exact values as a list:

np.array([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])

array([[2., 1., 4., 3.],
       [1., 2., 3., 4.],
       [4., 3., 2., 1.]])

Also zeros, ones, full(shape, value), eye(n). Random values break symmetry when initializing network weights; lists let you type a tensor by hand.

Reshape: same data, new layout

Getting Started

Same elements in a new shape; numel is preserved:

X = x.reshape(3, 4)
X

array([[ 0.,  1.,  2.,  3.],
       [ 4.,  5.,  6.,  7.],
       [ 8.,  9., 10., 11.]])

Usually no copy: only the shape metadata changes. Use -1 to infer an axis: x.reshape(3, -1).

02

Indexing & Slicing

reading & writing elements, rows, ranges

Reading: elements, rows, ranges

Indexing & Slicing

X[-1] is the last row;
X[1:3] is rows 1–2:

X[-1], X[1:3]

(array([ 8.,  9., 10., 11.]),
 array([[ 4.,  5.,  6.,  7.],
        [ 8.,  9., 10., 11.]]))

0-based; negatives count from the end; a range a:b is half-open (b excluded).

Writing: one cell or a whole region

Indexing & Slicing

Assignment writes in place.
One element, or a whole slice:

X[1, 2] = 17
X

array([[ 0.,  1.,  2.,  3.],
       [ 4.,  5., 17.,  7.],
       [ 8.,  9., 10., 11.]])

X[:2, :] = 12
X

array([[12., 12., 12., 12.],
       [12., 12., 12., 12.],
       [ 8.,  9., 10., 11.]])

03

Operations

elementwise math, joins, comparisons, broadcasting

Elementwise ops: matching shapes, entry by entry

Operations

The operators + - * / ** act elementwise on matching shapes:

x = np.array([1, 2, 4, 8])
y = np.array([2, 2, 2, 2])
x + y, x - y, x * y, x / y, x ** y

(array([ 3.,  4.,  6., 10.]),
 array([-1.,  0.,  2.,  6.]),
 array([ 2.,  4.,  8., 16.]),
 array([0.5, 1. , 2. , 4. ]),
 array([ 1.,  4., 16., 64.]))

Unary functions like exp map each element:

np.exp(x)

array([1.0000000e+00, 2.7182820e+00, 7.3890557e+00, 2.0085537e+01,
       5.4598145e+01, 1.4841315e+02, 4.0342877e+02, 1.0966331e+03,
       2.9809583e+03, 8.1030840e+03, 2.2026467e+04, 5.9874137e+04])

Any scalar→scalar map (exp, sin, log) extends to a whole tensor.

Concatenate along an axis

Operations

cat joins along an existing axis
dim=0 adds rows, dim=1 widens:

X = np.arange(12).reshape(3, 4)
Y = np.array([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
np.concatenate([X, Y], axis=0), np.concatenate([X, Y], axis=1)

Every other axis must already match.

Comparisons build masks; reductions collapse

Operations

Comparisons return a boolean tensor.
A ready-made mask:

X == Y

array([[False,  True, False,  True],
       [False, False, False, False],
       [False, False, False, False]])

Reductions collapse axes
no dim= gives a scalar:

X.sum()

array(66.)

==, <, > build masks; sum, mean, max collapse axes; add dim= to reduce just one.

Broadcasting stretches size-1 axes for free

Operations · the exception

Size-1 axes are virtually stretched
a 3\times1 plus a 1\times2 gives a 3\times2:

a = np.arange(3).reshape(3, 1)
b = np.arange(2).reshape(1, 2)
a, b

a + b

array([[0., 1.],
       [1., 2.],
       [2., 3.]])

Any axis of size 1 stretches to match the other tensor, without a copy.

Compatible only if each axis is equal or 1.

…or it refuses: no size-1 axis, no guess

Operations · the exception

Line up (3, 2) and (2, 3) from the right, pairing 2 with 3 and 3 with 2: no pair matches, neither member is 1, so the framework raises rather than guessing:

try:
    np.ones((3, 2)) + np.ones((2, 3))
except Exception as e:
    print(e)

Traceback (most recent call last):
  File "/home/smola/mxnet/src/operator/numpy/./../tensor/elemwise_binary_broadcast_op.h", line 69
MXNetError: Check failed: l == 1 || r == 1: operands could not be broadcast together with shapes [3,2] [2,3]

Broadcasting aligns shapes from the right; each axis pair must be equal or 1.

04

Memory & Interop

in-place updates and leaving the tensor world

The hidden cost of Y = Y + X

Performance

Every arithmetic expression allocates a new tensor
costly when Y is gigabytes and updated many times per second:

before = id(Y)
Y = Y + X
id(Y) == before

False

id(Y) changed: Y is now bound to a new tensor object.

Saving memory with in-place ops

Performance

Write into pre-allocated storage with
Z[:] = ...; the address holds:

Z = np.zeros_like(Y)
print('id(Z):', id(Z))
Z[:] = X + Y
print('id(Z):', id(Z))

id(Z): 130345996334288
id(Z): 130345996334288

If X isn’t needed afterward, X += Y is cheapest:

before = id(X)
X += Y
id(X) == before

True

Converting to other Python objects

Interop

Convert to / from a NumPy ndarray:

A = X.asnumpy()
B = np.array(A)
type(A), type(B)

(numpy.ndarray, mxnet.numpy.ndarray)

The result is a copy; host/device arrays don’t share storage here.

A size-1 tensor unwraps to a Python scalar with .item():

a = np.array([3.5])
a, a.item(), float(a), int(a)

(array([3.5]), 3.5, 3.5, 3)

Summary

Wrap-up

• Tensor = n-d array; the core data structure (GPU + autodiff).
• Create: arange, zeros, ones, randn, tensor([…]).
• Inspect / restructure: .shape, .numel(), reshape.
• Index / slice to read and write: negatives, ranges, regions.

• Elementwise math, comparisons (masks), reductions, cat.
• Broadcasting stretches size-1 axes and refuses anything else.
• Save memory with in-place ops (X[:] = …, +=), or in JAX via jit buffer reuse.
• Interop: tensor ↔︎ NumPy, .item() for scalars.