mxnet深度学习(NDArray)

mxnet深度学习(NDArray)

MXNet里面的3个主要的概念:

NDArray：NDArray提供了矩阵和张量(tensor)运算在CPU和GPU上，通过使用并行运算的技术。

Symbol:Symbol使得定义一个神经网络变得更加简单，并且自动提供差异化(用于区别别的神经网络)。

KVStore: KVStore  提供数据同步在有多个GPU和CPU的机器上。

NDArray(Numpy风格的，可以在CPU和GPU运算的张量计算模块)

NDArray与numpy.ndarray相似，但是它多了以下两点:

1.多个设备支持:所有的操作可以支持GPU和CPU。

2.自动并行:所有的操作都是以并行的方式进行的。

创建和初始化

我们可以创建NDArray在CPU和GPU上:

>>> import mxnet as mx
>>> a = mx.nd.empty((2, 3)) # create a 2-by-3 matrix on cpu
>>> b = mx.nd.empty((2, 3), mx.gpu()) # create a 2-by-3 matrix on gpu 0
>>> c = mx.nd.empty((2, 3), mx.gpu(2)) # create a 2-by-3 matrix on gpu 2
>>> c.shape # get shape
(2L, 3L)
>>> c.context # get device info
gpu(2)

它们可以初始化通过不同的方式

>>> a = mx.nd.zeros((2, 3)) # create a 2-by-3 matrix filled with 0
>>> b = mx.nd.ones((2, 3))  # create a 2-by-3 matrix filled with 1
>>> b[:] = 2 # set all elements of b to 2

我们可以把值从一个NDArray到另一个，即使它们在不同的设备上

>>> a = mx.nd.ones((2, 3))
>>> b = mx.nd.zeros((2, 3), mx.gpu())
>>> a.copyto(b) # copy data from cpu to gpu

我们可以把NDArray转换成numpy.ndarray

>>> a = mx.nd.ones((2, 3))
>>> b = a.asnumpy()
>>> type(b)

>>> print b
[[ 1.  1.  1.]
 [ 1.  1.  1.]]

反之亦然

>>> import numpy as np
>>> a = mx.nd.empty((2, 3))
>>> a[:] = np.random.uniform(-0.1, 0.1, a.shape)
>>> print a.asnumpy()
[[-0.06821112 -0.03704893  0.06688045]
 [ 0.09947646 -0.07700162  0.07681718]]

基础操作

元素级操作是默认的，NDArray执行的是元素级的操作(这和matlab里面和我们线性代数里面学的不一样)

>>> a = mx.nd.ones((2, 3)) * 2
>>> b = mx.nd.ones((2, 3)) * 4
>>> print b.asnumpy()
[[ 4.  4.  4.]
 [ 4.  4.  4.]]
>>> c = a + b
>>> print c.asnumpy()
[[ 6.  6.  6.]
 [ 6.  6.  6.]]
>>> d = a * b
>>> print d.asnumpy()
[[ 8.  8.  8.]
 [ 8.  8.  8.]]

如果两个NDArray在不同的设备上，我们需要显示的把他们移到同一个设备上。

下面的代码显示了在GPU 0操作的例子

>>> a = mx.nd.ones((2, 3)) * 2
>>> b = mx.nd.ones((2, 3), mx.gpu()) * 3
>>> c = a.copyto(mx.gpu()) * b
>>> print c.asnumpy()
[[ 6.  6.  6.]
 [ 6.  6.  6.]]

加载和保存

下面有两个方式去保存(加载)数据从磁盘上。第一个方式是pickle,NDArray是pickle compatible,意味着你可以简单的把NDArray进行pickle,就像在numpy.ndarray里面一样。

>>> import mxnet as mx
>>> import pickle as pkl

>>> a = mx.nd.ones((2, 3)) * 2
>>> data = pkl.dumps(a)
>>> b = pkl.loads(data)
>>> print b.asnumpy()
[[ 2.  2.  2.]
 [ 2.  2.  2.]]

第二个方式是直接把一列NDArray以二进制的格式存到磁盘中(这时就不用pickle了)

>>> a = mx.nd.ones((2,3))*2
>>> b = mx.nd.ones((2,3))*3
>>> mx.nd.save('mydata.bin', [a, b])
>>> c = mx.nd.load('mydata.bin')
>>> print c[0].asnumpy()
[[ 2.  2.  2.]
 [ 2.  2.  2.]]
>>> print c[1].asnumpy()
[[ 3.  3.  3.]
 [ 3.  3.  3.]]

我们还可以存一个字典(dict)

>>> mx.nd.save('mydata.bin', {'a':a, 'b':b})
>>> c = mx.nd.load('mydata.bin')
>>> print c['a'].asnumpy()
[[ 2.  2.  2.]
 [ 2.  2.  2.]]
>>> print c['b'].asnumpy()
[[ 3.  3.  3.]
 [ 3.  3.  3.]]

另外，如果设置了分布式系统比如S3和HDFS，我们可以直接去保存和加载它们(一般都没有用)

>>> mx.nd.save('s3://mybucket/mydata.bin', [a,b])
>>> mx.nd.save('hdfs///users/myname/mydata.bin', [a,b])

用自动并行运算 

NDArray可以自动并行执行操作。这是需要的，当我们需要使用多个资源如CPU,GPU,和CPU-to-GPU的内存带宽。   举个栗子，如果我们写a+=1在b+=1的后面，a是在CPU而b是在GPU，然后我们接下去想并行执行它们来提高效率。此外，在CPU和GPU之间进行数据拷贝的开销是很昂贵的，所以我们希望把它们和其他的运算一起并行计算。

然而,通过眼睛来找可以并行运算的语句是比较累人的。在下面的例子里面，a+=1和c*=3是可以被并行执行的，但是a+=1和b*=3必须顺序执行。

a = mx.nd.ones((2,3))
b = a
c = a.copyto(mx.cpu())
a += 1
b *= 3
c *= 3

幸运的是，MXNet在确保运行正确的情况下，可以自动解决依赖问题。换句话说，我们可以写程序就像一个单一的线程，MXNet将会自动派遣它们到多个设备，如具有多个GPU的显卡，和多台机器上。

这是通过惰性评估来实现的。任何我们写的操作都是通过一个中间引擎来发行的，然后返回。举个栗子，如果我们运行a+=1，它在执行加法操作后立即返回这个引擎。这个异步性允许我们发出更多的操作给引擎，所以它可以决定读写依赖并找到最好的并行执行它们的方式。

实际的计算是当我们想把结果拷贝到其它地方的时候完成的，比如print a.asnumpy() (复制到终端)或者mx.nd.save([a])。因此，如果我们想去写高效的并行的代码，我们只需要延缓请求结果的时间。