矩阵系列知识摘记

矩阵基本运算

1、单位矩阵

单位矩阵是一个特殊的方阵，其主对角线上的元素全为1，而其他元素全为0。单位矩阵通常用符号 I 或 E 表示。
单位矩阵在矩阵运算中类似于数字1 在乘法中的作用，即任何矩阵与单位矩阵相乘，都等于原矩阵。
$$I_n=\left[\begin{array}{ccccc}1& 0& 0& ...& 0\\ 0& 1& 0& ...& 0\\ 0& 0& 1& ...& 0\\ ...& ...& ...& ...& 0\\ 0& 0& 0& ...& 1\end{array}\right]$$

方阵：当矩阵的行数和列数目相等时，可以称之为方阵。方阵是一种特殊的矩阵。

2、矩阵的加法和减法

两个同型（行数和列数相同）的矩阵可以进行加法和减法运算，其结果是一个同型矩阵，它的每个元素的值等于前面两个矩阵对应位置的元素的和或者差。

加法公式
$$\left[\begin{array}{cccc}{a}_{11}& a_{12}& ...& a_{1n}\\ a_{21}& a_{22}& ...& a_{2n}\\ ...& & & \\ a_{m1}& a{b}_{m2}& ...& a_{mn}\end{array}\right]+\left[\begin{array}{cccc}{b}_{11}& b_{12}& ...& b_{1n}\\ b_{21}& b_{22}& ...& b_{2n}\\ ...& & & \\ b_{m1}& b_{m2}& ...& b_{mn}\end{array}\right]=\left[\begin{array}{cccc}{a}_{11}+b_{11}& a_{12}+b_{12}& ...& a_{1n}+b_{1n}\\ a_{21}+b_{21}& a_{22}+b_{22}& ...& a_{2n}+b_{2n}\\ ...& & & \\ a_{m1}+b_{m1}& a_{m2}+b_{m2}& ...& a_{mn}+b_{mn}\end{array}\right]$$

减法公式
$$\left[\begin{array}{cccc}{a}_{11}& a_{12}& ...& a_{1n}\\ a_{21}& a_{22}& ...& a_{2n}\\ ...& & & \\ a_{m1}& a_{m2}& ...& a_{mn}\end{array}\right]-\left[\begin{array}{cccc}{b}_{11}& b_{12}& ...& b_{1n}\\ b_{21}& b_{22}& ...& b_{2n}\\ ...& & & \\ b_{m1}& b_{m2}& ...& b_{mn}\end{array}\right]=\left[\begin{array}{cccc}{a}_{11}-b_{11}& a_{12}-b_{12}& ...& a_{1n}-b_{1n}\\ a_{21}-b_{21}& a_{22}-b_{22}& ...& a_{2n}-b_{2n}\\ ...& & & \\ a_{m1}-b_{m1}& a_{m2}-b_{m2}& ...& a_{mn}-b_{mn}\end{array}\right]$$

在numpy中的计算如下：

a = np.array([[1, 2], [3, 4]])  
print(a) 输出如下
[[1 2]
 [3 4]]
 
 b = np.eye(2, 2, dtype=np.int16)  
print(b) 输出如下
[[1 0]
 [0 1]]
 
print(a + b)  
[[2 2]
 [3 5]]
 
print(a-b)
[[0 2]
 [3 3]]

3、矩阵的数乘

与向量类似，一个数（标量）也可以跟一个矩阵相乘，其结果是一个矩阵，其中各个元素的值等于该数乘以原来矩阵中对应位置的值。

$$k\ast \left[\begin{array}{cccc}{a}_{11}& a_{12}& ...& a_{1n}\\ a_{21}& a_{22}& ...& a_{2n}\\ ...& & & \\ a_{m1}& a_{m2}& ...& a_{mn}\end{array}\right]=\left[\begin{array}{cccc}k\ast a_{11}& k\ast a_{12}& ...& k\ast a_{1n}\\ k\ast a_{21}& k\ast a_{22}& ...& k\ast a_{2n}\\ ...& & & \\ k\ast a_{m1}& k\ast a_{m2}& ...& k\ast a_{mn}\end{array}\right]$$

在numpy中的计算如下：

a = np.array([[1, 2], [3, 4]])  
print(a) 输出如下
[[1 2]
 [3 4]]
 
 b = np.eye(2, 2, dtype=np.int16)  
print(b) 输出如下
[[1 0]
 [0 1]]
 
print(10 * a)
[[10 20]
 [30 40]]

4、矩阵的点乘

矩阵的点乘也称之为矩阵的相乘。

两个矩阵，当第一个矩阵的列数与第二个矩阵的行数相等时，可以用第一个矩阵点乘第二个矩阵，其结果是一个新的矩阵，它的行数是第一个矩阵的行数，列数是第二个矩阵的列数。它的位与第 i 行第 j 列的元素，等于第一个矩阵的第 i 行（它是一个向量）与第二个矩阵的第 j 列（它也是一个向量）这两个向量的内积。

向量内积（点乘/点积/数量积）：两个向量对应元素相乘之后求和。

