深度学习--第3篇: Numpy

1. Numpy常用属性

ndim：维度
shape：行数和列数
size：元素个数

使用numpy首先要导入模块

import numpy as np

2. 创建矩阵

2.1 array创建矩阵

对于python中的numpy模块，一般用其提供的ndarray对象。 创建一个ndarray对象很简单，只要将一个list作为参数即可。其中维度与中括号个数直接相关. 数据类型默认 np.float64

# 创建一维数组
a = np.array([1,2,3,4,5,6])  # (6,)

# 创建二维数组,注意中括号数量
b1 = np.array([[1,2,3],[4,5,6]]) # (2,3)
b2 = np.array([[1,2,3,4,5,6]])   # (1,6)

2.1 获取矩阵属性

# ndim属性.矩阵维度
print(a.ndim) # 1
print(b1.ndim) # 2

# shape属性,矩阵行列数 (行数,列数)
print(a.shape) # (6,)
print(b1.shape) # (2,3)

print(b1.shape[0]) # 2
print(b1.shape[1]) # 3 

# size属性,矩阵大小
print(a.size) # 6
print(b1.size) # 6

2.2 创建矩阵关键字

关键字:

• zeros : 创建的数据全为0
• ones : 创建的数据全为1
• eye : 创建单位矩阵
• empty : 创建空矩阵(实际有值)
• dtype : 数据类型,默认是 np.float64, 包括np.int8, np.int16, np.int64, np.uint8, np.uint16, np.float32等

# 创建全为0的矩阵
a_zero = np.zeros([2,3])

# 创建全1矩阵
a_one = np.ones([3,2])

# 创建单位矩阵,方阵
a_eye = np.eye(3)

# 创建空矩阵
a_empty = np.empty([3,4])

# 创建int类型的矩阵
a_int = np.ones([2,3], dtype = np.int)

2.3 创建随机矩阵

• 创建一个2*3的在0~1范围内的均匀分布的随机数组

a_rand = np.random.rand(2,3)

• 创建一个2*3均值为0，标准差为1的正态分布的随机数数组

a_normal = np.random.normal(0,1,(2,3))

• 创建一个2*3均值为0，标准差为1的正态分布的随机数数组

a_randn = np.random.randn(2,3)

• 随机打乱矩阵顺序

x = np.array([3,5,1,2,8])  # (5,)
np.random.shuffle(x)   # 打乱顺序后  [3 8 1 5 2]

2.4 改变矩阵形状

• 前提条件: 改变前后矩阵的行数与列数之积相等
• 函数: reshape(行数,列数)
• 如果在 reshape 操作中将 size 指定为-1，则会自动计算其他的 size 大小

a = np.array([[1,2,3],
              [4,5,6]])  # (2,3) 
print(a.reshape(3,2))  # 转换原始矩阵形状 (3,2)
# 结果
[[1 2]
 [3 4]
 [5 6]]

print(a.reshape(-1,2))  # 转换原始矩阵形状 (3,2)

3. 矩阵的运算

3.1 常规运算

numpy中的ndarray对象重载了许多运算符，使用这些运算符可以完成矩阵间对应元素的运算。

运算符	说明
+	矩阵对应元素相加
-	矩阵对应元素相减
*	矩阵对应元素相乘
/	矩阵对应元素相除，如果都是整数则取商
%	矩阵对应元素相除后取余数
**	矩阵每个元素都取n次方，如**2：每个元素都取平方

a1 = np.array([[4,5,6],[1,2,3]])
a2 = np.array([[6,5,4],[3,2,1]])

print(a1+a2) # 相加
# 结果
[[10 10 10]
 [ 4  4  4]]

print(a1*a2) # 相乘
# 结果
[[24 25 24]
 [ 3  4  3]]
 
print(a1/a2) # 整数相除取商
# 结果
[[0 1 1]
 [0 1 3]]

print(a1%a2) # 相除取余数
# 结果
[[4 0 2]
 [1 0 0]]

print(a1**3) # 3次乘方
# 结果
[[ 64 125 216]
 [  1   8  27]]

3.2 矩阵的乘法(点乘)

• 点乘前提条件: 即第一个矩阵的列数等于第二个矩阵的行数.
• 矩阵乘法的函数为 dot

a1 = np.array([[1,2,3],
			   [4,5,6]])   # (2,3)
a2 = np.array([[1,2],
			   [3,4],
			   [5,6]]) # (3,2)
print(a1.dot(a2))   # 结果维度 (2,2)

# 结果
[[22 28]
 [49 64]]

3.3 矩阵的转置

• 矩阵转置函数: transpose()
  a.transpose() 等价于 a.T

a = np.array([[1,2,3],
              [4,5,6]])  # (2,3)
print(a.transpose())   # (3,2)
print(a.T)

3.4 矩阵的逆

