深度学习预备知识

学习路径按照《动手学深度学习》

符号

数字

$x$ ：标量
$\mathbf{x}$ ：向量
$\mathbf{X}$ ：矩阵
$\mathsf{X}$：张量
$\mathrm{I}$：单位矩阵
$x_i,[\mathbf{x}]_i$ ：向量 $\mathbf{x}$ 第 $i$ 个元素
$x_{i j},[\mathbf{X}]_{i j}$ ：矩阵 $\mathbf{X}$ 第 $i$ 行第 $j$ 列的元素

集合论

$\mathcal{X}$ ：集合
$\mathbb{Z}$ ：整数集合
$\mathbb{R}$ ：实数集合
$\mathbb{R}^n: n$ 维实数向量集合
$\mathbb{R}^{a \times b}$ ：包含 $a$ 行和 $b$ 列的实数矩阵集合
$\mathcal{A} \cup \mathcal{B}$ ：集合 $\mathcal{A}$ 和 $\mathcal{B}$ 的并集
$\mathcal{A} \cap \mathcal{B}$ ：集合 $\mathcal{A}$ 和 $\mathcal{B}$ 的交集
$\mathcal{A} \backslash \mathcal{B}$ ：集合 $\mathcal{A}$ 与集合 $\mathcal{B}$ 相减， $\mathcal{B}$ 关于 $\mathcal{A}$ 的相对补集

函数和运算符

$f(\cdot)$ ：函数
$\log (\cdot)$ ：自然对数
$\exp (\cdot)$ ：指数函数
$\mathbf{1}_{\boldsymbol{\chi}}$ ：指示函数
$(\cdot)^{\top}$ ：向量或矩阵的转置
$\mathbf{X}^{-1}$ ：矩阵的逆
$\odot$ ：按元素相乘
$[\cdot, \cdot]$ ：连结
$|\mathcal{X}|$ ：集合的基数
$|\cdot|_p: L_p$ 正则
$|\cdot|: L_2$ 正则
$\langle\mathbf{x}, \mathbf{y}\rangle$ ：向量 $\mathbf{x}$ 和 $\mathbf{y}$ 的点积
$\sum$ ：连加
$\Pi $：连乘
$\stackrel{\mathrm{def}}{=}$：定义

微积分

$\frac{d y}{d x}$ ：$y$ 关于 $x$ 的导数
$\frac{\partial y}{\partial x}$ ：$y$ 关于 $x$ 的偏导数
$\nabla_{\mathbf{x}} y$ ：$y$ 关于向量 $\mathbf{x}$ 的梯度
$\int_a^b f(x) d x$ ：$f$ 在 $a$ 到 $b$ 区间上关于 $x$ 的定积分
$\int f(x) d x$ ：$f$ 关于 $x$ 的不定积分

概率与信息论

$P(\cdot)$ ：概率分布
$z \sim P$ ：随机变量 $z$ 具有概率分布 $P$
$P(X \mid Y): X \mid Y$ 的条件概率
$p(x)$ ：概率密度函数
$E_x[f(x)]$ ：函数 $f$ 对 $x$ 的数学期望
$X \perp Y$ ：随机变量 $X$ 和 $Y$ 是独立的
$X \perp Y \mid Z$ ：随机变量 $X$ 和 $Y$ 在给定随机变量 $Z$ 的条件下是独立的
$\operatorname{Var}(X)$ ：随机变量 $X$ 的方差
$\sigma_X$ ：随机变量 $X$ 的标准差
$\operatorname{Cov}(X, Y)$ ：随机变量 $X$ 和 $Y$ 的协方差
$\rho(X, Y)$ ：随机变量 $X$ 和 $Y$ 的相关性
$H(X)$ ：随机变量 $X$ 的熵
$D_{\mathrm{KL}}(P | Q): P$ 和 $Q$ 的KL－散度

复杂度

$\mathcal{O}$ ：大 O 标记

数据操作

这一部分和numpy很相像，但不同的是用torch来实现

张量表示一个由数值组成的数组，这个数组可能有多个维度

具有一个轴的张量对应数学上的向量(vector)
具有两个轴的张量对应数学上的矩阵(matrix)
具有两个轴以上的张量没有特殊的数学名称

和numpy的写法基本一致，具体的回头看python基础

创建一个行向量

1	x = torch.arange(12)

1	tensor([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])

可以通过shape来访问张量(沿每个轴的长度)的形状，如果想要知道张量中元素的总数，需要通过numel()来访问

1 2	x.shape x.numel()

1 2	torch.Size([12]) 12

可以通过cat来实现多个张量**连结(concatenate)**在一起，只需要提供张量列表，并给出沿哪个轴连结(0为列，1为行)

1
2
3

X = torch.arange(12, dtype=torch.float).reshape((3,4))
Y = torch.tensor([[2.0,1,4,3],[1,2,3,4],[4,3,2,1]])
torch.cat((X,Y),dim=0),torch.cat((X,Y),dim=1)

(tensor([[ 0.,  1.,  2.,  3.],
         [ 4.,  5.,  6.,  7.],
         [ 8.,  9., 10., 11.],
         [ 2.,  1.,  4.,  3.],
         [ 1.,  2.,  3.,  4.],
         [ 4.,  3.,  2.,  1.]]),
 tensor([[ 0.,  1.,  2.,  3.,  2.,  1.,  4.,  3.],
         [ 4.,  5.,  6.,  7.,  1.,  2.,  3.,  4.],
         [ 8.,  9., 10., 11.,  4.,  3.,  2.,  1.]]))

广播机制

即使形状不同，仍然可以通过调用**广播机制(broadcasting mechanism)**来执行按元素操作

工作方式如下：

通过适当复制元素来扩展一个或两个数组，以便在转换之后，两个张量具有相同的形状；
对生成的数组执行按元素操作

在大多数情况下将沿着数组中长度为1的轴进行广播

1
2
3

a = torch.arange(3).reshape((3, 1))
b = torch.arange(2).reshape((1, 2))
a + b

1
2
3

tensor([[0, 1],
        [1, 2],
        [2, 3]])

节省内存

运行一些操作可能会导致为新结果分配内存

1
2
3

before = id(Y)
Y = Y + X
id(Y) == before # 输出False

主要是因为py自发会创造新地址

在机器学习中可能有数百兆的参数，并且在一秒内多次更新所有参数，通常情况下希望原地执行这些更新；如果不原地更新，其他引用仍然会指向旧的内存位置，可以导致旧参数的引用

