| # 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: |
| |
| ```python |
| 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: |
| ```python |
| x = mx.nd.array([[1, 2, 3], [4, 5, 6]]) |
| print(x) |
| ``` |
| |
| Construct from numpy array: |
| ```python |
| x_numpy = np.ones((2, 3)) |
| x = mx.nd.array(x_numpy) |
| print(x) |
| ``` |
| |
| Array construction routines: |
| ```python |
| # create an 2x3 array of ones |
| x = mx.nd.ones((2, 3)) |
| print(x) |
| # create an 2x3 array of zeros |
| x = mx.nd.zeros((2, 3)) |
| print(x) |
| # create an 1d-array of 0 to 5 and reshape to 2x3 |
| x = mx.nd.arange(6).reshape((2, 3)) |
| print(x) |
| ``` |
| |
| You can convert an NDArray to numpy array to retrieve its data with `.asnumpy()`: |
| ```python |
| z = x.asnumpy() |
| print(z) |
| ``` |
| |
| ## 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)`. |
| |
| ```python |
| print('x.shape:', x.shape) |
| ``` |
| |
| **NDArray.dtype**: A `numpy` _type_ object describing the type of array |
| elements. |
| |
| ```python |
| 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` |
| |
| ```python |
| print('x.size:', x.size) |
| ``` |
| |
| **NDArray.context**: The device on which this array is stored, e.g. `mx.cpu()` |
| or `mx.gpu(1)`. |
| |
| ```python |
| print('x.context:', x.context) |
| ``` |
| |
| ## NDArray Operations |
| |
| NDArray supports a wide range of operations. Simple operations can be called |
| with python syntax: |
| |
| ```python |
| 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: |
| |
| ```python |
| z = mx.nd.add(x, y) |
| print(z) |
| ``` |
| |
| You can also pass additional flags to operators: |
| |
| ```python |
| 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: |
| |
| ```python |
| # 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()) |
| print(x) |
| ``` |
| |
| ```python |
| x = mx.nd.array([[1, 2], [3, 4]], ctx=mx.cpu()) |
| print(x) |
| ``` |
| |
| You can copy arrays between devices with `.copyto()`: |
| |
| ```python |
| # Copy x to cpu. Replace with mx.gpu(0) if you have GPU. |
| y = x.copyto(mx.cpu()) |
| print(y) |
| ``` |
| |
| ```python |
| # Copy x to another NDArray, possibly on another Context. |
| y = mx.nd.zeros_like(x) |
| x.copyto(y) |
| print(y) |
| ``` |
| |
| See the [Advanced NDArray tutorial](../basic/ndarray.md) for a more detailed |
| introduction to NDArray API. |
| |
| <!-- INSERT SOURCE DOWNLOAD BUTTONS --> |