《线性代数》3. 矩阵，线性代数中最重要的概念

标签：begin end 矩阵概念线性代数 vec Bmatrix 向量

什么是矩阵

前面我们介绍了向量，它是线性代数中最基本的元素，但提到线性代数，估计更多人第一时间想到的是矩阵（Matrix）。

$\begin{Bmatrix} 1 & 2 & 3 & 4 \\ 5 & 6 & 7 & 8 \\ 9 & 10 & 11 & 12 \end{Bmatrix}$

如果说向量是对数的拓展，一个向量表示一组数，那么矩阵就是对向量的拓展，一个矩阵表示一组向量。比如上面那个矩阵，如果横着看，那么它由三个向量组成（每个向量维度为 4）；如果竖着看，那么它由四个向量组成（每个向量维度为 3）。

而在描述一个矩阵的时候，我们会用几行几列来描述，比如上面的矩阵就是一个 3 x 4 的矩阵（有 3 行 4 列）。如果一个矩阵的行数和列数相等，那么我们也称这样的矩阵为方阵。

$A = \begin{Bmatrix} a_{11} & a_{12} & a_{13} & a_{14} \\ a_{21} & a_{22} & a_{23} & a_{24} \\ a_{31} & a_{32} & a_{33} & a_{34} \end{Bmatrix}$

另外在数学体系中，我们使用大写符号来代表矩阵，对应的小写符号代表矩阵的元素。而且每个小写符号都有一个下标，比如 $a_{mn}$，表示第 $m$ 行、第 $n$ 列。

了解完什么是矩阵之后，我们通过 Python 来实现一个矩阵，在计算机中，矩阵可以看成一个二维数组。

矩阵的基本运算

回忆一下向量的基本运算，分别是向量的加法：$\vec{u} + \vec{w}$，向量的数量乘：$k * \vec{u}$。那么矩阵也是同理，矩阵也有加法：$A + B$，和乘法 $k * A$。

假设有两个矩阵 A 和 B，它们的值分别如下：

$A = \begin{Bmatrix} a_{11} & a_{12} & a_{13} & ··· & a_{1n} \\ a_{21} & a_{22} & a_{23} & ··· & a_{2n} \\ a_{31} & a_{32} & a_{33} & ··· & a_{3n} \\ ··· & ··· & ··· & ··· & ··· \\ a_{m1} & a_{m2} & a_{m3} & ··· & a_{mn} \end{Bmatrix}$，$B = \begin{Bmatrix} b_{11} & b_{12} & b_{13} & ··· & b_{1n} \\ b_{21} & b_{22} & b_{23} & ··· & b_{2n} \\ b_{31} & b_{32} & b_{33} & ··· & b_{3n} \\ ··· & ··· & ··· & ··· & ··· \\ b_{m1} & b_{m2} & b_{m3} & ··· & b_{mn} \end{Bmatrix}$

那么 $A + B$ 和 $k · A$ 的结果就为：

$A + B = \begin{Bmatrix} a_{11} + b_{11} & a_{12} + b_{12} & a_{13} + b_{13} & ··· & a_{1n} + b_{1n} \\ a_{21} + b_{21} & a_{22} + b_{22} & a_{23} + b_{23} & ··· & a_{2n} + b_{2n} \\ a_{31} + b_{31} & a_{32} + b_{32} & a_{33} + b_{33} & ··· & a_{3n} + b_{3n} \\ ··· & ··· & ··· & ··· & ··· \\ a_{m1} + b_{m1} & a_{m2} + b_{m2} & a_{m3} + b_{m3} & ··· & a_{mn} + b_{mn} \end{Bmatrix}$，$k · A = \begin{Bmatrix} k · a_{11} & k · a_{12} & k · a_{13} & ··· & k · a_{1n} \\ k · a_{21} & k · a_{22} & k · a_{23} & ··· & k · a_{2n} \\ k · a_{31} & k · a_{32} & k · a_{33} & ··· & k · a_{3n} \\ ··· & ··· & ··· & ··· & ··· \\ k · a_{m1} & k · a_{m2} & k · a_{m3} & ··· & k · a_{mn} \end{Bmatrix}$