可以使用切片表示/复合赋值将操作的结果分配给先前分配的数组

Z = torch.zeros_like(Y)  # 假设Z之前已经被创造
print('id(Z):', id(Z))
Z[:] = X + Y
print('id(Z):', id(Z))

1 2	id(Z): 1655337054096 id(Z): 1655337054096

1
2
3

before = id(Y)
Y += X
id(Y) == before # 输出True

转化为其它对象

PyTorch tensor 和 NumPy ndarray 相互转化

1 2	t = torch.tensor([1, 2, 3]) n = t.numpy()

1 2	n = np.array([4, 5, 6]) t = torch.from_numpy(n)

转化后torch张量和numpy数组将共享底层内存，就地操作更改一个张量也会同时更改另一个张量

tensor可以调用item函数转为标量或利用Python内置转化函数

1 2	a = torch.tensor([3.5]) a, a.item(), float(a), int(a)

1	(tensor([3.5000]), 3.5, 3.5, 3)

数据预处理

在Python中常用的数据分析工具中，通常使用pandas，可以与张量兼容

读取数据集

首先创建一个人工数据集，并存储在CSV(逗号分隔值)文件 ./data/house_tiny.csv中

import os
os.makedirs("data", exist_ok=True)
data_file = os.path.join('data','house_tiny.csv')
with open(data_file, 'w') as f:
    f.write('NumRooms,Alley,Price\n')  # 列名
    f.write('NA,Pave,127500\n')  # 每行表示一个数据样本
    f.write('2,NA,106000\n')
    f.write('4,NA,178100\n')
    f.write('NA,NA,140000\n')

要从创建的CSV文件中加载原始数据集，导入pandas包并调用read_csv函数

1
2
3

import pandas as pd
data = pd.read_csv(data_file)
print(data)

   NumRooms Alley   Price
0       NaN  Pave  127500
1       2.0   NaN  106000
2       4.0   NaN  178100
3       NaN   NaN  140000

处理缺失值

“NaN”项代表缺失值，为了处理缺失的数据，典型的方法包括插值法和删除法，其中插值法用一个替代值弥补缺失值，而删除法则直接忽略缺失值

这里使用插值法(不然没数据了都)，通过位置索引iloc，将data分成inputs和outputs，其中前者为data的前两列，而后者为data的最后一列

对于inputs中NumRooms缺少的数值，用同一列的均值替换“NaN”项

1
2
3

inputs, outputs = data.iloc[:,0:2], data.iloc[:,2]
inputs = inputs.fillna(inputs.mean(numeric_only=True)) # 要加上numeric_only，不然报错
print(inputs)

对于inputs中“巷子类型”(“Alley”)列，只接受两种类型的类别值“Pave”和“NaN”，pandas可以把字符串换为独热编码(one-hot encoding)

1 2	inputs = pd.get_dummies(inputs,dummy_na=True) # 把字符串换为独热编码(one-hot encoding) print(inputs)

   NumRooms  Alley_Pave  Alley_nan
0       3.0        True      False
1       2.0       False       True
2       4.0       False       True
3       3.0       False       True

转换为张量格式

现在inputs和outputs中的所有条目都是数值类型，它们可以转换为张量格式

# 先从pandas对象转为numpy对象，保证浮点数，再转为tensor
X = torch.tensor(inputs.to_numpy(dtype=float))
Y = torch.tensor(outputs.to_numpy(dtype=float))
print(X)
print(Y)

tensor([[3., 1., 0.],
        [2., 0., 1.],
        [4., 0., 1.],
        [3., 0., 1.]], dtype=torch.float64)
tensor([127500., 106000., 178100., 140000.], dtype=torch.float64)

删除缺失值最多的列

def drop_col(data):
    num = data.isna().sum() # 统计每列的缺失值数量
    col_to_drop = num.idxmax() # 找出缺失最多的列名
    data = data.drop(columns=[col_to_drop]) # 删除对应列
    # print(data)
    # return data

线性代数

标量

仅包含一个数值被称为标量(scalar)，标量由只有一个元素的张量表示

采用了数学表示法，其中标量变量由普通小写字母表示(例如，$x,y$和$z$),用$\mathbb{R}$表示所有(连续)实数标量的空间

向量

向量可以被视为标量值组成的列表，标量值被称为向量的元素(element)或分量(component)

在数学表示法中，向量通常记为粗体、小写的符号(例如，$\mathbf{x},\mathbf{y}$和$\mathbf{z}$)

通过一维张量表示向量，一般来说，张量可以具有任意长度，取决于机器的内存限制

类似于普通的Python数组

长度：len(x)，对于一个二阶及以上张量，len只会输出其第0个维度大小

形状：x.shape

矩阵

矩阵通常用粗体、大写字母来表示(例如$\mathbf{X},\mathbf{Y},\mathbf{Z}$)，在代码中表示为具有两个轴的张量

数学表示法使$\mathbf{A} \in \mathbb{R}^{m \times n}$来表示矩阵$\mathbf{A}$，其由$m$行和$n$列的实值标量组成
$$
\begin{split}\mathbf{A}^\top =
\begin{bmatrix}
a_{11} & a_{21} & \dots & a_{m1} \\
a_{12} & a_{22} & \dots & a_{m2} \\
\vdots & \vdots & \ddots & \vdots \\
a_{1n} & a_{2n} & \dots & a_{mn}
\end{bmatrix}\end{split}
$$
行列数相等的矩阵被称为方阵(square matrix)

1	A = torch.arange(20).reshape(5, 4)

tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11],
        [12, 13, 14, 15],
        [16, 17, 18, 19]])

交换矩阵的行和列称为矩阵的转置(transpose)，通常用$\mathbf{a}^\top$来表示矩阵的转置

A.T

tensor([[ 0,  4,  8, 12, 16],
        [ 1,  5,  9, 13, 17],
        [ 2,  6, 10, 14, 18],
        [ 3,  7, 11, 15, 19]])

如果$\mathbf{B}=\mathbf{A}^\top$，则对于任意$i$和$j$，都有$b_{ij}=a_{ji}$

张量

张量是描述具有任意数量轴的$n$维数组的通用方法，向量是一阶张量，矩阵是二阶张量

张量用特殊字体的大写字母表示(例如$\mathsf{X},\mathsf{Y},\mathsf{Z}$)，索引机制与矩阵类似