• 矩阵求逆的条件是矩阵的行数和列数相同(方阵)
• 求矩阵的逆需要先导入numpy.linalg，用linalg的inv函数来求逆

import numpy.linalg as lg

a = np.array([[1,2],[2,3]])  # (2,2)

print(lg.inv(a))
# 结果
[[-3.  2.]
 [ 2. -1.]]

3.5 常用矩阵函数

numpy中也定义了许多函数，使用这些函数可以将函数作用于矩阵中的每个元素。

矩阵函数	说明
np.sin(a)	对矩阵a中每个元素取正弦,sin(x)
np.cos(a)	对矩阵a中每个元素取余弦,cos(x)
np.tan(a)	对矩阵a中每个元素取正切,tan(x)
np.exp(a)	对矩阵a中每个元素取指数函数,ex
np.sqrt(a)	对矩阵a中每个元素开根号√x

4. 获取矩阵信息

通过指定axis关键字，获取矩阵在某一方向的信息.

二维axis值:

• axis = 0 : 列方向 获取矩阵信息
• axis = 1 : 行方向 获取矩阵信息

三维axis值:

• axis = 0 : 高度方向 获取矩阵信息
• axis = 1 : 列方向 获取矩阵信息
• axis = 2 : 行方向 获取矩阵信息

4.1 获取最值

获得矩阵中元素最大最小值的函数分别是max和min，可以获得整个矩阵、行或列的最大最小值.

# 对于2维矩阵
a = np.array([[1,2,3],
              [4,5,6]])  # (2,3)
print(a.max())   # 结果为6
print(a.min())   # 结果为1

# 可以指定axis关键字，获取行或列的最大、最小值
print(a.max(axis=0))  # 列最大值 [4 5 6]
print(a.max(axis=1))  # 行最大值 [3 6]

# 对于3维矩阵
b = np.array([ [[1,2,3],[4,5,6]],
			   [[7,8,9],[6,6,6]] ])  # (2,2,3)
# 高度方向最大值
print(b.max(axis=0)) 
# 结果
[[7 8 9]
 [6 6 6]]
 
# 列方向最大值
print(b.max(axis=1))
# 结果
[[4 5 6]
 [7 8 9]]
 
# 行方向最大值
print(b.max(axis=2))
# 结果
[[3 6]
 [9 6]]

4.2 获取平均值

获得矩阵中元素的平均值可以通过函数mean(), 可以获得整个矩阵、行或列的平均值.

a = np.array([[1,2,3],
              [4,5,6]]) # (2,3)
print(a.mean())       # 结果为3.5
print(a.mean(axis=0)) # 列方向的平均值 [2.5 3.5 4.5]
print(a.mean(axis=1)) # 行方向的平均值 [2. 5.]

4.3 获取方差

获取方差的函数为var().
方差函数var()相当于函数mean(abs(x - x.mean())**2),其中x为矩阵.

a = np.array([[1,2,3],
              [4,5,6]])  # (2,3)
print(a.var())    # 结果 2.9166666666666665
print(a.var(axis=0))  # 列方向的方差 [2.25 2.25 2.25]
print(a.var(axis=1))  # 行方向的方差 [0.66666667 0.66666667]

4.4 获取标准差

标准差的函数为std().
std()相当于sqrt(mean(abs(x - x.mean())**2))，或相当于sqrt(x.var()).

a = np.array([[1,2,3],
              [4,5,6]])  # (2,3)
print(a.std())    # 结果 1.707825127659933
print(a.std(axis=0))  # 列方向的标准差 [1.5 1.5 1.5]
print(a.std(axis=1))  # 行方向的标准差 [0.81649658 0.81649658]

4.5 矩阵求和

矩阵求和的函数是sum()，可以对行，列，或整个矩阵求和.

a = np.array([[1,2,3],
              [4,5,6]])  # (2,3)
print(a.sum())  # 结果21
print(a.sum(axis=0))  # 列方向求和 [5 7 9]
print(a.sum(axis=1))  # 行方向求和 [6 15]

4.6 矩阵累积求和

某位置累积和指的是该位置之前(包括该位置)所有元素的和.
矩阵求累积和的函数是cumsum()，可以对行，列，或整个矩阵求累积和.

a = np.array([[1,2,3],
              [4,5,6]])  # (2,3)
print(a.cumsum())  # 对整个矩阵求累积和 [1 3 6 10 15 21]

print(a.cumsum(axis=0))  # 列方向求累积和
# 结果
[[1 2 3]
 [5 7 9]]

print(a.cumsum(axis=1))  # 对列方向求累积和
# 结果
[[ 1  3  6]
 [ 4  9 15]]

5. 矩阵截取

5.1 按照行列截取

矩阵的截取和list相同，可以通过 [ ]（方括号）来截取.

a = np.array([[1,2,3,4],
              [4,5,6,7]])  # (2,4)