以上就是矩阵的基本运算，然后我们在此基础上再给出几个运算性质：

矩阵满足加法交换律：$A + B = B + A$
矩阵满足加法结合律律：$(A + B) + C = A + (B + C)$
和零矩阵相加，结果还是原矩阵：$A + O = A$
和对应的负矩阵相加，结果是零矩阵：$A + -A = O$，$-A$ 是唯一的，并且等于 $-1 * A$
数量乘也遵循结合律：$(c·k)·A = c·(k·A)$
分配率：$k · (A + B) = k · A + k · B$，同理还有 $(c + k ) · A = c · A + k · A$

矩阵和向量的乘法

假设有一个方程组：

$\begin{cases} 3x + 2y + 4z + 10m = 12 \\ 6y + 4z + 8m = 17 \\ 4x + 10y + z + 2m = 9 \\ y + 5z + 6m = 11 \end{cases}$

该方程组是我随便写的，很明显我们可以将未知数的系数提取成一个矩阵，至于未知数和等号右边的值则可以是一个列向量：

$\begin{Bmatrix} 3 & 2 & 4 & 10 \\ 0 & 6 & 4 & 8 \\ 4 & 10 & 1 & 2 \\ 0 & 1 & 5 & 6 \end{Bmatrix} · \begin{pmatrix} x \\ y \\ z \\ m \end{pmatrix} = \begin{pmatrix} 12 \\ 17 \\ 9 \\ 11 \end{pmatrix}$

如果让矩阵的每一行（行向量）都和未知数组成的向量做点乘，那么结果不就是上面的方程组吗。

因此任意一个方程组，我们都可以抽象成 $A · \vec{x} = \vec{b}$ 的形式。而矩阵和一个向量相乘，等于矩阵的每一行都和向量做点乘，就像下面这样：

$\begin{Bmatrix} a_{11} & a_{12} & a_{13} & ··· & a_{1n} \\ a_{21} & a_{22} & a_{23} & ··· & a_{2n} \\ a_{31} & a_{32} & a_{33} & ··· & a_{3n} \\ ··· & ··· & ··· & ··· & ··· \\ a_{m1} & a_{m2} & a_{m3} & ··· & a_{mn} \end{Bmatrix} · \begin{pmatrix} u_{1} \\ u_{2} \\ u_{3} \\ ··· \\ u_{n} \end{pmatrix} = \begin{pmatrix} a_{11}u_{1} + a_{12}u_{2} + a_{13}u_{3} + ··· + a_{1n}u_{n} \\ a_{21}u_{1} + a_{22}u_{2} + a_{23}u_{3} + ··· + a_{2n}u_{n} \\ a_{31}u_{1} + a_{32}u_{2} + a_{33}u_{3} + ··· + a_{3n}u_{n} \\ ··· \\ a_{m1}u_{1} + a_{m2}u_{2} + a_{m3}u_{3} + ··· + a_{mn}u_{n}\end{pmatrix}$

所以矩阵如果要和向量相乘，那么矩阵的列数必须和向量的元素个数相同，这样矩阵的每一行才能和向量做点乘。至于矩阵有多少行则无所谓，并且矩阵的行数就是结果向量的元素个数。另外矩阵实际上是多个向量的组合，如果矩阵只有一行，那么它也可以看作是一个向量，此时再和向量点乘，得到的就是一个标量。

最后我们再来看一下 $T · \vec{a} = \vec{b}$，这个式子可以解读为将向量 $\vec{a}$ 转换成了向量 $\vec{b}$，而转换的方式则由矩阵 $T$ 来定义。从这个角度来理解，可以把矩阵 $T$ 看成是向量的函数。

矩阵和矩阵的乘法

