赵走x博客 - 开发者的网上家园

机器学习的数学基础：矩阵篇

资源编号:570042 热度：90

# 前言
机器学习如火如荼，要学习机器学习，数学基础少不了。所以本系列将对机器学习所用到的线性代数、微积分和概率统计的基础知识做一个简单的概括。

本文将总结线性代数中矩阵的基本知识点。同时理论结合实践，使用 Python 来进行实践。如果需要跟着进行编程实践，请先确保下列环境已安装：

* Python - 编程实践所使用的语言；
* Numpy - Python 的数值计算库。

矩阵（Matrix）是人为约定的一种数据的表示方法，在图像处理、人工智能等领域，使用矩阵来表示和处理数据非常常见。一个矩阵的举例：

![](http://oldmark.oss-cn-beijing.aliyuncs.com/2023/12/18/b67f5a1a-9d54-11ee-a007-0242ac180005/f64be3933fd94da9abc09ede66745506.png)
其中，矩阵 A的下标 2×3表示 A是一个 2 行 3 列的矩阵。类似的，另一个示例：

![](http://oldmark.oss-cn-beijing.aliyuncs.com/2023/12/18/c3fab568-9d54-11ee-8d7d-0242ac180005/a0527b16107b493ba645d88dc428f58f.png)
再看回矩阵 A，如果要表示第 2 行的第 2 个元素 3 ，可以使用 A[2,2]或 a2,2。

Python 的 Numpy 库提供了 ndarray 类用于存储高维数组及普通的数组运算，另外提供 matrix 类用来支持矩阵运算。使用 Python 创建矩阵很简单：
```
import numpy as np
a = np.matrix('5 2 7;1 3 4')
b = np.matrix('5 2 7 6;1 3 4 2;8 2 -2 3')
```
也可以用下面这种形式：

```
import numpy as np
a = np.matrix([[5,2,7],[1,3,4]])
b = np.matrix([[5,2,7,6],[1,3,4,2],[8,2,-2,3]])
```
两种形式完全等效。但第一种更简明直观，不容易犯错。因此推荐第一种方式。

要把一个 matrix 对象转换为 ndarray 对象，可以直接用 getA() 方法。而把 ndarray 对象转成 matrix 对象可以用 asmatrix() 方法。

```
>>> b = a.getA()
>>> print b
[[5 2 7]
 [1 3 4]]
>>> type(b)
<type 'numpy.ndarray'>
>>> c = np.asmatrix(b)
>>> print c
[[5 2 7]
 [1 3 4]]
>>> type(c)
<class 'numpy.matrixlib.defmatrix.matrix'>
```
要取出矩阵中的某个值，可以使用类似数组的下标运算符。但要注意的是，计算机是以 0 开始计数的。例如，要取出 A[2,2]
 ，应该使用：

```
>>> a[1,1]
a[1,1]
3
```

# 基本运算

#### 加
![](http://oldmark.oss-cn-beijing.aliyuncs.com/2023/12/18/f0fd8a86-9d54-11ee-abc8-0242ac180005/df5771dd2b284d238c32ddbd370eadbd.png)
要注意两个矩阵的行数和列数必须相同，否则无定义。

Python 示例：

```
>>> a = np.matrix('1 0 1;1 2 1;2 1 1')
a = np.matrix('1 0 1;1 2 1;2 1 1')
>>> b = np.matrix('2 1 -1;0 -1 2;2 -1 0')
b = np.matrix('2 1 -1;0 -1 2;2 -1 0')
>>> a + b
a + b
matrix([[3, 1, 0],
        [1, 1, 3],
        [4, 0, 1]])
```
很容易看出，矩阵的加法满足交换律和结合律，即 A+B=B+A， (A+B)+C=A+(B+C)。

###减
矩阵减法也和加法一样简单。对于上面给出的 A和 B，有：

![](http://oldmark.oss-cn-beijing.aliyuncs.com/2023/12/18/066a0dcc-9d55-11ee-9f66-0242ac180005/c6765b4ad6224b4c8c640a08867f828f.png)

同样，相减的两个矩阵行数和列数必须完全相同，否则无定义。

Python 示例：

```
>>> a - b
a - b
matrix([[-1, -1,  2],
        [ 1,  3, -1],
        [ 0,  2,  1]])
```
### 乘

![](http://oldmark.oss-cn-beijing.aliyuncs.com/2023/12/18/53a98eaa-9d55-11ee-aac7-0242ac180005/39d95d8aceb64f61b349253ae4715cb8.png)

与初等代数的乘法不同，矩阵的乘法并不满足交换律，即 A×B≠B×A。但满足分配律，即 (A×B)×C=A×(B×C)。

再介绍两个特殊的矩阵：

* 单元矩阵 I。它的特点是行数列数相等，且在对角线上值为 1，其他地方值为 0 。它的一个特性是与其他矩阵相乘都等于那个矩阵本身。一个 3×3
 的单元矩阵示例：
![](http://oldmark.oss-cn-beijing.aliyuncs.com/2023/12/18/65bef300-9d55-11ee-bedc-0242ac180005/d5c547b70c4e492283f8a1a94503bf32.png)
* 零矩阵。顾名思义就是全部元素都是 0 的矩阵。零矩阵乘以任何矩阵都为零矩阵，与任何矩阵相加都等于那个矩阵。

Python 示例：
```
>>> a * b
a * b
matrix([[ 4,  0, -1],
        [ 4, -2,  3],
        [ 6,  0,  0]])
>>> b * a
b * a
matrix([[ 1,  1,  2],
        [ 3,  0,  1],
        [ 1, -2,  1]])        
>>> c = np.matrix('5 7 2;4 3 1')
c = np.matrix('5 7 2;4 3 1')
>>> d = np.matrix('1;5;6')
d = np.matrix('1;5;6')
>>> c*d
c*d
matrix([[52],
        [25]])
>>> a * b * d
a * b * d
matrix([[-2],
        [12],
        [ 6]])
>>> a * (b * d)
a * (b * d)
matrix([[-2],
        [12],
        [ 6]])
>>> I = np.eye(3)  # 创建一个3阶单元矩阵
I = np.np.eye(3)
>>> a * I
a * I
matrix([[1, 0, 1],
        [1, 2, 1],
        [2, 1, 1]])
>>> I * a
I * a
matrix([[1, 0, 1],
        [1, 2, 1],
        [2, 1, 1]])
>>> a * z
a * z
matrix([[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]])
>>> b * z
b * z
matrix([[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]])
>>> c * z
c * z
matrix([[0, 0, 0],
        [0, 0, 0]])
```
注意上面创建单元矩阵用了 ‘eye()’ 函数，它等同于下面的写法：

```
>>> I = np.matrix('1 0 0;0 1 0;0 0 1')
```
### 除（求逆）
矩阵并没有一个直接叫除法的操作。但有个与之相似的运算，叫做求逆运算。
![](http://oldmark.oss-cn-beijing.aliyuncs.com/2023/12/18/8581906c-9d55-11ee-916b-0242ac180005/13f88ed2c5044c66b90ad03351ae09bc.png)

矩阵的求逆有很多种方法。常见的有伴随阵法、初等变换法、分块矩阵求逆法等。

##### 伴随阵法
![](http://oldmark.oss-cn-beijing.aliyuncs.com/2023/12/18/918bdfca-9d55-11ee-9e4c-0242ac180005/ada716aaf53b4f1d87ada5feb6d85bbe.png)

![](http://oldmark.oss-cn-beijing.aliyuncs.com/2023/12/18/9fbbc362-9d55-11ee-a028-0242ac180005/2a9615f30a0e4d2db8413d46698355e6.png)
![](http://oldmark.oss-cn-beijing.aliyuncs.com/2023/12/18/bc371abe-9d55-11ee-8f61-0242ac180005/ddfc7e3eafcc40599f1ace87ebcf5831.png)

##### 初等变换法
![](http://oldmark.oss-cn-beijing.aliyuncs.com/2023/12/18/c88ab62c-9d55-11ee-9693-0242ac180005/5e77b5486d744073b0c834aeaa41eeba.png)

![](http://oldmark.oss-cn-beijing.aliyuncs.com/2023/12/18/d605a104-9d55-11ee-885a-0242ac180005/6d90a54ce731408ebcef099226db09b0.png)

##### 奇异矩阵
![](http://oldmark.oss-cn-beijing.aliyuncs.com/2023/12/18/e31379ca-9d55-11ee-b26e-0242ac180005/ccb2bb5f00044593bd4407015c59ef3a.png)

Python 求逆示例：
```
>>> a = np.matrix('1 0 1; 1 2 1; 2 1 1')
a = np.matrix('1 0 1; 1 2 1; 2 1 1')
>>> a.I
a.I
matrix([[-0.5, -0.5,  1. ],
        [-0.5,  0.5,  0. ],
        [ 1.5,  0.5, -1. ]])
>>> a * a.I
a * a.I
matrix([[ 1.,  0.,  0.],
        [ 0.,  1.,  0.],
        [ 0.,  0.,  1.]]
>>> a.I * a
a.I * a
matrix([[ 1.,  0.,  0.],
        [ 0.,  1.,  0.],
        [ 0.,  0.,  1.]])
>>> f = np.matrix('0 1;0 0')
f = np.matrix('0 1;0 0')
>>> f.I
f.I
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/Library/Python/2.7/site-packages/numpy/matrixlib/defmatrix.py", line 972, in getI
    return asmatrix(func(self))
  File "/Library/Python/2.7/site-packages/numpy/linalg/linalg.py", line 526, in inv
    ainv = _umath_linalg.inv(a, signature=signature, extobj=extobj)
  File "/Library/Python/2.7/site-packages/numpy/linalg/linalg.py", line 90, in _raise_linalgerror_singular
    raise LinAlgError("Singular matrix")
numpy.linalg.linalg.LinAlgError: Singular matrix
```
### 矩阵的转置

![](http://oldmark.oss-cn-beijing.aliyuncs.com/2023/12/18/f7a39d84-9d55-11ee-bfe8-0242ac180005/36f8ba50fa12424990ecfc7783716127.png)

Python 示例：
```
>>> a = np.matrix('2 4;1 3')
>>> a.T
matrix([[2, 1],
        [4, 3]])
>>> b = np.matrix('1 2 3;4 5 6')
>>> b.T
matrix([[1, 4],
        [2, 5],
        [3, 6]])
```
矩阵的转置有一个性质：矩阵乘积的转置等于矩阵调换后分别做转置的乘积，即
![](http://oldmark.oss-cn-beijing.aliyuncs.com/2023/12/18/032d6536-9d56-11ee-a62c-0242ac180005/f6916033369f48c784b014452ec10146.png)
Python 示例：
```
>>> a = np.matrix('2 4;1 3')
>>> b = np.matrix('1 6;2 5')
>>> a*b
matrix([[10, 32],
        [ 7, 21]])
>>> b.T*a.T
matrix([[10,  7],
        [32, 21]])
```
# 应用举例
矩阵是一种非常通用的数据表示方法，只要能用矩阵来表示数据，就能够用矩阵的这套运算来解决问题。下面列举几种常见的数学问题，它们都能够使用矩阵的思路来解决。

### 求解方程组
例如一个二元方程组
![](http://oldmark.oss-cn-beijing.aliyuncs.com/2023/12/18/1563f1e8-9d56-11ee-bac2-0242ac180005/a562dbfaacc04865bd62b6816b80f370.png)

可以用矩阵表示成：
![](http://oldmark.oss-cn-beijing.aliyuncs.com/2023/12/18/1e037de6-9d56-11ee-8579-0242ac180005/dfea85fb0f5c41fcb16805989256f662.png)

![](http://oldmark.oss-cn-beijing.aliyuncs.com/2023/12/18/24c815c4-9d56-11ee-b197-0242ac180005/5006521900c345199a19543d61070c1f.png)

虽然这个例子给出的方法用于二元一次矩阵求解还不如直接用初中就学到的消元法，但矩阵的好处在于对于更高维的数据，比如有成百上千个未知数，这个解法依然有效。

在 Python 中，可以使用 Numpy 的线性代数算法库 linalg 提供的 solve 方法求解方程组。示例如下：

```
>>> a = np.matrix('3 2; -1 1')
>>> b = np.matrix('7; 1')
>>> np.linalg.solve(a, b)
matrix([[ 1.],
        [ 2.]])
```
### 求向量组合
![](http://oldmark.oss-cn-beijing.aliyuncs.com/2023/12/18/36723250-9d56-11ee-a950-0242ac180005/7238fd84bf0245c9bc2b5fb878066ad5.png)

![](http://oldmark.oss-cn-beijing.aliyuncs.com/2023/12/18/3d0ed276-9d56-11ee-8d88-0242ac180005/a0c3fe5f0ce746ce9c245cf2824c20fa.png)