$$\begin{gathered} a=[a_1,a_2,...,a_n] \\ b=[b_1,b_2,...,b_n] \\ a\ast b=a_1\ast b_1+a_2\ast b_2+...+a_n\ast b_n \end{gathered}$$

矩阵可以看成是多维的向量，即单个向量的叠加。

矩阵点乘的意义:

矩阵点乘的意义有很多，此处仅简述矩阵在人工智能领域的意义。矩阵点乘最大的意义在于计算两个矩阵的相似度。

$$余弦相似度cos\theta =\frac{A、B矩阵相乘}{A向量长度\ast B向量长度}$$
$cos\theta$ 越大，说明A、B两个矩阵越相似
A、B矩阵相乘 = A向量长度 x B向量长度 x $cos\theta$ = A向量长度 x B向量在A向量上的投影长度

$$\left[\begin{array}{cccc}{a}_{11}& a_{12}& ...& a_{1n}\\ a_{21}& a_{22}& ...& a_{2n}\\ ...& & & \\ a_{m1}& a_{m2}& ...& a_{mn}\end{array}\right]\ast \left[\begin{array}{cccc}{b}_{11}& b_{12}& ...& b_{1n}\\ b_{21}& b_{22}& ...& b_{2n}\\ ...& & & \\ b_{m1}& b_{m2}& ...& b_{mn}\end{array}\right]=\left[\begin{array}{cccc}{c}_{11}& c_{12}& ...& c_{1n}\\ c_{21}& c_{22}& ...& c_{2n}\\ ...& & & \\ c_{m1}& c_{m2}& ...& c_{mn}\end{array}\right]$$

$$\begin{gathered} c_{11}=a_{11}\ast b_{11}+a_{12}\ast b_{21}+..+a_{1n}\ast b_{m1} \\ {c}_{12}=a_{11}\ast b_{12}+a_{12}\ast b_{22}+..+a_{1n}\ast b_{m2} \\ ... \\ {c}_{1n}=a_{11}\ast b_{1n}+a_{12}\ast b_{2n}+..+a_{1n}\ast b_{mn} \\ 其他以此类推 \end{gathered}$$

举例如下：

$$\left[\begin{array}{cc}1& 2\\ 3& 4\end{array}\right]\ast \left[\begin{array}{cc}5& 6\\ 7& 8\end{array}\right]=\left[\begin{array}{cc}19& 22\\ 43& 50\end{array}\right]$$

19 = 1*5 + 2*7
22 = 1*6 + 2*8
43 = 3*5 + 4*7
50 = 3*6 + 4*8

在numpy中的计算如下：

# a · b = a[0] * b[0] + a[1] * b[1] + ... + a[n] * b[n]
# 一维矩阵相乘
a = [1, 2, 3]
b = [1, 0, 2]
print(np.dot(a, b))  # 7

# 二维矩阵相乘
a = [[1, 0], [0, 1]]
b = [[4, 1], [2, 2]]
print(np.dot(a, b))
# [[4 1]
#  [2 2]]

5、矩阵的转置

矩阵的转置是一个矩阵，它的第 i 行 第 j 列的值等于原矩阵的第 j 行第 i 列的值。矩阵A的转置用$A^T$表示。
$${\left[\begin{array}{cccc}{a}_{11}& a_{12}& ...& a_{1n}\\ a_{21}& a_{22}& ...& a_{2n}\\ ...& & & \\ a_{m1}& a{b}_{m2}& ...& a_{mn}\end{array}\right]}^T=\left[\begin{array}{cccc}{a}_{11}& a_{21}& ...& a_{m1}\\ a_{12}& a_{22}& ...& a_{m2}\\ ...& & & \\ a_{1n}& a{b}_{2n}& ...& a_{mn}\end{array}\right]$$

在numpy中的计算如下：

数组转置是一个常见的线性代数操作，它指的是将数组的行变为列，列变为行。在编程中，特别是在处理矩阵或二维数组时，这个操作非常有用

ndarray.T

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

6、矩阵的逆

矩阵的逆类似于数的倒数，矩阵A的逆用$A^{-1}$表示。
如果一个n阶方阵A，存在另一个n阶方阵B，使得 A * B = B * A = E，则称方针B为矩阵A的逆，或者称矩阵B为矩阵A的逆矩阵。如果矩阵A的逆矩阵存在，则称矩阵A是可逆矩阵。

矩阵A的逆矩阵的转置等于矩阵A的转置的逆，即$(A^{-1}{)}^T$ = $(A^T{)}^{-1}$

矩阵的逆的意义：
解决“矩阵除法”问题：由于矩阵本身没有除法的概念，但有时需要在矩阵运算中进行类似除法的操作。矩阵的逆就是用来解决这种“矩阵除法”问题的。例如，如果我们要计算 (X \times A = B)，并且 (A) 是可逆的，那么可以通过左乘 $A^{-1}$ 来得到 (X = B \times $A^{-1}$)。

在numpy中的计算如下：

# 定义一个矩阵
matrix = np.array([[1, 2], [3, 4]])
print(matrix)

# [[1 2]
#  [3 4]]
# 求矩阵的逆
inverse_matrix = np.linalg.inv(matrix)

print(inverse_matrix)
# [[-2.   1. ]
#  [ 1.5 -0.5]]