矩阵相乘在图形学上非常有用，比如有一个点 $\begin{pmatrix}x \\ y \end{pmatrix}$，我们希望它的横坐标放大 $1.5$ 倍，纵坐标放大 $2$ 倍，那么怎么做呢？显然要找到一个矩阵 $T$，使得：

$T · \begin{pmatrix}x \\ y \end{pmatrix} = \begin{pmatrix}1.5x \\ 2y \end{pmatrix}$

首先和 $T$ 相乘的向量的长度是 $2$，所以 $T$ 的列数必须是 $2$，否则两者无法相乘。然后结果向量的长度是 $2$，因此 $T$ 的行数也必须是 $2$，所以 $T$ 是一个 $2 × 2$ 的矩阵。

$\begin{Bmatrix} a & b \\ c & d \end{Bmatrix} · \begin{pmatrix}x \\ y \end{pmatrix} = \begin{Bmatrix} a·x + b·y \\ c·x + d·y \end{Bmatrix} = \begin{pmatrix}1.5x \\ 2y \end{pmatrix}$

根据式子，不难得出：

$T = \begin{Bmatrix} 1.5 & 0 \\ 0 & 2 \end{Bmatrix}$

经过矩阵 $T$，我们就可以将一个点（向量）进行映射，使得横坐标扩大 1.5 倍，纵坐标扩大 2 倍。但是问题来了，如果有很多的向量该怎么办？很简单，将这些向量组合成一个矩阵即可。

$\begin{Bmatrix} 1.5 & 0 \\ 0 & 2 \end{Bmatrix} · \begin{Bmatrix}x_{1} & x_{2} & x_{3} & x_{4} \\ y_{1} & y_{2} & y_{3} & y_{4}\end{Bmatrix} = \begin{Bmatrix} 1.5x_{1} & 1.5x_{2} & 1.5x_{3} & 1.5x_{4}\\ 2y_{1} & 2y_{2} & 2y_{3} & 2y_{4} \end{Bmatrix}$

比如我们将 4 个点映射成矩阵，需要注意：这 4 个点是以列的形式组织的。所以从这个式子你也能看出矩阵乘法是怎么一回事了，假设有两个矩阵：$A$ 和 $B$，如果 $A$ 和 $B$ 能够相乘，那么必须满足矩阵 $A$ 的列数等于矩阵 $B$ 的行数，其它则没有要求。

回顾一下矩阵和向量相乘，需要满足矩阵的列数等于向量的长度，如果向量看成是只有一列的矩阵呢？所以结论是相似的。

然后让矩阵 $A$ 的每一行去和矩阵 $B$ 每一列相乘，得到的结果 $C$ 就是一个行数和 $A$ 保持一致、列数和 $B$ 保持一致的矩阵。比如 $A$ 是 $m$ 行 $k$ 列，$B$ 是 $k$ 行 $n$ 列，那么矩阵 $C$ 就是 $m$ 行 $n$ 列。

$A = \begin{Bmatrix}\vec{r_{1}} \\ \vec{r_{2}} \\ \vec{r_{3}} \\ ... \\ \vec{r_{m}} \end{Bmatrix}$，$B = \begin{Bmatrix} \vec{c_{1}} & \vec{c_{2}} & \vec{c_{3}} & ... & \vec{c_{n}} \end{Bmatrix}$

为了描述方便，我们用 $\vec{r}$ 代表矩阵 $A$ 的每一行，可以想象一行有很多元素，$\vec{c}$ 代表矩阵 $B$ 的每一列，可以想象一列有很多元素。但 $A$ 和 $B$ 如果相乘，那必须满足 $\vec{r}$ 和长度 $\vec{c}$ 的长度是一致的，也就是 $A$ 和列数要等于 $B$ 的行数。

