Step¶

The basic slice syntax is i:j:k where i is the starting index, j is the stopping index, and k is the step (k must be nonzero).

Note: Previously, MXNet supported basic slicing and indexing only with step=1. From release 1.0, arbitrary values of step are supported.

x = nd.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype='int32')
# Select elements 1 through 7, and use a step of 2
x[1:7:2]

[1 3 5]
<NDArray 3 @cpu(0)>

Purely Integer Array Indexing¶

When the index consists of as many integer arrays as the array being indexed has dimensions, the indexing is straight forward, but different from slicing.

Advanced indexes always are broadcast and iterated as one:

result[i_1, ..., i_M] == x[ind_1[i_1, ..., i_M], ind_2[i_1, ..., i_M],
                           ..., ind_N[i_1, ..., i_M]]

Note that the result shape is identical to the (broadcast) indexing array shapes ind_1, ..., ind_N.

Example: From each row, a specific element should be selected. The row index is just [0, 1, 2] and the column index specifies the element to choose for the corresponding row, here [0, 1, 0]. Using both together the task can be solved using advanced indexing:

x = nd.array([[1, 2],
              [3, 4],
              [5, 6]], dtype='int32')
x[[0, 1, 2], [0, 1, 0]]

[1 4 5]
<NDArray 3 @cpu(0)>

To achieve a behavior similar to the basic slicing above, broadcasting can be used. This is best understood with an example.

Example: From a 4x3 array the corner elements should be selected using advanced indexing. Thus all elements for which the column is one of [0, 2] and the row is one of [0, 3] need to be selected. To use advanced indexing one needs to select all elements explicitly. Using the method explained previously one could write:

x = nd.array([[ 0,  1,  2],
              [ 3,  4,  5],
              [ 6,  7,  8],
              [ 9, 10, 11]], dtype='int32')
x[[[0, 0], [3, 3]],
  [[0, 2], [0, 2]]]

[[ 0  2]
 [ 9 11]]
<NDArray 2x2 @cpu(0)>

However, since the indexing arrays above just repeat themselves, broadcasting can be used.

x[[[0], [3]],
  [[0, 2]]]

[[ 0  2]
 [ 9 11]]
<NDArray 2x2 @cpu(0)>

Combining Advanced and Basic Indexing¶

There are three situations we need to consider when mix advanced and basic indices in a single selection object. Let’s look at examples to understand each one’s behavior.

• There is only one advanced index in the selection object. For example, x is an NDArray with shape=(10, 20, 30, 40, 50) and result=x[:, :, ind] has one advanced index ind with shape=(2, 3, 4) on the third axis. The result will have shape=(10, 20, 2, 3, 4, 40, 50) because the subspace of x in the third dimension is replaced by the subspace of shape=(2, 3, 4). If we let i, j, k loop over the (2, 3, 4)-shaped subspace, it is equivalent to result[:, :, i, j, k, :, :] = x[:, :, ind[i, j, k], :, :].

import numpy as np
shape = (10, 20, 30, 40, 50)
x = nd.arange(np.prod(shape), dtype='int32').reshape(shape)
ind = nd.arange(24).reshape((2, 3, 4))
print(x[:, :, ind].shape)

(10, 20, 2, 3, 4, 40, 50)

• There are at least two advanced indices in the selection object, and all the advanced indices are adjacent to each other. For example, x is an NDArray with shape=(10, 20, 30, 40, 50) and result=x[:, :, ind1, ind2, :] has two advanced indices with shapes that are broadcastable to shape=(2, 3, 4). Then the result has shape=(10, 20, 2, 3, 4, 50) because (30, 40)-shaped subspace has been replaced with (2, 3, 4)-shaped subspace from the indices.

ind1 = [0, 1, 2, 3]
ind2 = [[[0], [1], [2]], [[3], [4], [5]]]
print(x[:, :, ind1, ind2, :].shape)

(10, 20, 2, 3, 4, 50)

• There are at least two advanced indices in the selection object, and there is at least one advanced index separated from the others by basic indices. For example, x is an NDArray with shape=(10, 20, 30, 40, 50) and result=x[:, :, ind1, :, ind2] has two advanced indices with shapes that are broadcastable to shape=(2, 3, 4). Then the result has shape=(2, 3, 4, 10, 20, 40) because there is no unambiguous place to place the indexing subspace, hence it is prepended to the beginning.

print(x[:, :, ind1, :, ind2].shape)

(2, 3, 4, 10, 20, 40)