图像以$n$维数组形式出现，其中3个轴对应于高度、宽度，以及一个通道(channel)轴，用于表示颜色通道(红色、绿色和蓝色)

1	X = torch.arange(24).reshape(2, 3, 4)

tensor([[[ 0,  1,  2,  3],
         [ 4,  5,  6,  7],
         [ 8,  9, 10, 11]],

        [[12, 13, 14, 15],
         [16, 17, 18, 19],
         [20, 21, 22, 23]]])

Hadamard积

任何按元素的一元运算都不会改变其操作数的形状

给定具有相同形状的任意两个张量，任何按元素二元运算的结果都将是相同形状的张量

两个矩阵的按元素乘法称为Hadamard积(Hadamard product)(数学符号$\odot$)

要和后面的点积区分开来，点积更像是线性代数课程上讲的矩阵乘法，Hadamard积是矩阵元素的操作

矩阵$\mathbf{A}$和$\mathbf{B}$的Hadamard积为
$$
\begin{split}\mathbf{A} \odot \mathbf{B} =
\begin{bmatrix}
a_{11} b_{11} & a_{12} b_{12} & \dots & a_{1n} b_{1n} \\
a_{21} b_{21} & a_{22} b_{22} & \dots & a_{2n} b_{2n} \\
\vdots & \vdots & \ddots & \vdots \\
a_{m1} b_{m1} & a_{m2} b_{m2} & \dots & a_{mn} b_{mn}
\end{bmatrix}\end{split}
$$

1 2	B = A.clone() A*B

tensor([[  0,   1,   4,   9],
        [ 16,  25,  36,  49],
        [ 64,  81, 100, 121],
        [144, 169, 196, 225],
        [256, 289, 324, 361]])

降维

对任意张量进行的一个有用的操作是计算其元素的和

数学表示法使用符号$\sum$表示求和

1	A.shape, A.sum()

1	(torch.Size([5, 4]), tensor(190.))

默认情况下，调用求和函数会沿所有的轴降低张量的维度，使它变为一个标量，还可以指定张量沿哪一个轴来通过求和降低维度

为了通过求和所有行的元素来降维(轴0)，可以在调用函数时指定axis=0，由于输入矩阵沿0轴降维以生成输出向量，因此输入轴0的维数在输出形状中消失

1 2	A_sum_axis0 = A.sum(axis=0) A_sum_axis0, A_sum_axis0.shape

1	(tensor([40, 45, 50, 55]), torch.Size([4]))

为什么是这个结果呢，因为0轴(行轴)降维，各行的元素被累加压缩，所以输出的每个元素是行元素相加的结果

同理，指定axis=1将通过汇总所有列的元素降维

1 2	A_sum_axis1 = A.sum(axis=1) A_sum_axis1, A_sum_axis1.shape

1	(tensor([ 6., 22., 38., 54., 70.]), torch.Size([5]))

注意结果，因为降维了，没有行的概念，从想法上列压缩，剩下的是行，但其实最后的结果是一维张量

axis可以输入多个轴，对于二阶向量输入[0,1]等价于对矩阵的所有元素进行求和

1	A.sum(axis=[0, 1]) # 结果和A.sum()相同

1	tensor(190.)

平均值(mean或average)，通过将总和除以元素总数来计算平均值，也可以指定轴

1 2	A.mean(), A.sum() / A.numel() # 所有元素平均值 A.mean(axis=0), A.sum(axis=0) / A.shape[0] # 行平均值

1 2	(tensor(9.5000), tensor(9.5000)) (tensor([ 8., 9., 10., 11.]), tensor([ 8., 9., 10., 11.]))

非降维求和

有时在调用函数来计算总和或均值时保持轴数不变会很有用，加入keepdims参数

1 2	sum_A = A.sum(axis=1, keepdims=True) sum_A

tensor([[ 6.],
        [22.],
        [38.],
        [54.],
        [70.]])

由于sum_A在对每行进行求和后仍保持两个轴，可以通过广播将A除以sum_A，实现对每行元素除以行平均数，如果没有keepdims将报错

A / sum_A

tensor([[0.0000, 0.1667, 0.3333, 0.5000],
        [0.1818, 0.2273, 0.2727, 0.3182],
        [0.2105, 0.2368, 0.2632, 0.2895],
        [0.2222, 0.2407, 0.2593, 0.2778],
        [0.2286, 0.2429, 0.2571, 0.2714]])

如果想沿某个轴计算A元素的累积总和，可以调用cumsum函数，不会沿任何轴降低输入张量的维度

1	A.cumsum(axis=0) # 按行计算

tensor([[ 0.,  1.,  2.,  3.],
        [ 4.,  6.,  8., 10.],
        [12., 15., 18., 21.],
        [24., 28., 32., 36.],
        [40., 45., 50., 55.]])

点积

给定两个向量$\mathbf{x},\mathbf{y}\in\mathbb{R}^d$，点积(dot product)$\mathbf{x}^\top\mathbf{y} $(或$\langle\mathbf{x},\mathbf{y}\rangle$) 是相同位置的按元素乘积的和
$$
\mathbf{x}^\top \mathbf{y} = \sum_{i=1}^{d} x_i y_i
$$

1
2
3

x = torch.arange(4,dtype=torch.float32)
y = torch.ones(4,dtype=torch.float32)
x, y, x@y

1	(tensor([0., 1., 2., 3.]), tensor([1., 1., 1., 1.]), tensor(6.))

点积在很多场合都很有用，给定一组由向量$\mathbf{x} \in \mathbb{R}^d$表示的值，和一组由$\mathbf{w} \in \mathbb{R}^d$表示的权重，$\mathbf{x}$中的值根据权重$\mathbf{w}$的加权和，可以表示为点积$\mathbf{x}^\top \mathbf{w}$

当权重为非负数且和为1$\left(\sum_{i=1}^{d}{w_i}=1\right)$，点积表示加权平均(weighted average)

将两个向量规范化得到单位长度后，点积表示它们夹角的余弦

矩阵-向量积

之前定义的$\mathbf{A} \in \mathbb{R}^{m \times n}$和向量$\mathbf{x} \in \mathbb{R}^n$，将矩阵$\mathbf{A}$用它的行向量表示
$$
\begin{split}\mathbf{A}=
\begin{bmatrix}
\mathbf{a}^\top_{1} \\
\mathbf{a}^\top_{2} \\
\vdots \\
\mathbf{a}^\top_m \\
\end{bmatrix}\end{split}
$$
其中每个$\mathbf{a}^\top_{i} \in \mathbb{R}^n$都是行向量，表示矩阵的第$i$行，矩阵向量积是一个长度为$m$的列向量，其第$i$个元素是点积$\mathbf{a}^\top_i \mathbf{x}$

