NumPy Shape Manipulation — reshape, flatten, ravel, transpose

Reshaping arrays is one of the most frequent NumPy operations, especially when preparing data for machine learning models. A linear layer expects (batch, features). A convolution expects (batch, channels, height, width). Getting the shape right without introducing bugs requires understanding which operations copy data and which do not.

This guide covers the core shape manipulation functions, the view/copy rules for each, and the practical patterns that come up in real code.

reshape — Changing Shape Without Changing Data

reshape() returns a view when the data is contiguous in memory (which it usually is for freshly created arrays). Use -1 as a wildcard dimension and NumPy computes it from the total element count. This is the most common way to restructure data for ML model inputs.

import numpy as np

a = np.arange(12)  # shape (12,)

print(a.reshape(3, 4))   # (3, 4)
print(a.reshape(2, 6))   # (2, 6)
print(a.reshape(2, -1))  # (2, 6) — -1 inferred
print(a.reshape(3, 2, 2)) # (3, 2, 2)

# Common ML pattern: add batch dimension
single = np.random.randn(28, 28)       # one image
batch  = single.reshape(1, 28, 28)     # one image in a batch
print(batch.shape)  # (1, 28, 28)

flatten vs ravel — Both Give 1D, Different Memory

flatten() always returns a new array with its own memory. ravel() returns a view when the array is contiguous, else it returns a flattened copy. For most use cases ravel() is faster and memory-efficient, but if you need a guaranteed independent copy that won't mutate the original, use flatten().

import numpy as np

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

f = m.flatten()   # copy — always
r = m.ravel()     # view when possible

f[0] = 99
print(m[0, 0])  # 1 — flatten copy not linked

r[0] = 99
print(m[0, 0])  # 99 — ravel view is linked

transpose — Reordering Axes

transpose() reverses the order of axes by default (equivalent to .T). You can also pass a tuple to specify the exact axis order. It always returns a view — no data is copied, only the strides and shape metadata are rearranged. This is extremely fast but the result is non-contiguous in memory.

import numpy as np

a = np.arange(24).reshape(2, 3, 4)
print(a.shape)                   # (2, 3, 4)
print(a.T.shape)                 # (4, 3, 2) — reversed
print(a.transpose(0, 2, 1).shape)  # (2, 4, 3) — swap last two axes

# .T is just shorthand for .transpose()
matrix = np.ones((3, 5))
print(matrix.T.shape)  # (5, 3)

squeeze and expand_dims — Manage Singleton Dimensions

squeeze() removes dimensions of size 1 from the shape. expand_dims() inserts a new dimension of size 1 at a specified axis. Both return views when possible. They are essential for aligning array shapes before operations like concatenation or broadcasting.

import numpy as np

a = np.zeros((1, 3, 1, 4))   # shape with two size-1 dims
print(a.squeeze().shape)     # (3, 4)
print(a.squeeze(axis=0).shape)  # (3, 1, 4) — remove only axis 0

b = np.array([1, 2, 3])  # shape (3,)
print(np.expand_dims(b, axis=0).shape)  # (1, 3)
print(np.expand_dims(b, axis=1).shape)  # (3, 1)

Reshaping in Practice: ML Data Pipeline Patterns

In machine learning, shape manipulation is used constantly to convert between different data layouts. Common patterns: (samples, features) → (batch, channels, height, width) for CNNs; adding batch dimensions; flattening final layers; transposing from (batch, seq, features) to (seq, batch, features) for recurrent networks. Knowing which operations are views vs copies directly impacts memory budgets and training speed.

import numpy as np

# 1. Load flat CSV, reshape into images
flat = np.random.randn(1000 * 28 * 28)  # 784000 items
images = flat.reshape(-1, 28, 28)        # (1000, 28, 28)
# 2. Add channel dim for CNN
images_cnn = np.expand_dims(images, axis=1)  # (1000, 1, 28, 28)
# 3. Transpose for sequence models: (batch, time, features) -> (time, batch, features)
batch_seq_feat = np.random.randn(32, 50, 128)
seq_batch_feat = np.transpose(batch_seq_feat, (1, 0, 2))  # (50, 32, 128)
# 4. Flatten final conv features for dense layer
conv_out = np.random.randn(32, 64, 7, 7)  # batch=32, channels=64, H=7, W=7
flat_features = conv_out.reshape(32, -1)  # (32, 64*7*7=3136)

Frequently Asked Questions