数据操作（基于MXNET框架）

数据操作

import mxnet as mx # 导包

1. 创建NDArray

x = mx.nd.arange(12,ctx=mx.gpu())
x

[ 0.  1.  2.  3.  4.  5.  6.  7.  8.  9. 10. 11.]
<NDArray 12 @gpu(0)>

1.1 通过shape属性来获取NDArray实例的形状

x.shape

(12,)

1.2 通过size属性得到NDArray实例中元素的总数

x.size

12

1.3 使用reshape函数把行向量x的形状改为(3,4)

X = x.reshape((3,4))
X

[[ 0.  1.  2.  3.]
 [ 4.  5.  6.  7.]
 [ 8.  9. 10. 11.]]
<NDArray 3x4 @gpu(0)>

1.4 创建一个各元素为0，形状为(2,3,4)的张量

mx.nd.zeros((2,3,4),ctx=mx.gpu())

[[[0. 0. 0. 0.]
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]]

 [[0. 0. 0. 0.]
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]]]
<NDArray 2x3x4 @gpu(0)>

1.5 创建各元素为1的张量

mx.nd.ones((3,4),ctx=mx.gpu())

[[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]
<NDArray 3x4 @gpu(0)>

1.6 通过Python的列表（list）指定需要创建的NDArray中每个元素的值

Y = nd.array([[2,1,4,3],[1,2,3,4],[4,3,2,1]],ctx=mx.gpu())
Y

[[2. 1. 4. 3.]
 [1. 2. 3. 4.]
 [4. 3. 2. 1.]]
<NDArray 3x4 @gpu(0)>

1.7 创建NDArray，每个元素都随机采样于均值为0、标准差为1的正态分布

mx.nd.random.normal(0,1,shape=(3,4),ctx=mx.gpu())

    [[-0.17739409  0.8909654   0.720208   -0.04110664]
     [-0.14618981 -1.1971692   0.48786253 -0.36545533]
     [ 0.48647016 -1.1397052  -2.0556722   1.5083628 ]]
    <NDArray 3x4 @gpu(0)>

2. 运算

2.1 加法

X + Y

[[ 2.  2.  6.  6.]
 [ 5.  7.  9. 11.]
 [12. 12. 12. 12.]]
<NDArray 3x4 @gpu(0)>

2.2 乘法

X * Y 

[[ 0.  1.  8.  9.]
 [ 4. 10. 18. 28.]
 [32. 27. 20. 11.]]
<NDArray 3x4 @gpu(0)>

2.3 除法

X / Y

[[ 0.    1.    0.5   1.  ]
 [ 4.    2.5   2.    1.75]
 [ 2.    3.    5.   11.  ]]
<NDArray 3x4 @gpu(0)>

2.4 指数运算

Y.exp() 

[[ 7.389056   2.7182817 54.59815   20.085537 ]
 [ 2.7182817  7.389056  20.085537  54.59815  ]
 [54.59815   20.085537   7.389056   2.7182817]]
<NDArray 3x4 @gpu(0)>

2.5 矩阵乘法

mx.nd.dot(X,Y.T)

[[ 18.  20.  10.]
 [ 58.  60.  50.]
 [ 98. 100.  90.]]
<NDArray 3x3 @gpu(0)>

2.6 连结多个NDArray：concat函数

mx.nd.concat(X,Y,dim=0),mx.nd.concat(X,Y,dim=1) # dim=0代表加行数，列数不变；dim=1代表加列数，行数不变

(
 [[ 0.  1.  2.  3.]
  [ 4.  5.  6.  7.]
  [ 8.  9. 10. 11.]
  [ 2.  1.  4.  3.]
  [ 1.  2.  3.  4.]
  [ 4.  3.  2.  1.]]
 <NDArray 6x4 @gpu(0)>,
 
 [[ 0.  1.  2.  3.  2.  1.  4.  3.]
  [ 4.  5.  6.  7.  1.  2.  3.  4.]
  [ 8.  9. 10. 11.  4.  3.  2.  1.]]
 <NDArray 3x8 @gpu(0)>)

2.7 条件判断式

X == Y # 以X == Y为例，如果X和Y在相同位置的条件判断为真（值相等）,那么新的NDArray在相同位置的值为1,反之为0

[[0. 1. 0. 1.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]
<NDArray 3x4 @gpu(0)>

2.8 NDArray中的所有元素求和

X.sum() # 得到只有一个元素的NDArray

[66.]
<NDArray 1 @gpu(0)>

2.9 X的l2范数

X.norm().asscalar() # 通过asscalar函数将结果变换为Python中的标量,或mx.nd.norm(X)
# X.sum() 或 mx.nd.sum(X)
# X.exp() 或 mx.nd.exp(X)

22.494442

3. 广播机制（适当复制元素使两个NDArray形状相同后再按元素运算）

A = mx.nd.arange(3,ctx=mx.gpu()).reshape((3,1))
B = mx.nd.arange(2,ctx=mx.gpu()).reshape((1,2)) 
A,B

(
 [[0.]
  [1.]
  [2.]]
 <NDArray 3x1 @gpu(0)>,
 
 [[0. 1.]]
 <NDArray 1x2 @gpu(0)>)

A + B
# 如果要计算A + B，那么A中第⼀列的3个元素被⼴播（复制）到了第⼆列，而B中第⼀⾏的2个元素被⼴播（复制）到了第⼆⾏和第三⾏。
# 如此，就可以对2个3⾏2列的矩阵按元素相加。

[[0. 1.]
 [1. 2.]
 [2. 3.]]
<NDArray 3x2 @gpu(0)>

4. 索引（左闭右开指定范围）

4.1 截取了矩阵X中行索引为1和2的两行

X[1:3]

[[ 4.  5.  6.  7.]
 [ 8.  9. 10. 11.]]
<NDArray 2x4 @gpu(0)>

4.2 访问单个元素并做修改

X[1,2] = 9
X    

[[ 0.  1.  2.  3.]
 [ 4.  5.  9.  7.]
 [ 8.  9. 10. 11.]]
<NDArray 3x4 @gpu(0)>

4.3 截取一部分元素，并重新赋值

X[1:2,:] = 12
X

[[ 0.  1.  2.  3.]
 [12. 12. 12. 12.]
 [ 8.  9. 10. 11.]]
<NDArray 3x4 @gpu(0)>

5. 运算的内存开销

5.1 运算后Y指向新的内存

before = id(Y)
Y = Y + X
id(Y) == before

False

5.2 指定结果到特定内存(有临时开销)

Z = Y.zeros_like() # 通过zeros_like创建和Y形状相同且元素为0的NDArray
before = id(Z)
Z[:] = X + Y
id(Z) == before

True

5.3 运算符全名函数中的out参数(避免临时开销)

mx.nd.elemwise_add(X,Y,out=Z)
id(Z) == before

True

5.4 用X[:] = X + Y 或者 X += Y来减少运算的内存开销

before = id(X)
X += Y
id(X) == before
# 前提：后续程序不会再使用X

True

6. NDArray和NumPy相互变换

import numpy as np

6.1 NumPy转换为NDArray

P = np.ones((2,3))
D = mx.nd.array(P,ctx=mx.gpu())
D

[[1. 1. 1.]
 [1. 1. 1.]]
<NDArray 2x3 @gpu(0)>

6.2 NDArray转换为NumPy

D.asnumpy()

array([[1., 1., 1.],
       [1., 1., 1.]], dtype=float32)

7. 自动求梯度：autograd

7.1 对函数 y = 2·x^⊤·x 求关于列向量x的梯度

7.1.1 创建 x

x = mx.nd.arange(4,ctx=mx.gpu()).reshape((4,1))
x    

[[0.]
 [1.]
 [2.]
 [3.]]
<NDArray 4x1 @gpu(0)>

7.1.2 调⽤attach_grad函数来申请存储梯度所需要的内存

x.attach_grad()

7.1.3 调⽤record函数来要求MXNet记录与求梯度有关的计算

with mx.autograd.record():
    y = 2 * mx.nd.dot(x.T,x)

7.1.4 调⽤backward函数⾃动求梯度

y.backward()

7.1.5 验证结果:函数 y = 2·x^⊤·x关于 x 的梯度应为 4·x

assert(x.grad - 4 * x).norm().asscalar() == 0
x.grad

[[ 0.]
 [ 4.]
 [ 8.]
 [12.]]
<NDArray 4x1 @gpu(0)>

7.2 训练模式和预测模式

7.2.1 调⽤is_training函数来查看

print(mx.autograd.is_training())
with mx.autograd.record():
    print(mx.autograd.is_training())

False
True

7.3 对Python控制流求梯度

def f(a):
    b = a * 2
    while b.norm().asscalar() < 1000:
        b = b * 2
    if b.sum().asscalar() > 0:
        c = b
    else:
        c = 100 * b
    return c

7.3.1 使⽤record函数记录计算，并调⽤backward函数求梯度

a = mx.nd.random.normal(shape=1)
a.attach_grad()
with mx.autograd.record():
    c = f(a)
c.backward()

7.3.2 验证控制流求梯度的结果的正确性

a.grad == c / a    

[1.]
<NDArray 1 @cpu(0)>

8. 查找模块⾥的所有函数和类

8.1 使⽤dir函数,nd.random模块中所有的成员或属性

print(dir(mx.nd.random))

['NDArray', '_Null', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_internal', '_random_helper', 'current_context', 'exponential', 'exponential_like', 'gamma', 'gamma_like', 'generalized_negative_binomial', 'generalized_negative_binomial_like', 'multinomial', 'negative_binomial', 'negative_binomial_like', 'normal', 'normal_like', 'numeric_types', 'poisson', 'poisson_like', 'randint', 'randn', 'shuffle', 'uniform', 'uniform_like']

9. 查找特定函数和类的使⽤

help(mx.nd.ones_like)

Help on function ones_like:

ones_like(data=None, out=None, name=None, **kwargs)
    Return an array of ones with the same shape and type
    as the input array.
    
    Examples::
    
      x = [[ 0.,  0.,  0.],
           [ 0.,  0.,  0.]]
    
      ones_like(x) = [[ 1.,  1.,  1.],
                      [ 1.,  1.,  1.]]

    Parameters
    ----------
    data : NDArray
        The input
    
    out : NDArray, optional
        The output NDArray to hold the result.
    
    Returns
    -------
    out : NDArray or list of NDArrays
        The output of this function.

9.1 ones_like()用法

x = mx.nd.array([[0,0,0],[2,2,2]],ctx=mx.gpu())
y = x.ones_like()
y

[[1. 1. 1.]
 [1. 1. 1.]]
<NDArray 2x3 @gpu(0)>