在深度学习中一般把以列向量为准，转置符号表示这是一个行向量，这样就很容易思考了

$$
\begin{split}\mathbf{A}\mathbf{x}
= \begin{bmatrix}
\mathbf{a}^\top_{1} \\
\mathbf{a}^\top_{2} \\
\vdots \\
\mathbf{a}^\top_m \
\end{bmatrix}\mathbf{x}
= \begin{bmatrix}
\mathbf{a}^\top_{1} \mathbf{x} \\
\mathbf{a}^\top_{2} \mathbf{x} \\
\vdots\\
\mathbf{a}^\top_{m} \mathbf{x}\
\end{bmatrix}\end{split}
$$
可以把一个矩阵$\mathbf{A} \in \mathbb{R}^{m \times n}$乘法看作一个从$\mathbb{R}^{n}$到$\mathbb{R}^{m}$向量的转换，这些转换是非常有用的，例如可以用方阵的乘法来表示旋转

在代码中**矩阵-向量积(matrix–vector product)**使用mv函数表示

1	torch.mv(input, vec) → Tensor

input 必须是二维张量(shape = (m, n))
vec 必须是一维张量(shape = (n,))
返回结果是一个一维张量(shape = (m,))

A = torch.tensor([[1, 2, 3],
                  [4, 5, 6]])
x = torch.tensor([1, 2, 3])
y = torch.mv(A, x) # 要求输入的数据类型相同

1	tensor([14, 32])

$$
\left[\begin{array}{lll}
1 & 2 & 3 \\
4 & 5 & 6
\end{array}\right]\left[\begin{array}{l}
1 \\
2 \\
3
\end{array}\right]=\left[\begin{array}{l}
1 \times 1+2 \times 2+3 \times 3 \\
4 \times 1+5 \times 2+6 \times 3
\end{array}\right]=\left[\begin{array}{l}
14 \\
32
\end{array}\right]
$$

矩阵-矩阵乘法

假设有两个矩阵$\mathbf{A} \in \mathbb{R}^{n \times k}$ 和 $\mathbf{B} \in \mathbb{R}^{k \times m}$
$$
\begin{split}\mathbf{A}=\begin{bmatrix}
a_{11} & a_{12} & \cdots & a_{1k} \\
a_{21} & a_{22} & \cdots & a_{2k} \\
\vdots & \vdots & \ddots & \vdots \\
a_{n1} & a_{n2} & \cdots & a_{nk} \\
\end{bmatrix},\quad
\mathbf{B}=\begin{bmatrix}
b_{11} & b_{12} & \cdots & b_{1m} \\
b_{21} & b_{22} & \cdots & b_{2m} \\
\vdots & \vdots & \ddots & \vdots \\
b_{k1} & b_{k2} & \cdots & b_{km} \\
\end{bmatrix}.\end{split}
$$
用行向量$\mathbf{a}^\top_{i} \in \mathbb{R}^k$表示矩阵$\mathbf{A}$的第$i$行，并让列向量$\mathbf{b}_{j} \in \mathbb{R}^k$作为矩阵$\mathbf{B}$的第$j$列

要生成矩阵积$\mathbf{C} = \mathbf{A}\mathbf{B}$，最简单的方法是考虑$\mathbf{A}$的行向量和$\mathbf{B}$的列向量，$\mathbf{B}=
\begin{bmatrix}
\mathbf{b}_1 & \mathbf{b}_2 & \cdots & \mathbf{b}_m
\end{bmatrix}$

将每个元素$c_{ij}$计算为点积$\mathbf{a}^\top_i \mathbf{b}_j$

将矩阵-矩阵乘法看作简单地执行$m$次矩阵-向量积，并将结果拼接在一起，形成一个$n \times m$矩阵

1
2
3

A = torch.arange(20).reshape((5,4)).float()
B = torch.ones(4,3)
torch.mm(A,B)

tensor([[ 6.,  6.,  6.],
        [22., 22., 22.],
        [38., 38., 38.],
        [54., 54., 54.],
        [70., 70., 70.]])

要与Hadamard积区别开，矩阵乘法并不是按元素乘法

范数

非正式地说，向量的范数是表示一个向量有多大，不涉及维度，而是分量的大小

向量范数是将向量映射到标量的函数$f$

给定任意向量$\mathbf{x}$，向量范数要满足一些属性

$$
f(\alpha \mathbf{x}) = |\alpha| f(\mathbf{x}).
$$
$$
f(\mathbf{x} + \mathbf{y}) \leq f(\mathbf{x}) + f(\mathbf{y}).
$$
$$
f(\mathbf{x}) \geq 0.
$$

范数听起来很像距离的度量

欧几里得距离是一个$L_2$范数
$$
\mid \mid \mathbf{x}\mid \mid_2 = \sqrt{\sum_{i=1}^n x_i^2},
$$
在$L_2$范数中常常省略下标2，也就是$\mid \mid \mathbf{x}\mid \mid$等价于$\mid \mid \mathbf{x}\mid \mid_2$

代码中可以直接用norm计算

1 2	u = torch.tensor([3.0, -4.0]) torch.norm(u)

1	tensor(5.)

深度学习中更经常地使用$L_2$范数的平方，也会经常遇到$L_1$范数，它表示为向量元素的绝对值之和
$$
\mid \mid \mathbf{x}\mid \mid_1 = \sum_{i=1}^n \left|x_i \right|.
$$
与$L_2$范数相比，$L_1$范数受异常值的影响较小，将绝对值函数和按元素求和组合起来

1	torch.abs(u).sum()

1	tensor(7.)

$L_2$范数和$L_1$范数都是更一般的$L_p$范数的特例
$$
\mid \mid\mathbf{x}\mid \mid_p = \left(\sum_{i=1}^n \left|x_i \right|^p \right)^{1/p}.
$$
类似于向量的$L_2$范数，矩阵$\mathbf{X} \in \mathbb{R}^{m \times n}$的Frobenius范数(Frobenius norm)是矩阵元素平方和的平方根：
$$
\mid \mid\mathbf{X}\mid \mid_F = \sqrt{\sum_{i=1}^m \sum_{j=1}^n x_{ij}^2}.
$$
Frobenius范数满足向量范数的所有性质，就像是矩阵形向量的$L_2$范数

