动手学深度学习-Day1-NDarray

环境安装

本书第二章的环境安装写的非常详细，电脑上已经装好了Anaconda，下载代码，并按照步骤进入命令行模式，配置环境即可。此处不在赘述。使用Windows系统下的操作。

数据操作

在jupyternotebook中进入chapter_prerequisite/ndarray.ipynb。
NDArry是一个类。

创建NDArray

chapter_prerequisite/ndarray.ipynb

from mxnet import nd
x = nd.arange(12) -----------arange函数创建行向量
x
输出：

第二行是指返回一个NDArray实例，长度为12的一维数组，且被创建在CPU使用的内存上。

x.shape -----shape属性得到该实例的形状
out：（12，）
x.size -------得到该实例中元素的总数
out：12
X = x.reshape((3, 4)) ----reshape函数改变向量的形状，这里改成3行4列的矩阵，并记作X.
X
注：这里也可以写为reshape（-1,4),-1是模糊控制的意思，第二个参数是固定的，由于x向量中元素个数已知，因此得到结论一样。

//创建一个各元素为0，形状为(2, 3, 4)的张量
nd.zeros((2, 3, 4))
//Out
[[[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 @cpu(0)>

//创建元素为1的张量
nd.ones((3, 4))
//Out
[[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]
<NDArray 3x4 @cpu(0)>

//产生指定元素值
Y = nd.array([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
Y
//OUt
[[2. 1. 4. 3.]
 [1. 2. 3. 4.]
 [4. 3. 2. 1.]]
<NDArray 3x4 @cpu(0)>

//随机元素值，random.normal，均值0标准差为1的正态分布
nd.random.normal(0, 1, shape=(3, 4))
//Out

[[ 2.2122064   0.7740038   1.0434405   1.1839255 ]
 [ 1.8917114  -1.2347414  -1.771029   -0.45138445]
 [ 0.57938355 -1.856082   -1.9768796  -0.20801921]]
<NDArray 3x4 @cpu(0)>

运算

支持“+，-，*，/”等各种运算，按照矩阵的运算法则，注意行列的对应即可。

按元素运算

// 运算示例，按元素进行操作
X + Y
X * Y
X / Y
Y.exp() ----指数运算

矩阵运算

//使用dot函数做矩阵乘法，X和Y都是3行4列的矩阵
nd.dot(X, Y.T) ----Y.T是对Y做转置运算，变成4行3列
//Out
 [[ 18.  20.  10.]
 [ 58.  60.  50.]
 [ 98. 100.  90.]]
<NDArray 3x3 @cpu(0)>

Y=[[2. 1. 4. 3.]
[1. 2. 3. 4.]
[4. 3. 2. 1.]]
X=[[ 0. 1. 2. 3.]
[ 4. 5. 6. 7.]
[ 8. 9. 10. 11.]]

//使用concat连接多个矩阵
nd.concat(X, Y, dim=0), nd.concat(X, Y, dim=1) ----dim=0表示在行上连接，因为形状结论的第一个元素表征的是行的尺寸，dim=1表示在列上连接
//Out
 (
 [[ 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 @cpu(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 @cpu(0)>)

//条件判别
X == Y
//out
[[0. 1. 0. 1.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]
<NDArray 3x4 @cpu(0)>

//求和
X.sum()
//OUt
[66.]
<NDArray 1 @cpu(0)>

//将向量转换成标量
X.norm().asscalar()
//Out
22.494442

广播机制

对两个形状不同的NDArray按元素运算时，可能会触发广播（broadcasting）机制：先适当复制元素使这两个NDArray形状相同后再按元素运算。

//定义
A = nd.arange(3).reshape((3, 1))  ---生成含有三个元素一维数组，整形成3行1列
B = nd.arange(2).reshape((1, 2))
A, B
//Out
(
 [[0.]
  [1.]
  [2.]]
 <NDArray 3x1 @cpu(0)>, ---第一个矩阵，3行1列
 [[0. 1.]]
 <NDArray 1x2 @cpu(0)>)---第二个矩阵，两个元素，1行2列
 //执行按元素加
 A+B  ---此时A的第一列复制到第二列，变成3行2列，B的第一行复制到第二行和第三行，也变成3行2列
 //OUt
 [[0. 1.]
 [1. 2.]
 [2. 3.]]
<NDArray 3x2 @cpu(0)>

索引

索引（index）代表元素的位置，从0开始递增

//截取索引值为1-3，按照左闭右开，取出索引为1和2的两行
X[1:3]
//Out
[[ 4.  5.  6.  7.]
 [ 8.  9. 10. 11.]]
<NDArray 2x4 @cpu(0)>

//指定某元素的值
X[1, 2] = 9  ---第2行第3列元素设置为0
X
//Out
[[ 0.  1.  2.  3.]
 [ 4.  5. 9.  7.]
 [ 8.  9. 10. 11.]]
<NDArray 3x4 @cpu(0)>

//截取一部分元素，重新赋值
X[1:2, :] = 12   ---行索引为1-2，即第2行，逗号右边的冒号表示给所有列
X
//Out
[[ 0.  1.  2.  3.]
 [12. 12. 12. 12.]
 [ 8.  9. 10. 11.]]
<NDArray 3x4 @cpu(0)>

运算的内存开销

使用Python自带的id函数检查实例的ID是否一致

//id函数检查
before = id(Y)
Y = Y + X  ---即使做了这样的运算并在赋值给矩阵Y，仍然会有新的ID，即新的内存
id(Y) == before
//Out
False

想指定结果到特定内存，使用索引指定的方式，但是在计算中，开了临时内存放置计算结果，在复制到对应矩阵

//索引替换，id函数检查
Z = Y.zeros_like()   ---定义一个元素为0的矩阵，其形式和Y完全相同
before = id(Z)  --得到z的内存
Z[:] = X + Y  ---通过索引方式，将X+Y的值赋值给Z
id(Z) == before  --判断之前的Z的内存和之后的内存是否一致
//Out
True

想避免这个临时内存开销，我们可以使用运算符全名函数中的out参数。调用NDArray模块的方法elemwise_add(),指定参数out,意为将相加的结果直接复制到out对应参数的中,中间避免了临时空间的开销。

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

NDArray和NumPy相互变换

通过array函数和asnumpy函数令数据在NDArray和NumPy格式之间相互变换。

//
import numpy as np
P = np.ones((2, 3))   --numpy的数组
print("numpy array:" , P)
D = nd.array(P)
D
//Out
numpy array: [[1. 1. 1.]
 [1. 1. 1.]]
ndarray: 
[[1. 1. 1.]
 [1. 1. 1.]]
<NDArray 2x3 @cpu(0)>
//变换会numpy
D.asnumpy()
//Out
array([[1., 1., 1.],
       [1., 1., 1.]], dtype=float32)