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

创建矩阵

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

向量

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

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

# 计算均值
np.mean(matrix)
>>> 6.5
# 计算方差
np.var(matrix)
>>> 11.916666666666666
# 计算标准差
np.std(matrix)
>>> 3.4520525295346629

重塑矩阵

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

矩阵加减法

# 创建矩阵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]])

对矩阵元素进行操作

# 创建一个方法：对每个元素加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]])

创建稀疏矩阵

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

描述一个矩阵

# 查看行和列
matrix.shape
>>> (4, 3)
# 查看所有元素个数（行*列）
matrix.size
>>> 12
# 查看维数
matrix.ndim
>>> 2

最大值和最小值

# 最大值
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])

矩阵求逆

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

展平矩阵

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

元素选择

# 对一个向量
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])

计算矩阵点乘（对应位置相乘之后再相加）

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）

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

矢量或矩阵转置

# 创建一个矢量
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/