仍然调用norm函数计算矩阵的Frobenius范数

1	torch.norm(torch.ones((4, 9)))

1	tensor(6.)

范数和目标

在深度学习中经常试图解决优化问题：最大化分配给观测数据的概率; 最小化预测和真实观测之间的距离，用向量表示物品(如单词、产品或新闻文章)，以便最小化相似项目之间的距离，最大化不同项目之间的距离

微积分

导数和微分

在深度学习中，通常选择对于模型参数可微的损失函数。简而言之，对于每个参数，如果把这个参数增加或减少一个无穷小的量，可以知道损失会以多快的速度增加或减少

假设有一个函数$f: \mathbb{R} \rightarrow \mathbb{R}$，其输入和输出都是标量。如果$f$的导数存在，这个极限被定义为
$$
f’(x) = \lim_{h \rightarrow 0} \frac{f(x+h) - f(x)}{h}.
$$
如果$f’(a)$存在，则称在处是**可微(differentiable)**的，导数$f’(x)$解释为相对于$x$的瞬时变化率

给定$y=f(x)$，其中$x$和$y$分别是函数的自变量和因变量，以下表达式是等价的
$$
f’(x) = y’ = \frac{dy}{dx} = \frac{df}{dx} = \frac{d}{dx} f(x) = Df(x) = D_x f(x)
$$
其中符号$\frac{d}{dx}$和$D$是微分运算符，表示微分操作

$DC = 0$($C$为常数)
$Dx^n = nx^{n-1}$
$De^x = e^x$
$D\ln(x) = 1/x$

偏导数

设$y = f(x_1, x_2, \ldots, x_n)$是一个具有$n$个变量的函数，$y$关于第$i$个参数$x_i$的**偏导数(partial derivative)**为
$$
\frac{\partial y}{\partial x_i} = \lim_{h \rightarrow 0} \frac{f(x_1, \ldots, x_{i-1}, x_i+h, x_{i+1}, \ldots, x_n) - f(x_1, \ldots, x_i, \ldots, x_n)}{h}.
$$
对于偏导数的表示，以下是等价的：
$$
\frac{\partial y}{\partial x_i} = \frac{\partial f}{\partial x_i} = f_{x_i} = f_i = D_i f = D_{x_i} f.
$$

梯度

可以连结一个多元函数对其所有变量的偏导数，以得到该函数的**梯度(gradient)**向量

设函数$f:\mathbb{R}^n\rightarrow\mathbb{R}$的输入是一个$n$维向量$\mathbf{x}=[x_1,x_2,\ldots,x_n]^\top$，并且输出是一个标量

函数$f(\mathbf{x})$相对于$\mathbf{x}$的梯度是一个包含$n$个偏导数的向量
$$
\nabla_{\mathbf{x}} f(\mathbf{x}) = \bigg[\frac{\partial f(\mathbf{x})}{\partial x_1}, \frac{\partial f(\mathbf{x})}{\partial x_2}, \ldots, \frac{\partial f(\mathbf{x})}{\partial x_n}\bigg]^\top
$$
$\nabla_{\mathbf{x}} f(\mathbf{x})$通常在没有歧义时被$\nabla f(\mathbf{x})$取代

在微分多元函数时经常使用以下规则：(python默认分子布局，结论改写成分子布局的形式)

对于所有$\mathbf{A} \in \mathbb{R}^{m \times n}$，都有$\nabla_{\mathbf{x}} \mathbf{A} \mathbf{x} = \mathbf{A}$
对于所有$\mathbf{A} \in \mathbb{R}^{n \times m}$，都有$\nabla_{\mathbf{x}} \mathbf{x}^\top \mathbf{A} = \mathbf{A}^\top$
对于所有$\mathbf{A} \in \mathbb{R}^{n \times n}$，都有$\nabla_{\mathbf{x}} \mathbf{x}^\top \mathbf{A} \mathbf{x} = (\mathbf{A} + \mathbf{A}^\top)\mathbf{x}$

如果$\mathbf{A}$对称，则导数更简化为$\nabla_{\mathbf{x}} \mathbf{x}^\top \mathbf{A} \mathbf{x} =2\mathbf{A}\mathbf{x}$，这是神经网络里常见的“平方损失”形式
$\nabla_{\mathbf{x}} \mid\mid\mathbf{x} \mid\mid^2 = \nabla_{\mathbf{x}} \mathbf{x}^\top \mathbf{x} = 2\mathbf{x}$

对于任何矩阵$\mathbf{X}$，都有$\nabla_{\mathbf{X}} |\mathbf{X} |_F^2 = 2\mathbf{X}$

链式法则

假设函数$y=f(u)$和$u=g(x)$都是可微的
$$
\frac{dy}{dx} = \frac{dy}{du} \frac{du}{dx}
$$

练习题

绘制函数$y = f(x) = x^3 - \frac{1}{x}$和其在$x = 1$处切线的图像

import numpy as np
import matplotlib.pyplot as plt

def f(x):
    return x**3 - 1/x

def fp(x):
    return 3*x**2 + 1/x**2

# Tangent line: y = m(x - x1) + y1
def tangent(x):
    return m*(x - x1) + y1

x1 = 1.0
y1 = f(x1)
m = fp(x1)

x = np.linspace(0.1,2,400)
plt.plot(x,f(x),label=r"$y=x^3-\frac{1}{x}$")
plt.plot(x,tangent(x),label="Tangent")
plt.xlabel("x")
plt.ylabel("y")
plt.title(r" $y=x^3-\frac{1}{x}$ Tangent in $x=1$ ")
plt.scatter([x1], [y1], s=40)
plt.legend(loc="upper left")
plt.grid(True)
plt.show()

