小白的机器学习实战——向量,矩阵和数组

创建矩阵

1
2
3
4
5
6
import numpy as np
# 创建矩阵
matrix = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9],
[10, 11, 12]])

向量

1
2
3
4
5
6
# 行向量
vector_row = np.array([1, 2, 3])
# 列向量
vector_column = np.array([[1],
[2],
[3]])

计算平均值,方差和标准偏差

1
2
3
4
5
6
7
8
9
# 计算均值
np.mean(matrix)
>>> 6.5
# 计算方差
np.var(matrix)
>>> 11.916666666666666
# 计算标准差
np.std(matrix)
>>> 3.4520525295346629

重塑矩阵

1
2
3
4
5
# 第二维可以为-1让程序自己推断,如matrix.reshape(2, -1)
matrix.reshape(2, 6)
>>> array([[ 1, 2, 3, 4, 5, 6],
[ 7, 8, 9, 10, 11, 12]])

矩阵加减法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 创建矩阵a
matrix_a = np.array([[1, 1, 1],
[1, 1, 1],
[1, 1, 2]])

# 创建矩阵b
matrix_b = np.array([[1, 3, 1],
[1, 3, 1],
[1, 3, 8]])

# 矩阵相加
np.add(matrix_a, matrix_b)
array([[ 2, 4, 2],
[ 2, 4, 2],
[ 2, 4, 10]])

# 矩阵相减
np.subtract(matrix_a, matrix_b)
array([[ 0, -2, 0],
[ 0, -2, 0],
[ 0, -2, -6]])

对矩阵元素进行操作

1
2
3
4
5
6
7
8
9
10
11
12
# 创建一个方法:对每个元素加10
add_100 = lambda i: i + 10

# 在对numpy的数组进行操作时,我们应该尽量避免循环操作,尽可能利用矢量化函数来避免循环。但是,直接将自定义函数应用在numpy数组之上会报错,我们需要将函数进行矢量化转换.
vectorized_add_100 = np.vectorize(add_100)

# 最后将函数应用到矩阵上
vectorized_add_100(matrix)
>>> array([[11, 12, 13],
[14, 15, 16],
[17, 18, 19],
[20, 21, 22]])

创建稀疏矩阵

1
2
3
4
5
6
7
8
9
# 创建一个矩阵,其中零元素远远多于非零元素
matrix = np.array([[0, 0],
[1, 0],
[0, 6]])
# 由于稀疏矩阵中非零元素较少,零元素较多,因此可以采用只存储非零元素的方法来进行压缩存储。
# 另外对于很多元素为零的稀疏矩阵,仅存储非零元素可使矩阵操作效率更高,速度更快。
# python不能自动创建稀疏矩阵,所以要用scipy中特殊的命令来得到稀疏矩阵。
from scipy import sparse
matrix_sparse = sparse.csr_matrix(matrix)

描述一个矩阵

1
2
3
4
5
6
7
8
9
# 查看行和列
matrix.shape
>>> (4, 3)
# 查看所有元素个数(行*列)
matrix.size
>>> 12
# 查看维数
matrix.ndim
>>> 2

最大值和最小值

1
2
3
4
5
6
7
8
9
10
11
12
# 最大值
np.max(matrix)
>>> 12
# 最小值
np.min(matrix)
>>> 1
# 按列查找最大元素
np.max(matrix, axis=0)
>>> array([10, 11, 12])
# 按行查找最大元素
np.max(matrix, axis=1)
>>> array([3, 6, 9,12])

矩阵求逆

1
2
3
4
5
6
7
# 创建一个新矩阵
matrix_n = np.array([[1, 2],
[3, 4]])
# 计算逆矩阵
np.linalg.inv(matrix_n)
>>> array([[-2. , 1. ],
[ 1.5, -0.5]])

展平矩阵

1
2
matrix.flatten()
>>> array([1, 2, 3, 4, 5, 6, 7, 8, 9])

元素选择

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 对一个向量
vector = np.array([1, 2, 3, 4, 5, 6])
vector[1]
>>> 2
# 对于一个矩阵
matrix = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
matrix[1,1]
>>> 5
对于一个张量(高维矩阵)
tensor = np.array([
[[[1, 1], [1, 1]], [[2, 2], [2, 2]]],
[[[3, 3], [3, 3]], [[4, 4], [4, 4]]]
])
tensor[1,1,1]
>>> array([4, 4])

计算矩阵点乘(对应位置相乘之后再相加)

1
2
3
4
5
6
7
8
vector_a = np.array([1,2,3])
vector_b = np.array([4,5,6])
# 方法一
np.dot(vector_a, vector_b)
>>> 32
# 方法二
vector_a @ vector_b
>>> 32

计算矩阵的行列式(The Determinant Of A Matrix)、矩阵的迹(The Trace Of A Matrix)和矩阵的秩(The Rank Of A Matrix)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
matrix = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
# 行列式:行列式(Determinant)是数学中的一个函数,将一个 n*n的矩阵A映射到一个标量,记作det(A)或|A|
np.linalg.det(matrix)
>>> -9.5161973539299405e-16

# 迹:在线性代数中,一个n×n矩阵A的主对角线(从左上方至右下方的对角线)上各个元素的总和被称为矩阵A的迹(或迹数),一般记作tr(A)。
# 先获得矩阵的对角线
matrix.diagonal()
>>> array([1, 5, 9])
# 对角线求和就是迹
matrix.diagonal().sum()
>>> 15
# 秩:在线性代数中,一个矩阵A的列秩是A的线性独立的纵列的极大数目。
np.linalg.matrix_rank(matrix)
>>> 2

矢量或矩阵转置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 创建一个矢量
vector = np.array([1, 2, 3, 4, 5, 6])
# 转置
vector.T
>>> array([1, 2, 3, 4, 5, 6])

# 创建一个矩阵
matrix = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
# 转置
matrix.T
>>> array([[1, 4, 7],
[2, 5, 8],
[3, 6, 9]])

参考:https://chrisalbon.com/