$C = A · B = \begin{Bmatrix}\vec{r_{1}} · \vec{c_{1}} & \vec{r_{1}} · \vec{c_{2}} & \vec{r_{1}} · \vec{c_{3}} & ··· & \vec{r_{1}} · \vec{c_{n}}\\ \vec{r_{2}} · \vec{c_{1}} & \vec{r_{2}} · \vec{c_{2}} & \vec{r_{2}} · \vec{c_{3}} & ··· & \vec{r_{2}} · \vec{c_{n}}\\\vec{r_{3}} · \vec{c_{1}} & \vec{r_{3}} · \vec{c_{2}} & \vec{r_{3}} · \vec{c_{3}} & ··· & \vec{r_{3}} · \vec{c_{n}}\\ ··· & ··· & ··· & ··· & ···\\\vec{r_{m}} · \vec{c_{1}} & \vec{r_{m}} · \vec{c_{2}} & \vec{r_{m}} · \vec{c_{3}} & ··· & \vec{r_{m}} · \vec{c_{n}} \end{Bmatrix}$

相乘的时候，让矩阵 $A$ 的每一行去点乘矩阵 $B$ 的每一列即可。并且 $C$ 的行数等于 $A$ 的行数，$C$ 的列数等于 $B$ 的列数，所以 $C_{ij}$ 就是 $A$ 的第 $i$ 行和 $B$ 的第 $j$ 列点乘的结果。

矩阵乘法不遵循交换律。

矩阵乘法的性质

我们说矩阵乘法不遵循交换律，即 $A · B ≠ B · A$，而且 $A$ 和 $B$ 要能相乘，必须满足 $A$ 的列数等于 $B$ 的行数，但 $A$ 的行数和 $B$ 的列数之间的关系则没有要求，这就使得 $B · A$ 可能压根就不合法。如果 $A ·B$ 和 $B · A $ 都合法，那么要求 $A$ 和 $B$ 必须都是方阵，但即便如此，它们的结果大部分情况也是不一样的。

那么矩阵乘法都遵循哪些性质呢？

$(A · B) · C = A · (B · C)$
$A · (B + C) = A · B + A · C$
$(B + C) · A = B · A + C · A$

注意：第二条和第三条本身是没有问题的，但它们两者是没有关系的。

然后对于任意的 $r × c$ 的矩阵 $A$，存在 $c × m$ 的零矩阵 $O$，使得 $A · O_{cm} = O_{rm}$，这个很简单，任何矩阵和零矩阵相乘，结果还是零矩阵，只是维度的变了。

同理对于任意的 $r × c$ 的矩阵 $A$，存在 $m × r$ 的零矩阵 $O$，使得 $O_{mr} · A = O_{mc}$

然后矩阵也可以进行幂运算，比如 $A^{k}$ 就是 $k$ 个 $A$ 相乘，但很明显，如果矩阵想要幂运算，那么矩阵必须是方阵。

最后再补充一点：$(A + B)^{2} = A^{2} + A·B + B·A + B^{2}$，但不等于 $A^{2} + 2AB + B^{2}$。

矩阵的转置

回顾一下在介绍矩阵乘法时，举的一个例子，我们假设有 4 个点。

$\begin{Bmatrix}x_{1} & x_{2} & x_{3} & x_{4} \\ y_{1} & y_{2} & y_{3} & y_{4}\end{Bmatrix}$

但这种排列方式多少有点别扭，我们更习惯这么排列：

$\begin{Bmatrix}x_{1} & y_{1}\\x_{2} & y_{2}\\x_{3} & y_{3}\\x_{4} & y_{4}\end{Bmatrix}$

但做乘法的时候，第二种矩阵是不能直接乘的，我们需要变成第一种矩阵的形式。而第二种矩阵只要将它的每一行单独的拿出来，并以列的方式进行组合，就得到了第一种矩阵，这个过程就叫做矩阵的转置。

矩阵 $A$ 转置之后的矩阵，我们一般叫做 $A^{T}$，如果 $A$ 是 $m · n$ 矩阵，那么 $A^{T}$ 就是 $n · m$ 矩阵。

其中 $A$ 的第 $i$ 行变成了 $A^{T}$ 的第 $i$ 列
$A_{ij} = A^{T}_{ji}$