函数$f(\mathbf{x}) = \mid\mid\mathbf{x}\mid\mid$的梯度是什么?
$$
\mid\mid x\mid\mid=\left(x^{\top} x\right)^{1 / 2}\\
\nabla\mid\mid x\mid\mid=2 x\cdot\frac{1}{2}\left(x^{\top} x\right)^{-1 / 2} =\frac{x}{\mid\mid x \mid\mid}
$$
矢量L2范数关于矢量自身的梯度是与矢量方向相同的单位矢量
尝试写出函数$u = f(x, y, z)$，其中$x = x(a, b)$，$y = y(a, b)$，$z = z(a, b)$的链式法则
$$
\begin{aligned}
& \frac{\partial u}{\partial a}=f_x \frac{\partial x}{\partial a}+f_y \frac{\partial y}{\partial a}+f_z \frac{\partial z}{\partial a} \\
& \frac{\partial u}{\partial b}=f_x \frac{\partial x}{\partial b}+f_y \frac{\partial y}{\partial b}+f_z \frac{\partial z}{\partial b}
\end{aligned}
$$

其中 $f_x, f_y, f_z$ 都在 $(x(a, b), y(a, b), z(a, b))$ 处取值

自动微分

求导是几乎所有深度学习优化算法的关键步骤，但对于复杂的模型，手工进行更新是一件很痛苦的事情(而且经常容易出错)

深度学习框架通过自动计算导数，即**自动微分(automatic differentiation)**来加快求导

根据设计好的模型，系统会构建一个计算图(computational graph)，来跟踪计算是哪些数据通过哪些操作组合起来产生输出。自动微分使系统能够随后反向传播梯度

**反向传播(backpropagate)**意味着跟踪整个计算图，填充关于每个参数的偏导数

简单例子

求导之前需要一个地方来存储梯度，并且不会在每次对一个参数求导时都分配新的内存

1
2
3

x = torch.arange(4,dtype=torch.float32,requires_grad=True)
# requires_grad 启动用于追踪梯度，注意需要float类型
x.grad  # 默认值是None

计算y

1	y = 2 * x@x # tensor(28., grad_fn=<DotBackward0>)

通过调用反向传播函数来自动计算y关于x每个分量的梯度，并打印这些梯度

1 2	y.backward() x.grad

1	tensor([ 0., 4., 8., 12.])

函数$y=2\mathbf{x}^{\top}\mathbf{x}$关于$\mathbf{x}$的梯度应为$4\mathbf{x}$，符合

计算x的另一个函数的导数前，要记得清除梯度，不然梯度会累积

x.grad.zero_() # 清除累积
y = x.sum()
y.backward()
x.grad

1	tensor([1., 1., 1., 1.])

backward 做的是向量–雅可比积，根据链式法则乘上局部雅可比矩阵

若 y 是标量，数学上反向传播的起点只有一个数，默认就是 1，不需要专门输入

若 y 是张量，上游梯度是一个与 y 同形状的张量$v$，如果不告诉它$v$是什么无法计算

1	y.backward(torch.ones_like(y)) # 选择全1方向

因为sum的雅可比就是全1，所以常这么写

1 2	y.sum().backward() # == y.backward( torch.ones_like(y) )

非标量变量的反向传播

当y不是标量时，向量y关于向量x的导数的最自然解释是一个矩阵

对于高阶和高维的y和x，求导的结果可以是一个高阶张量

对非标量调用backward需要传入一个gradient参数，该参数指定微分函数关于self的梯度

x.grad.zero_()
x = torch.ones(2, 2, requires_grad=True)
y = x * 3
z = y ** 2
z.sum().backward()
# z.backward() # 非标量输出反向传播时如果没有指定gradient将会报错
print(x.grad)

1 2	tensor([[18., 18.], [18., 18.]])

分离计算

有时希望将某些计算移动到记录的计算图之外

假设y是作为x的函数计算的，而z则是作为y和x的函数计算的

想计算z关于x的梯度，但由于某种原因，希望将y视为一个常数，并且只考虑到x在y被计算后发挥的作用

可以分离y来返回一个新变量u，该变量与y具有相同的值，但丢弃计算图中如何计算y的任何信息，梯度不会向后流经u到x

x = torch.ones(2, 2, requires_grad=True)
y = x*x
u = y.detach() # 分离出一个新的张量，但共享相同的数据存储
z = u * x
z.sum().backward()
print(x.grad == u)

1 2	tensor([[True, True], [True, True]])

同时也可以在y上调用反向传播，得到y=x*x关于的x的导数

1
2
3

x.grad.zero_()
y.sum().backward()
print(x.grad == 2*x)

1 2	tensor([[True, True], [True, True]])

控制流的梯度计算

使用自动微分的一个好处是，即使构建函数的计算图需要通过Python控制流(例如，条件、循环或任意函数调用)，仍然可以计算得到的变量的梯度

在下面的代码中，while循环的迭代次数和if语句的结果都取决于输入a的值

def f(a):
    b = a*2
    while b.norm()<1000:
        b = b*2
    if b.sum() > 0:
        c = b
    else:
        c = 100 *b
    return c

a.grad.zero_()
a = torch.randn(size=(), requires_grad=True) # () 标量，没有维度
d = f(a)
d.backward() # 标量无所谓
print(a.grad == d/a)
# tensor(True)

练习题

为什么计算二阶导数比一阶导数的开销要更大？

设有函数$f:\mathbb{R}^{n}\rightarrow \mathbb{R}$

一阶导数是一个长度为$n$的向量，PyTorch的默认方式是使用反向模式自动微分(reverse-mode AD)，只要做一次反向传播，就能得到整个梯度向量

二阶导数是一个$n\times n$的矩阵(Hessian(海森矩阵))，要完整求出Hessian，就得重复计算一阶梯度$n$次，每次对不同的分量求导

复杂度从$O(n)$变成了$O(n^2)$
在控制流的例子中，计算d关于a的导数，如果将变量a更改为随机向量或矩阵，会发生什么？

将会报错，因为没有此时不是标量了，没有指定gradient将会报错，改成这个比较稳定，标量或者张量都不会出现报错
1
d.sum().backward()

使$f(x)=\sin(x)$，绘制$f(x)$和$\frac{df(x)}{dx}$的图像，其中后者不使用$f’(x)=\cos(x)$

import torch
import numpy as np
import matplotlib.pyplot as plt
x = torch.linspace(0,2*np.pi,100, requires_grad=True)
fx = torch.sin(x)
fx.sum().backward()
dfx = x.grad
plt.plot(x.detach().numpy(),fx.detach().numpy(),label="f(x)=sin(x)")
plt.plot(x.detach().numpy(), dfx.detach().numpy(), label="dfx")
plt.grid()
plt.legend()
plt.show()

概率

简单地说，机器学习就是做出预测

基本概率论

检查骰子的唯一方法是多次投掷并记录结果

