NDArray - Scientific computing on CPU and GPU

NDArray is a tensor data structure similar to numpy’s multi-dimensional array. In addition, it supports asynchronous computation on CPU and GPU.

First, let’s import MXNet:

from __future__ import print_function
import numpy as np
import mxnet as mx

Creating NDArray

There are many ways to create NDArray.

Construct from (nested) list:

x = mx.nd.array([[1, 2, 3], [4, 5, 6]])

Construct from numpy array:

x_numpy = np.ones((2, 3))
x = mx.nd.array(x_numpy)

Array construction routines:

# create an 2x3 array of ones
x = mx.nd.ones((2, 3))
# create an 2x3 array of zeros
x = mx.nd.zeros((2, 3))
# create an 1d-array of 0 to 5 and reshape to 2x3
x = mx.nd.arange(6).reshape((2, 3))

You can convert an NDArray to numpy array to retrieve its data with .asnumpy():

z = x.asnumpy()

Basic attributes

NDArray has some basic attributes that you often want to query:

NDArray.shape: The dimensions of the array. It is a tuple of integers indicating the length of the array along each axis. For a matrix with n rows and m columns, its shape will be (n, m).

print('x.shape:', x.shape)

NDArray.dtype: A numpy type object describing the type of array elements.

print('x.dtype:', x.dtype)

NDArray.size: the total number of components in the array - equals to the product of the components of its shape

print('x.size:', x.size)

NDArray.context: The device on which this array is stored, e.g. mx.cpu() or mx.gpu(1).

print('x.context:', x.context)

NDArray Operations

NDArray supports a wide range of operations. Simple operations can be called with python syntax:

x = mx.nd.array([[1, 2], [3, 4]])
y = mx.nd.array([[4, 3], [2, 1]])
print(x + y)

You can also call operators from the mxnet.ndarray (or mx.nd for short) name space:

z = mx.nd.add(x, y)

You can also pass additional flags to operators:

z = mx.nd.sum(x, axis=0)
print('axis=0:', z)
z = mx.nd.sum(x, axis=1)
print('axis=1:', z)

Using GPU

Each NDArray lives on a Context. MXNet supports mx.cpu() for CPU and mx.gpu(0), mx.gpu(1), etc for GPU. You can specify context when creating NDArray:

# creates on CPU (the default).
# Replace mx.cpu() with mx.gpu(0) if you have a GPU.
x = mx.nd.zeros((2, 2), ctx=mx.cpu())
x = mx.nd.array([[1, 2], [3, 4]], ctx=mx.cpu())

You can copy arrays between devices with .copyto():

# Copy x to cpu. Replace with mx.gpu(0) if you have GPU.
y = x.copyto(mx.cpu())
# Copy x to another NDArray, possibly on another Context.
y = mx.nd.zeros_like(x)

See the Advanced NDArray tutorial for a more detailed introduction to NDArray API.