然后是之前提到的向量，如果不做特殊说明，那么向量指的是列向量。但书籍是横版印刷，所以为了表示这是个列向量，于是便使用行向量加转置的方式，比如 $(3, 5)^{T}$。

了解完矩阵的转置之后，再来看看它有哪些性质。

$(A^{T})^{T} = A$
$(A + B)^{T} = A ^{T} + B^{T}$
$(k · A)^{T} = k · A^{T}$
$(A · B)^{T} = B^{T} · A^{T}$

有兴趣可以自己证明一下。

Numpy 中的矩阵

然后看一下如何在 Numpy 中操作矩阵。

import numpy as np

# 矩阵依旧可以通过数组来实现，只不过是二维数组
mat = np.array(
    [
        [1, 2, 3, 4],
        [5, 6, 7, 8],
        [9, 10, 11, 12]
    ]
)
print(mat)
"""
[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]
"""
# 3 行 4 列
print(mat.shape)
"""
(3, 4)
"""
# 元素个数
print(mat.size)
"""
12
"""
# 获取转置矩阵
print(mat.T)
"""
[[ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]
 [ 4  8 12]]
"""
# 获取第 2 行第 3 列的元素
print(mat[1, 2])
"""
7
"""
# 也可以对矩阵进行截取，截取矩阵的第一行、第二行和第二列、第三列
print(mat[0: 2, 1: 3])
"""
[[2 3]
 [6 7]]
"""
# 获取矩阵的某一行，比如获取第 2 行，至于列则全部截取
# 也可以写成 mat[1]，列默认全部截取
print(mat[1, :])
"""
[5 6 7 8]
"""
# 获取矩阵的某一列，比如获取第 3 列，此时必须写成 mat[:, 2]
print(mat[:, 2])
"""
[ 3  7 11]
"""

比较简单，再来看看矩阵的运算。

import numpy as np

# 矩阵依旧可以通过数组来实现，只不过是二维数组
mat1 = np.array(
    [[1, 2, 3], [4, 5, 6]]
)
mat2 = np.array(
    [[11, 22, 33], [44, 55, 66]]
)
# 矩阵相加
print(mat1 + mat2)
"""
[[12 24 36]
 [48 60 72]]
"""
# 矩阵相减
print(mat1 - mat2)
"""
[[-10 -20 -30]
 [-40 -50 -60]]
"""
# 和标量相乘
print(mat1 * 3)
"""
[[ 3  6  9]
 [12 15 18]]
"""
# 矩阵的相乘，如果直接用 * 号，那么表示对应的元素相乘
# 因为这里创建的其实是数组，本质上是用数组来模拟矩阵
# 如果希望实现数学上的矩阵相乘，那么应该使用 @
print(mat1 * mat2)
"""
[[ 11  44  99]
 [176 275 396]]
"""
try:
    mat1 @ mat2
except ValueError as e:
    print(e)
"""
matmul: Input operand 1 has a mismatch in its core dimension 0, 
        with gufunc signature (n?,k),(k,m?)->(n?,m?) (size 2 is different from 3)
"""
# 我们看到矩阵的相乘报错了，因为 mat1 的列数和 mat2 的行数不相等
# 提示给的也很明显：不满足 (n?,k),(k,m?)->(n?,m?)

# 我们将 mat2 转置一下即可，但 mat1 * mat2.T 是不对的，因为形状不一样，而 * 是对应元素依次相乘
print(mat1 @ mat2.T)
"""
[[154 352]
 [352 847]]
"""

# 矩阵和向量相乘
vec1 = np.array([1, 2, 3])  # 行向量
vec2 = np.array([[1], [2], [3]])  # 列向量
print(mat1 @ vec1)
"""
[14 32]
"""
print(mat1 @ vec2)
"""
[[14]
 [32]]
"""

非常简单，以上就是矩阵相关的操作。

标签：begin,end,矩阵,概念,线性代数,vec,Bmatrix,向量
From： https://www.cnblogs.com/traditional/p/17663040.html