对于每个骰子将观察到${1, \ldots, 6}$中的一个值，对于每个值，一种自然的方法是将它出现的次数除以投掷的总次数，即此**事件(event)**概率的估计值

**大数定律(law of large numbers)**指出：随着投掷次数的增加，这个估计值会越来越接近真实的潜在概率

在统计学中，把从概率分布中抽取样本的过程称为抽样(sampling)，笼统来说可以把**分布(distribution)**看作对事件的概率分配

将概率分配给一些离散选择的分布称为多项分布(multinomial distribution)

为了抽取一个样本，即掷骰子，只需传入一个概率向量，输出是另一个相同长度的向量，它在索引处的值是采样结果中出现的次数

1 2	fair_probs = torch.ones([6]) / 6 # 分配概率 multinomial.Multinomial(1, fair_probs).sample() # 进行采样

1	tensor([0., 0., 0., 1., 0., 0.])

希望从同一分布中生成多个样本，如果用Python的for循环来完成这个任务，速度会慢得惊人

因此使用深度学习框架的函数同时抽取多个样本，得到想要的任意形状的独立样本数组

可以统计1000次投掷后，每个数字被投中了多少次，计算相对频率，以作为真实概率的估计

fair_probs = torch.ones([6]) / 6
fre = 1000
counts = multinomial.Multinomial(fre, fair_probs).sample()
counts/fre

1	tensor([0.1750, 0.1640, 0.1520, 0.1710, 0.1610, 0.1770])

也可以看到这些概率如何随着时间的推移收敛到真实概率，进行500组实验，每组抽取10个样品

import torch
from torch.distributions import multinomial # 概率分布模块
import matplotlib.pyplot as plt
from ipywidgets import interact, IntSlider
def simulate_dice(n=10, m=500):
    fair_probs = torch.ones([6]) / 6
    counts = multinomial.Multinomial(n, fair_probs).sample((m,))
    cum_counts = counts.cumsum(dim=0)
    estimates = cum_counts/cum_counts.sum(dim=1,keepdim=True)
    for i in range(6):
        plt.plot(estimates[:,i].numpy(), label=f"P(die={i+1})")
    plt.axhline(y=0.167, color="black", linestyle="dashed")
    plt.xlabel('Groups of experiments')
    plt.ylabel('Estimated probability')
    plt.title(f"n={n}, m={m}")
    plt.legend()
    plt.show()
# 定义交互
interact(
    simulate_dice,
    n = IntSlider(value = 10, min=1, max=30, step=1, description="n(per group num)"),
    m = IntSlider(value = 500, min=100, max=1000, step=1, description="m(group num)")
)

小n每组信息很少，每次抽样波动巨大；大n每组本身就是一个小样本集，波动明显减弱，样本方差减小，单次实验更接近期望

增大m结果会更接近理论值

概率论公理

在给定的样本空间$\mathcal{S}$中，事件$\mathcal{A}$的概率，表示为$P(\mathcal{A})$，满足以下属性：

对于任意事件$\mathcal{A}$，其概率从不会是负数，即$P(\mathcal{A}) \geq 0$
整个样本空间的概率为1，即$P(\mathcal{S}) = 1$
对于**互斥(mutually exclusive)**事件，任意一个可数序列$\mathcal{A}_1, \mathcal{A}2, \ldots$，序列中任意一个事件发生的概率等于它们各自发生的概率之和，即$P(\bigcup{i=1}^{\infty} \mathcal{A}i) = \sum{i=1}^{\infty} P(\mathcal{A}_i)$

随机变量

随机变量几乎可以是任何数量，并且它可以在随机实验的一组可能性中取一个值

考虑一个随机变量$X$，其值在掷骰子的样本空间$\mathcal{S}={1,2,3,4,5,6}$中，可以将事件“看到一个5”表示为${X=5}$或$X=5$，其概率表示为$P({X=5})$或$P(X=5)$

**离散(discrete)随机变量(如骰子的每一面)和连续(continuous)**随机变量(如人的体重和身高)之间存在微妙的区别

将这个看到某个数值的可能性量化为**密度(density)**更为合适

处理多个随机变量

当处理多个随机变量时，会有若干个变量是我们感兴趣的

联合概率

对于$P(A=a,B=b)$回答：$A=a$和$B=b$同时满足的概率是多少？

对于任何$a$和$b$的取值，必然满足$P(A = a, B=b) \leq P(A=a)$，同时发生的概率一定不大于单独事件的发生概率

条件概率

联合概率的不等式带出
$$
0 \leq \frac{P(A=a, B=b)}{P(A=a)} \leq 1
$$
称这个比率为条件概率(conditional probability)，并用$P(B=b \mid A=a)$表示它

贝叶斯定理

使用条件概率的定义可以得出统计学中最有用的方程之一：Bayes定理(Bayes’ theorem)

根据乘法法则(multiplication rule)可得到$P(A, B) = P(B \mid A) P(A)$，根据对称性，可得到$P(A, B) = P(A \mid B) P(B)$

假设$P(B)>0$，求解条件概率
$$
P(A \mid B) = \frac{P(B \mid A) P(A)}{P(B)}
$$

边际化

为了能进行事件概率求和，需要求和法则(sum rule)，即$B$的概率相当于计算的所有可能选择，并将所有选择的联合概率聚合在一起：
$$
P(B) = \sum_{A} P(A, B)
$$
这也称为边际化(marginalization)，边际化结果的概率或分布称为边际概率或边际分布

独立性

如果两个随机变量$A$和$B$是独立的，意味着事件$A$的发生跟事件$B$的发生无关

在这种情况下，统计学家通常将这一点表述为$A \perp B$

根据贝叶斯定理，马上就能同样得到$P(A \mid B) = P(A)$，在所有其他情况下，称$A$和$B$依赖

根据条件分布$P(A \mid B) = \frac{P(A, B)}{P(B)} = P(A)$，等价于$P(A, B) = P(A)P(B)$，因此两个随机变量是独立的，当且仅当两个随机变量的联合分布是其各自分布的乘积

给定另一个随机变量$C$时，两个随机变量$A$和$B$是条件独立的(conditionally independent)，当且仅当$P(A, B \mid C) = P(A \mid C)P(B \mid C)$，这个情况表示为$A \perp B \mid C$

概念应用

假设一个医生对患者进行艾滋病病毒(HIV)测试，如果患者健康但测试显示他患病，这个概率只有1%；如果患者真正感染HIV，它永远不会检测不出