print( a[0,:] )  # 获取第1行,所有列
print( a[1,:] )  # 获取第2行,所有列
print( a[:,1] )  # 获取第2列,所有行
print( a[1,0:2] )  # 获取第2行,第1,2列的数据

5.2 按照条件截取

按条件截取应用较多的是对矩阵中满足一定条件的元素变成特定的值.
例如: 将矩阵中大于5的元素变成0

a = np.array([[1,2,3,4],
              [4,5,6,7]])  # (2,4)
a[a>5] = 0  # 将a中大于5的元素变为0
print(a)
# 结果
[[1 2 3 4]
 [4 5 0 0]]

6. 矩阵合并

矩阵的合并可以通过numpy中的hstack方法和vstack方法实现.

• hstack : 横向合并
• vstack : 纵向合并

a1 = np.array([[1,2],[3,4]])  # (2,2)
a2 = np.array([[5,6],[7,8]])  # (2,2)

print(np.hstack([a1,a2])) # 横向合并 (2,4)
# 结果
[[1 2 5 6]
 [3 4 7 8]]

print(np.vstack([a1,a2]))  # 纵向合并 (4,2)
# 结果
[[1 2]
 [3 4]
 [5 6]
 [7 8]]

矩阵的合并也可以通过concatenatef方法.

np.concatenate( (a1,a2), axis=0 )   # 列方向合并
等价于  np.vstack( (a1,a2) )

np.concatenate( (a1,a2), axis=1 )   # 行方向合并
等价于  np.hstack( (a1,a2) ) 

7. arg系列索引函数

numpy中arg系列函数被经常使用，通常先进行排序然后返回原数组特定的索引.

• argmax : 将数组排序后返回数组元素从小到大依次排序的, 原数组中的最大元素索引;
• argmin : 将数组排序后返回数组元素从小到大依次排序的, 原数组中的最小元素索引;
• argsort : 将数组排序后返回数组元素从小到大依次排序的, 原数组中的所有元素索引;
• argsort表示升序排序, 如果使用降序排序, 则讲原始数据添加负号即可;

a = np.array([[1,2,3,4],
              [4,5,6,7]])  # (2,4)
print(np.argmax(a))  # 最大元素索引 7
print(np.argmin(a))  # 最小元素索引 0
print(np.argsort(a)) # 排序后索引 
# 结果
[[0 1 2 3]
 [0 1 2 3]]

print(np.argmax(a,axis=0)) # 列方向最大元素索引 [1 1 1 1]
print(np.argmax(a,axis=1)) # 行方向最大元素索引 [3 3]

• 实例: 给定一矩阵,将其按照第2行元素从小到大的顺序,重新给矩阵排序.

b = np.array( [ [5,6,1,3,7],[1,6,4,3,8],
				[2,5,6,4,3], [4,2,3,1,5] ])  # (4,5)
# 原始数据
[[5 6 1 3 7]
 [1 6 4 3 8]
 [2 5 6 4 3]
 [4 2 3 1 5]]

inds = np.argsort( b[1,:] ) # 排序查询索引  [0 3 2 1 4]
c = b[:,inds]     # 按照排序后的索引排序
# 按照第2行从小到大顺序的排序结果
[[5 3 1 6 7]
 [1 3 4 6 8]
 [2 4 6 5 3]
 [4 1 3 2 5]]

inds = np.argsort( -b[1,:] ) # 添加负号,从大到小排序查询索引  [0 3 2 1 4]
c = b[:,inds]     # 按照排序后的索引排序,从大到小排序
# 按照第2行从大到小顺序的排序结果
[[7 6 1 3 5]
 [8 6 4 3 1]
 [3 5 6 4 2]
 [5 2 3 1 4]]

8. 索引

8.1 常规索引

索引序号从0开始，并接受从数组末尾开始索引的负索引。

• 正索引 : 0 到 (size-1)
• 负索引 : -1 到 -size

a = np.array([[1,2,3,4],
              [4,5,6,7]])  # (2,4)
print( a[0, 0] )  # 第1行,第1列元素索引 1
print( a[0,-1] )  # 第1行,倒数第1列元素 4

print( a[-2,:] )  # 倒数第2行的元素 [1 2 3 4]
print( a[:,-3] )  # 倒数第3列的元素 [2 5]

8.2 多维数组索引

多维索引数组必须是整数类型。数组中的每个值指示要使用的数组中的哪个值代替索引。

a = np.array([[1,2,3,4],
              [4,5,6,7]])  # (2,4)
b = a[:,[2,0,1]]  # 将a的第3列,1列,2列按顺序赋给b
# 结果
[[3 1 2]
 [6 4 5]]

9. 后续计划

后续开始Pytorch的学习,包括完成简单的网络搭建,数据集的读取和划分(训练,验证,测试),以及如何训练,测试网络,编写损失函数等.