{:check ["true"]}
import numpy as np
We can switch the axes of a tensor with various APIs.
In linear algebra, this is known as taking the transpose of a matrix.
x = np.random.random((2,3)).round(decimals=1)
x
# Transpose of a matrix makes its rows into columns
# and columns into rows.
np.transpose(x)
# NDArray objects has `transpose` as a method
x.transpose()
# Transpose is used so frequently that NDArray has a property
# `T` that computes the transpose.
x.T
For higher order tensors, we need to be more explicit about which axes are swapped.
# Let's look at how transpose generalizes to tensors
# with more ranks.
x = np.random.randint(100, size=(2,3,4))
x
# The transpose function can accept a sequence
# which indicates how the axes should be re-ordered.
#
# Note here we are swapping the second and third axes.
np.transpose(x, [0, 2, 1])
# The `swapaxes` can be used to perform exchanging
# the position of two axes.
#
# Here we are perform the swapping using `swapaxes`.
np.swapaxes(x,1,2)
# Finally, `moveaxis` can move an given axis to
# a new position.
#
# Here we are moving the second axis to the last position,
# thus swapping the second and third axes in yet another
# way.
np.moveaxis(x, 1, -1)
It's very often that we end up with trivial axes.
An axis is trivial if it only has one index. Effectively, it can be removed without losing any data.
We can apply a squeeze to safely remove these trivial axis (all together or one by one).
# Here is an example of NDArray with three axes,
# but the first two axes are of size 1, and thus
# are trivial.
# We can drop them without affecting the size of the
# tensor.
x = np.array([[[1, 2,3]]])
print(repr(x))
print("Shape =", x.shape)
# The `squeeze` function drops axes if they are trivial.
# By default, `squeeze` examines all axes.
np.squeeze(x)
# We can ask `squeeze` to process given axes only.
# Here, we try to squeeze only the first axes.
np.squeeze(x, 0)
In working with machine learning data processing pipelines, we often need to artificially introduce trivial axes. This can be done by expand_dims.
The result of expand_dims is a tensor with additional axes, which are all trivial.
expand_dims(x, axis=[...]) specifies which of the axes after expansion will be trivial.
# Consider a simple vector.
x = np.array([1,2,3])
# We can introduce a new trivial axis. We are
# adding a new axis at position 0 which will be trivial.
np.expand_dims(x, axis=0)
# Here, we are adding the new axis at position 1
# which will be trivial.
np.expand_dims(x, axis=1)
# We can add more than one trivial axes.
np.expand_dims(x, axis=[0,1])
Reshape changes the shape of a tensor while preserving the same number of entries.
The original tensor and the output tensor can have different shapes, but they must hold exactly the same number of entries.
It's also really important to note that the elements are enumerated the same way in both the input and output tensors.
# Consider a vector with 12 elements.
x = np.arange(12)
x
# We can reshape the vector into a new shape (2,6) using
# `reshape`. Note that the new shape must have the same
# size as the original vector.
np.reshape(x, (2,6))
# We can reshape the vector into (4,3).
np.reshape(x, (4,3))
# Here the vector is reshaped into a tensor with three axes with
# the shape (2,2,3)
np.reshape(x, (2, 2, 3))
# -1 can be used only once to denote a number
# that makes `reshape` possible.
np.reshape(x, (2, -1, 2))
Flatten is a special case of reshape. It always collapses the tensor into a single axis.
# Suppose we have tensor with many axes.
x = np.random.random((2,2,3,3)).round(decimals=2)
x
# We can flatten the tensor into a vector using the `flatten` function.
x.flatten()
We can make copies of the same tensor to form larger tensors. This can be done using
repeat andtilerepeat repeats each element n times along the specified axis.
# Consider a matrix of shape (2, 4)
x = np.arange(8).reshape((2,4))
x
# We can use `repeat` to copy _each_ row
# into 3 copies.
# Note that each row is duplicated 3 times.
np.repeat(x, 3, axis=0)
Tile works similarly, but it repeat the whole tensor along the specified axis.
Furthermore, the repetitions are specified for each of the axes separately.
# Tiling repeates the entire tensor along the axes.
# Here, we use `tile` to make copies of the entire tensor
# along the columns three times.
np.tile(x, (1, 3))
# Tiling is powerful as it can copy the tensor along
# different axes.
# Here we are tiling the matrix 2 times along the first axis,
# and 3 times along the second axes.
np.tile(x, (2, 3))