使用$D_1$来表示诊断结果(如果阳性为1，如果阴性为0)，$H$来表示感染艾滋病病毒的状态(如果阳性为1，如果阴性为0)，条件概率表中表示：

条件概率	$H=1$	$H=0$
$P(D_1 = 1 \mid H)$	1	0.01
$P(D_1 = 0 \mid H)$	0	0.99

每列的加和都是1(但每行的加和不是)，因为条件概率需要总和为1，就像概率一样

现在要计算如果测试出来呈阳性，患者感染HIV的概率，即$P(H = 1 \mid D_1 = 1)$

根据贝叶斯定理
$$
P(H = 1 \mid D_1 = 1)= \frac{P(D_1=1 \mid H=1) P(H=1)}{P(D_1=1)}
$$
假设人口总体是相当健康的$P(H=1) = 0.0015$，可以求出$P(D_1 = 1) $
$$
\begin{split}\begin{aligned}
P(D_1 = 1) =& P(D_1=1, H=0) + P(D_1=1, H=1) \\
=& P(D_1=1 \mid H=0) P(H=0) + P(D_1=1 \mid H=1) P(H=1) \\
=& 0.011485.
\end{aligned}\end{split}
$$
因此得到
$$
\begin{aligned}
P(H = 1 \mid D_1 = 1)= \frac{P(D_1=1 \mid H=1) P(H=1)}{P(D_1=1)} = 0.1306 \end{aligned}
$$
尽管使用了非常准确的测试，患者实际上患有艾滋病的几率只有13.06%，概率可能是违反直觉的

患者会要求医生进行另一次测试来确定病情，第二个测试具有不同的特性，它不如第一个测试那么精确

条件概率	H=1	H=0
$P(D_2 = 1 \mid H)$	0.98	0.03
$P(D_2 = 0 \mid H)$	0.02	0.97

不幸的是，第二次测试也显示阳性，通过假设条件独立性来计算出应用Bayes定理的必要概率

计算目标为
$$
\begin{split}\begin{aligned}
P(H = 1 \mid D_1 = 1, D_2 = 1)
= \frac{P(D_1 = 1, D_2 = 1 \mid H=1) P(H=1)}{P(D_1 = 1, D_2 = 1)}
\end{aligned}\end{split}
$$
两次检测都为阳性实际上没感染的概率
$$
\begin{split}\begin{aligned}
P(D_1 = 1, D_2 = 1 \mid H = 0) = P(D_1 = 1 \mid H = 0) P(D_2 = 1 \mid H = 0)
= 0.0003
\end{aligned}\end{split}
$$
两次检测都为阳性实际上感染的概率
$$
\begin{split}\begin{aligned}
P(D_1 = 1, D_2 = 1 \mid H = 1) = P(D_1 = 1 \mid H = 1) P(D_2 = 1 \mid H = 1)
= 0.98
\end{aligned}\end{split}
$$
现在可以应用边际化和乘法规则
$$
\begin{split}\begin{aligned}
P(D_1 = 1, D_2 = 1)
=& P(D_1 = 1, D_2 = 1, H = 0) + P(D_1 = 1, D_2 = 1, H = 1) \\
=& P(D_1 = 1, D_2 = 1 \mid H = 0)P(H=0) + P(D_1 = 1, D_2 = 1 \mid H = 1)P(H=1)\\
=& 0.00176955
\end{aligned}\end{split}
$$
鉴于存在两次阳性检测，患者患有艾滋病的概率为
$$
\begin{split}\begin{aligned}
P(H = 1 \mid D_1 = 1, D_2 = 1)
= \frac{P(D_1 = 1, D_2 = 1 \mid H=1) P(H=1)}{P(D_1 = 1, D_2 = 1)}
= 0.8307
\end{aligned}\end{split}
$$
第二次测试能够对患病的情况获得更高的信心，尽管第二次检验比第一次检验的准确性要低得多

期望和方差

一个随机变量$X$的**期望(expectation)**表示为
$$
E[X] = \sum_{x} x P(X = x)
$$
当函数$f(x)$的输入是从分布$P$中抽取的随机变量时，$f(x)$的期望值为
$$
E_{x \sim P}[f(x)] = \sum_x f(x) P(x)
$$
在许多情况下，希望衡量随机变量$X$与其期望值的偏置，这可以通过方差来量化
$$
\mathrm{Var}[X] = E\left[(X - E[X])^2\right] =E[X^2] - E[X]^2
$$
随机变量函数的方差衡量当从该随机变量分布中采样不同值时，函数值偏离该函数的期望的程度
$$
\mathrm{Var}[f(x)] = E\left[\left(f(x) - E[f(x)]\right)^2\right]
$$

练习题

给定两个概率为$ P(\mathcal{A}) $和$P(\mathcal{B})$的事件，计算$P(\mathcal{A} \cup \mathcal{B})$和$P(\mathcal{A} \cap \mathcal{B})$的上限和下限(韦恩图)

假设$ P(\mathcal{A}) =p, P(\mathcal{B})=q $

$P(\mathcal{A} \cup \mathcal{B})=p+q-P(\mathcal{A} \cap \mathcal{B})$：

两个事件越独立越大(交集小)，下界在交集大(一个尽量包含另一个)时取得
$$
\mathrm{max}(p,q)\le P(\mathcal{A} \cup \mathcal{B})\le \mathrm{min}(1,p+q)
$$
$P(\mathcal{A} \cap \mathcal{B})=p+q-P(\mathcal{A} \cup \mathcal{B})$：

上界不能超过小的那个事件，下界由全集限制
$$
\mathrm{max}(0,p+q-1) \le P(\mathcal{A} \cap \mathcal{B}) \le \mathrm{min}(p,q)
$$
假设有一系列随机变量$A,B,C$，其中$B$只依赖于$A$，而$C$只依赖于$B$，能简化联合概率 $P(A,B,C)$吗?

马尔可夫链的关键性质是“无记忆性”，对于$A,B,C$它们形成了马尔可夫链
$$
A\rightarrow B \rightarrow C
$$
那么可以简化为
$$
P(A,B,C)=P(A)P(B\mid A)P(C\mid B)
$$
而不是一般情况下的
$$
P(A,B,C)=P(A)P(B\mid A)P(C\mid A,B)
$$
因为$C$不直接依赖$A$

未来的演化不依赖更早的历史，只依赖当下的状态