本文最后更新于：1 年前

要学习深度学习，首先需要先掌握一些基本技能。所有机器学习方法都涉及从数据中提取信息。因此，我们先学习一些关于数据的实用技能，包括存储、操作和预处理数据。机器学习通常需要处理大型数据集。 线性代数为人们提供了一些用来处理表格数据的方法。我们可以将某些数据集视为一个表，其中表的行对应样本，列对应属性。深度学习是关于优化的学习。对于一个带有参数的模型，我们想要找到其中能拟合数据的最好模型。在算法的每个步骤中，决定以何种方式调整参数需要一点微积分知识。机器学习还涉及如何做出预测：给定观察到的信息，某些未知属性可能的值是多少？要在不确定的情况下进行严格的推断，我们需要借用概率语言。

数据操作

这里可以使用Jupyter Notebook进行操作昂

入门

引入pytorch

1	`import torch`

张量表示一个由数值组成的数组，这个数组可能有多个维度。具有一个轴的张量对应数学上的向量（vector）；具有两个轴的张量对应数学上的矩阵（matrix）；具有两个轴以上的张量没有特殊的数学名称。

1 2	`x = torch.arange(12) x`

通过张量的shape属性来访问张量（沿每个轴的长度）的形状。

x.shape

如果只想知道张量中元素的总数，即形状的所有元素乘积，可以检查它的大小（size）。因为这里在处理的是一个向量，所以它的shape与它的size相同。

1	`x.numel()`

要想改变一个张量的形状而不改变元素数量和元素值，可以调用reshape函数。注意，通过改变张量的形状，张量的大小不会改变。

1 2	`X = x.reshape(3, 4) X`

我们不需要通过手动指定每个维度来改变形状。也就是说，如果我们的目标形状是（高度,宽度），那么在知道宽度后，高度会被自动计算得出。即我们可以用x.reshape(-1,4)或x.reshape(3,-1)来取代x.reshape(3,4)。

有时，我们希望使用全0、全1、其他常量，或者从特定分布中随机采样的数字来初始化矩阵。我们可以创建一个形状为（2,3,4）的张量，其中所有元素都设置为0。

1 2	`torch.zeros((2, 3, 4)) torch.ones((2, 3, 4))`

有时我们想通过从某个特定的概率分布中随机采样来得到张量中每个元素的值。例如，当我们构造数组来作为神经网络中的参数时，我们通常会随机初始化参数的值。以下代码创建一个形状为（3,4）的张量。其中的每个元素都从均值为0、标准差为1的标准高斯分布（正态分布）中随机采样。

1	`torch.randn(3, 4)`

我们还可以通过提供包含数值的Python列表（或嵌套列表），来为所需张量中的每个元素赋予确定值。在这里，最外层的列表对应于轴0，内层的列表对应于轴1。

1	`torch.tensor([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])`

运算符

我们想在这些数据上执行数学运算，其中最简单且最有用的操作是按元素（elementwise）运算。它们将标准标量运算符应用于数组的每个元素。对于将两个数组作为输入的函数，按元素运算将二元运算符应用于两个数组中的每对位置对应的元素。我们可以基于任何从标量到标量的函数来创建按元素函数。总之就是，要么对一个tensor批量操作，要么多个tensor对应位置批量操作。

x = torch.tensor([1.0, 2, 4, 8])
y = torch.tensor([2, 2, 2, 2])
x + y, x - y, x * y, x / y, x ** y  # **运算符是求幂运算
torch.exp(x)

除了按元素计算外，我们还可以执行线性代数运算，包括向量点积和矩阵乘法。我们也可以把多个张量连结（concatenate）在一起，把它们端对端地叠起来形成一个更大的张量。我们只需要提供张量列表，并给出沿哪个轴连结。

X = torch.arange(12, dtype=torch.float32).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.]]))

dim=0是按照行，后面的append到前面的。dim=1是按照列，右边的append到左边的。

有时，我们想通过逻辑运算符构建二元张量。

X == Y

对于每个位置，如果X和Y在该位置相等，则新张量中相应项的值为1。这意味着逻辑语句X == Y在该位置处为真，否则该位置为0。

对张量中的所有元素进行求和，会产生一个单元素张量。

X.sum()

广播机制

在某些情况下，即使形状不同，我们仍然可以通过调用 广播机制（broadcasting mechanism）来执行按元素操作。这种机制的工作方式如下：
1. 通过适当复制元素来扩展一个或两个数组，以便在转换之后，两个张量具有相同的形状；
2. 对生成的数组执行按元素操作。

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

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

# 结果
(tensor([[0],
         [1],
         [2]]),
 tensor([[0, 1]]))

a和b分别是3×1和1×2矩阵，如果让它们相加，它们的形状不匹配。我们将两个矩阵广播为一个更大的3×2矩阵

a + b

# 结果
tensor([[0, 1],
        [1, 2],
        [2, 3]])

索引和切片

就像在任何其他Python数组中一样，张量中的元素可以通过索引访问。与任何Python数组一样：第一个元素的索引是0，最后一个元素索引是-1；可以指定范围以包含第一个元素和最后一个之前的元素。

1	`X[-1], X[1:3]`

左闭右开依然适用，如果是矩阵的话，注意这里表示的是行！！！

除读取外，我们还可以通过指定索引来将元素写入矩阵。

1 2	`X[1, 2] = 9 X`

如果我们想为多个元素赋值相同的值，我们只需要索引所有元素，然后为它们赋值。例如，[0:2, :]访问第1行和第2行，其中“:”代表沿轴1（列）的所有元素。虽然我们讨论的是矩阵的索引，但这也适用于向量和超过2个维度的张量。

1 2	`X[0:2, :] = 12 X`

代表第一行和第二行的所有列，都变为12

节省内存

运行一些操作可能会导致为新结果分配内存。例如，如果我们用Y = X + Y，我们将取消引用Y指向的张量，而是指向新分配的内存处的张量。

我们用Python的id()函数演示了这一点，它给我们提供了内存中引用对象的确切地址。运行Y = Y + X后，我们会发现id(Y)指向另一个位置。这是因为Python首先计算Y + X，为结果分配新的内存，然后使Y指向内存中的这个新位置。

before = id(Y)
Y = Y + X
id(Y) == before

# 结果
False

这可能是不可取的，原因有两个：
1. 首先，我们不想总是不必要地分配内存。在机器学习中，我们可能有数百兆的参数，并且在一秒内多次更新所有参数。通常情况下，我们希望原地执行这些更新；
2. 如果我们不原地更新，其他引用仍然会指向旧的内存位置，这样我们的某些代码可能会无意中引用旧的参数。
幸运的是，执行原地操作非常简单。我们可以使用切片表示法将操作的结果分配给先前分配的数组，例如Y[:] = <expression>。为了说明这一点，我们首先创建一个新的矩阵Z，其形状与另一个Y相同，使用zeros_like来分配一个全0的块。

Z = torch.zeros_like(Y)
print('id(Z):', id(Z))
# 说白了就是下面这里，可以保证Z的内存位置不变捏！！！
Z[:] = X + Y
print('id(Z):', id(Z))

# 结果
id(Z): 139931132035296
id(Z): 139931132035296

如果在后续计算中没有重复使用X，我们也可以使用X[:] = X + Y或X += Y来减少操作的内存开销。

before = id(X)
X += Y
id(X) == before

# 结果
True

转换为其他Python对象

将深度学习框架定义的张量转换为NumPy张量（ndarray）很容易，反之也同样容易。 torch张量和numpy数组将共享它们的底层内存，就地操作更改一个张量也会同时更改另一个张量。

A = X.numpy()
B = torch.tensor(A)
type(A), type(B)

# 结果
(numpy.ndarray, torch.Tensor)

要将大小为1的张量转换为Python标量，我们可以调用item函数或Python的内置函数。

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

# 结果
(tensor([3.5000]), 3.5, 3.5, 3)

Summary

深度学习存储和操作数据的主要接口是张量（$n$维数组, Tensor）。它提供了各种功能，包括基本数学运算、广播、索引、切片、内存节省和转换其他Python对象。

数据预处理

在Python中常用的数据分析工具中，我们通常使用pandas软件包。像庞大的Python生态系统中的许多其他扩展包一样，pandas可以与张量兼容。本节我们将简要介绍使用pandas预处理原始数据，并将原始数据转换为张量格式的步骤。后面的章节将介绍更多的数据预处理技术。

读取数据集

Read_csv函数

# 如果没有安装pandas，只需取消对以下行的注释来安装pandas
# !pip install pandas
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中缺少的数值，我们用同一列的均值替换“NaN”项。

inputs, outputs = data.iloc[:, 0:2], data.iloc[:, 2]
# 用inputs的平均值填充NaN
inputs = inputs.fillna(inputs.mean())
print(inputs)

# 结果
   NumRooms Alley
0       3.0  Pave
1       2.0   NaN
2       4.0   NaN
3       3.0   NaN

对于inputs中的类别值或离散值，我们将“NaN”视为一个类别。由于“巷子类型”（“Alley”）列只接受两种类型的类别值“Pave”和“NaN”， pandas可以自动将此列转换为两列“Alley_Pave”和“Alley_nan”。巷子类型为“Pave”的行会将“Alley_Pave”的值设置为1，“Alley_nan”的值设置为0。缺少巷子类型的行会将“Alley_Pave”和“Alley_nan”分别设置为0和1。

inputs = pd.get_dummies(inputs, dummy_na=True)
print(inputs)

# 结果
   NumRooms  Alley_Pave  Alley_nan
0       3.0           1          0
1       2.0           0          1
2       4.0           0          1
3       3.0           0          1

Reference: https://pandas.pydata.org/docs/reference/api/pandas.get_dummies.html

转换为张量格式

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

import torch

X, y = torch.tensor(inputs.values), torch.tensor(outputs.values)
X, y

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

Summary

pandas软件包是Python中常用的数据分析工具中，pandas可以与张量兼容。
用pandas处理缺失的数据时，我们可根据情况选择用插值法和删除法。
ChatGPT + Google，不懂就问，可以帮助我们解决很多问题昂！

线性代数

线性代数内容有助于读者了解和实现本书中介绍的大多数模型

标量

严格来说，仅包含一个数值被称为标量（scalar），没有方向的概念，就是简单的值。（例如：温度）

import torch

x = torch.tensor(3.0)
y = torch.tensor(2.0)

x + y, x * y, x / y, x**y

向量

向量可以被视为标量值组成的列表。这些标量值被称为向量的元素（element）或分量（component）。当向量表示数据集中的样本时，它们的值具有一定的现实意义。

1 2	`x = torch.arange(4) x`

我们可以使用下标来引用向量的任一元素，例如可以通过$x_{i}$来引用第$i$个元素。注意，元素$x_{i}$是一个标量，所以我们在引用它时不会加粗。

$$
\begin{split}\mathbf{x} =\begin{bmatrix}x_{1} \x_{2} \ \vdots \x_{n}\end{bmatrix},\end{split}
$$

其中$x_1,\ldots,x_n$是向量的元素。在代码中，我们通过张量的索引来访问任一元素。

长度、维度和形状

向量只是一个数字数组，就像每个数组都有一个长度一样，每个向量也是如此。在数学表示法中，如果我们想说一个向量$\mathbf{x}$由$n$个实值标量组成，可以将其表示为$\mathbf{x}\in\mathbb{R}^n$。向量的长度通常称为向量的维度（dimension）。

1 2	`len(x) x.shape`

维度（dimension）这个词在不同上下文时往往会有不同的含义，这经常会使人感到困惑。为了清楚起见，我们在此明确一下：向量或轴的维度被用来表示向量或轴的长度，即向量或轴的元素数量。然而，张量的维度用来表示张量具有的轴数。在这个意义上，张量的某个轴的维数就是这个轴的长度。

矩阵

正如向量将标量从零阶推广到一阶，矩阵将向量从一阶推广到二阶。矩阵，我们通常用粗体、大写字母来表示（例如$\mathbf{X}$），在代码中表示为具有两个轴的张量。$\mathbf{A} \in \mathbb{R}^{m \times n}$表示矩阵$\mathbf{A}$，其由$m$行和$n$列的实值标量组成。当矩阵具有相同数量的行和列时，其形状将变为正方形；因此，它被称为方阵（square matrix）。

$$
\begin{split}\mathbf{A}=\begin{bmatrix} a_{11} & a_{12} & \cdots & a_{1n} \ a_{21} & a_{22} & \cdots & a_{2n} \ \vdots & \vdots & \ddots & \vdots \ a_{m1} & a_{m2} & \cdots & a_{mn} \ \end{bmatrix}.\end{split}
$$

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

当我们交换矩阵的行和列时，结果称为矩阵的转置（transpose）。通常用$\mathbf{a}^\top$来表示矩阵的转置，如果$\mathbf{B}=\mathbf{A}^\top$，则对于任意$i$和$j$，都有$b_{ij}=a_{ji}$。

$$
\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}
$$

A.T

作为方阵的一种特殊类型，对称矩阵（symmetric matrix）满足 $\mathbf{A} = \mathbf{A}^\top$

B = torch.tensor([[1, 2, 3], [2, 0, 4], [3, 4, 5]])
B == B.T

# 结果
tensor([[True, True, True],
        [True, True, True],
        [True, True, True]])

矩阵是有用的数据结构：它们允许我们组织具有不同模式的数据。

张量

就像向量是标量的推广，矩阵是向量的推广一样，我们可以构建具有更多轴的数据结构。张量（本小节中的“张量”指代数对象）是描述具有任意数量轴的$n$维数组的通用方法。向量是一阶张量，矩阵是二阶张量。张量用特殊字体的大写字母表示（例如$\mathsf{X}$），它们的索引机制与矩阵类似。当我们开始处理图像时，张量将变得更加重要，图像以$n$维数组形式出现，其中3个轴对应于高度、宽度，以及一个通道（channel）轴，用于表示颜色通道（红色、绿色和蓝色）。

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

张量算法的基本性质

标量、向量、矩阵和任意数量轴的张量（本小节中的“张量”指代数对象）有一些实用的属性。例如，从按元素操作的定义中可以注意到，任何按元素的一元运算都不会改变其操作数的形状。同样，给定具有相同形状的任意两个张量，任何按元素二元运算的结果都将是相同形状的张量。例如，将两个相同形状的矩阵相加，会在这两个矩阵上执行元素加法。

1
2
3

A = torch.arange(20, dtype=torch.float32).reshape(5, 4)
B = A.clone()  # 通过分配新内存，将A的一个副本分配给B
A, A + B

两个矩阵的按元素乘法称为Hadamard积（Hadamard product）

$$
\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}
$$

A * B

将张量乘以或加上一个标量不会改变张量的形状，其中张量的每个元素都将与标量相加或相乘。

1
2
3

a = 2
X = torch.arange(24).reshape(2, 3, 4)
a + X, (a * X).shape

降维

我们可以对任意张量进行的一个有用的操作是计算其元素的和。为了表示长度为$d$的向量中元素的总和，可以记为$\sum_{i=1}^dx_i$。

1 2	`x = torch.arange(4, dtype=torch.float32) x, x.sum()`

我们可以表示任意形状张量的元素和。例如，矩阵$\mathbf{A}$中元素的和可以记为$\sum_{i=1}^{m} \sum_{j=1}^{n} a_{ij}$

A.sum()

默认情况下，调用求和函数会沿所有的轴降低张量的维度，使它变为一个标量。我们还可以指定张量沿哪一个轴来通过求和降低维度。以矩阵为例，为了通过求和所有行的元素来降维（轴0），可以在调用函数时指定axis=0。由于输入矩阵沿0轴降维以生成输出向量，因此输入轴0的维数在输出形状中消失。

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

指定axis=1将通过汇总所有列的元素降维（轴1）。因此，输入轴1的维数在输出形状中消失。

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

沿着行和列对矩阵求和，等价于对矩阵的所有元素进行求和。

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

一个与求和相关的量是平均值（mean或average）。我们通过将总和除以元素总数来计算平均值。在代码中，我们可以调用函数来计算任意形状张量的平均值。

1	`A.mean(), A.sum() / A.numel()`

计算平均值的函数也可以沿指定轴降低张量的维度。

1	`A.mean(axis=0), A.sum(axis=0) / A.shape[0]`

非降维求和

有时在调用函数来计算总和或均值时保持轴数不变会很有用。

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

由于sum_A在对每行进行求和后仍保持两个轴，我们可以通过广播将A除以sum_A。

1	`A / sum_A`

如果我们想沿某个轴计算A元素的累积总和，比如axis=0（按行计算），可以调用cumsum函数。此函数不会沿任何轴降低输入张量的维度。

1	`A.cumsum(axis=0)`

点积(dot product)

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

1 2	`y = torch.ones(4, dtype = torch.float32) x, y, torch.dot(x, y)`

我们可以通过执行按元素乘法，然后进行求和来表示两个向量的点积

1	`torch.sum(x * y)`

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

矩阵-向量积

矩阵-向量积（matrix-vector product），$\mathbf{A} \in \mathbb{R}^{m \times n}$是矩阵，$\mathbf{x} \in \mathbb{R}^n$是向量。

$$
\begin{split}\mathbf{A}=
\begin{bmatrix}
\mathbf{a}^\top_{1} \
\mathbf{a}^\top_{2} \
\vdots \
\mathbf{a}^\top_m \
\end{bmatrix},\end{split}
$$

$$
\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}$到转换，这些转换是非常有用的，例如可以用方阵的乘法来表示旋转。可以使用矩阵-向量积来描述在给定前一层的值时，求解神经网络每一层所需的复杂计算。

矩阵-向量积，我们使用mv函数。当我们为矩阵A和向量x调用torch.mv(A, x)时，会执行矩阵-向量积。注意，A的列维数（沿轴1的长度）必须与x的维数（其长度）相同。

1	`A.shape, x.shape, torch.mv(A, x)`

矩阵-矩阵乘法

掌握点积和矩阵-向量积的知识后，那么矩阵-矩阵乘法（matrix-matrix multiplication）应该很简单。

$\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}
$$

$$
\begin{split}\mathbf{A}=
\begin{bmatrix}
\mathbf{a}^\top_{1} \
\mathbf{a}^\top_{2} \
\vdots \
\mathbf{a}^\top_n \
\end{bmatrix},
\quad \mathbf{B}=\begin{bmatrix}
\mathbf{b}{1} & \mathbf{b}{2} & \cdots & \mathbf{b}_{m} \
\end{bmatrix}.\end{split}
$$

$$
\begin{split}\mathbf{C} = \mathbf{AB} = \begin{bmatrix}
\mathbf{a}^\top_{1} \
\mathbf{a}^\top_{2} \
\vdots \
\mathbf{a}^\top_n \
\end{bmatrix}
\begin{bmatrix}
\mathbf{b}{1} & \mathbf{b}{2} & \cdots & \mathbf{b}{m} \
\end{bmatrix}
= \begin{bmatrix}
\mathbf{a}^\top{1} \mathbf{b}1 & \mathbf{a}^\top{1}\mathbf{b}2& \cdots & \mathbf{a}^\top{1} \mathbf{b}m \
\mathbf{a}^\top{2}\mathbf{b}1 & \mathbf{a}^\top{2} \mathbf{b}2 & \cdots & \mathbf{a}^\top{2} \mathbf{b}m \
\vdots & \vdots & \ddots &\vdots\
\mathbf{a}^\top{n} \mathbf{b}1 & \mathbf{a}^\top{n}\mathbf{b}2& \cdots& \mathbf{a}^\top{n} \mathbf{b}_m
\end{bmatrix}.\end{split}
$$

当作n x 1（列向量）和1 x m（行向量），看作简单地执行$m$次矩阵-向量积，并将结果拼接在一起，形成一个$n \times m$矩阵。

1 2	`B = torch.ones(4, 3) torch.mm(A, B)`

矩阵-矩阵乘法可以简单地称为矩阵乘法，不应与”Hadamard积”混淆。

范数

线性代数中最有用的一些运算符是范数（norm）。非正式地说，向量的范数是表示一个向量有多大。这里考虑的大小（size）概念不涉及维度，而是分量的大小。向量范数是将向量映射到标量的函数$f$。满足的性质有

$$
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. \

\forall i, [\mathbf{x}]_i = 0 \Leftrightarrow f(\mathbf{x})=0. \

|\mathbf{x}|2 = \sqrt{\sum{i=1}^n x_i^2},
$$

范数听起来很像距离的度量。欧几里得距离和毕达哥拉斯定理中的非负性概念和三角不等式可能会给出一些启发。事实上，欧几里得距离是一个$L_2$范数：假设$n$维向量$x$中的元素是$x_1,\ldots,x_n$，其$L_2$范数是向量元素平方和的平方根。

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

# 结果
tensor(5.)

在我看来，就是如何求一个向量的长短嘛，还是直角坐标系那一套东西。
深度学习中更经常地使用$L_2$范数的平方，也会经常遇到$L_1$范数，它表示为向量元素的绝对值之和。与$L_2$范数相比，$L_1$范数受异常值的影响较小。为了计算$L_1$范数，我们将绝对值函数和按元素求和组合起来。

$$
|\mathbf{x}|1 = \sum{i=1}^n \left|x_i \right|.
$$

1	`torch.abs(u).sum()`

$L_2$和$L_1$范数都是$L_p$范数的特例：

$$
|\mathbf{x}|p = \left(\sum{i=1}^n \left|x_i \right|^p \right)^{1/p}.
$$

类似于$L_2$范数，矩阵的范数为：

$$
|\mathbf{X}|F = \sqrt{\sum{i=1}^m \sum_{j=1}^n x_{ij}^2}.
$$

Frobenius范数满足向量范数的所有性质，它就像是矩阵形向量的$L_2$范数。调用以下函数将计算矩阵的Frobenius范数。

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

范数和目标

在深度学习中，我们经常试图解决优化问题： 最大化分配给观测数据的概率; 最小化预测和真实观测之间的距离。用向量表示物品（如单词、产品或新闻文章），以便最小化相似项目之间的距离，最大化不同项目之间的距离。目标，或许是深度学习算法最重要的组成部分（除了数据），通常被表达为范数。

关于线性代数的更多信息

线性代数还有很多，其中很多数学对于机器学习非常有用。例如，矩阵可以分解为因子，这些分解可以显示真实世界数据集中的低维结构。机器学习的整个子领域都侧重于使用矩阵分解及其向高阶张量的泛化，来发现数据集中的结构并解决预测问题。当开始动手尝试并在真实数据集上应用了有效的机器学习模型，你会更倾向于学习更多数学。

微积分

逼近法就是积分（integral calculus）的起源。 2000多年后，微积分的另一支，微分（differential calculus）被发明出来。在微分学最重要的应用是优化问题，即考虑如何把事情做到最好。
在深度学习中，我们“训练”模型，不断更新它们，使它们在看到越来越多的数据时变得越来越好。通常情况下，变得更好意味着最小化一个损失函数（loss function），即一个衡量“模型有多糟糕”这个问题的分数。最终，我们真正关心的是生成一个模型，它能够在从未见过的数据上表现良好。但“训练”模型只能将模型与我们实际能看到的数据相拟合。因此，我们可以将拟合模型的任务分解为两个关键问题：
- 优化（optimization）：用模型拟合观测数据的过程；
- 泛化（generalization）：数学原理和实践者的智慧，能够指导我们生成出有效性超出用于训练的数据集本身的模型。

导数和微分

如果$f$的导数存在，这个极限被定义为：

$$
f’(x) = \lim_{h \rightarrow 0} \frac{f(x+h) - f(x)}{h}.
$$

如果$f’(a)$存在，则称$f(x)$在$a$处是可微（differentiable）的。如果$f(x)$在一个区间内的每个数上都是可微的，则此函数在此区间中是可微的。我们可以将导数$f’(x)$解释为$f(x)$相对于$x$的瞬时（instantaneous）变化率。所谓的瞬时变化率是基于$h$中的变化$h$，且$h$接近0。

# mock 导数
%matplotlib inline
import numpy as np
from matplotlib_inline import backend_inline
from d2l import torch as d2l


def f(x):
    return 3 * x ** 2 - 4 * x

def numerical_lim(f, x, h):
    return (f(x + h) - f(x)) / h

h = 0.1
for i in range(5):
    print(f'h={h:.5f}, numerical limit={numerical_lim(f, 1, h):.5f}')
    h *= 0.1

# res
h=0.10000, numerical limit=2.30000
h=0.01000, numerical limit=2.03000
h=0.00100, numerical limit=2.00300
h=0.00010, numerical limit=2.00030
h=0.00001, numerical limit=2.00003

导数符号：

$$
f’(x) = y’ = \frac{dy}{dx} = \frac{df}{dx} = \frac{d}{dx} f(x) = Df(x) = D_x f(x),
$$

我们可以使用以下规则来对常见函数求微分：

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

法则：

$$
常数乘法法则：\frac{d}{dx} [Cf(x)] = C \frac{d}{dx} f(x), \
加法法则：\frac{d}{dx} [f(x) + g(x)] = \frac{d}{dx} f(x) + \frac{d}{dx} g(x), \
乘法法则：\frac{d}{dx} [f(x)g(x)] = f(x) \frac{d}{dx} [g(x)] + g(x) \frac{d}{dx} [f(x)], \
除法法则：\frac{d}{dx} \left[\frac{f(x)}{g(x)}\right] = \frac{g(x) \frac{d}{dx} [f(x)] - f(x) \frac{d}{dx} [g(x)]}{[g(x)]^2}.
$$

对导数的这种解释进行可视化，我们将使用matplotlib，这是一个Python中流行的绘图库。要配置matplotlib生成图形的属性，我们需要定义几个函数。在下面，use_svg_display函数指定matplotlib软件包输出svg图表以获得更清晰的图像。

注意，注释#@save是一个特殊的标记，会将对应的函数、类或语句保存在d2l包中。因此，以后无须重新定义就可以直接调用它们（例如，d2l.use_svg_display()）。

#@save
def use_svg_display():
    """使用svg格式在Jupyter中显示绘图"""
    backend_inline.set_matplotlib_formats('svg')

#@save
def set_figsize(figsize=(3.5, 2.5)):
    """设置matplotlib的图表大小"""
    use_svg_display()
    d2l.plt.rcParams['figure.figsize'] = figsize
    
#@save
def set_axes(axes, xlabel, ylabel, xlim, ylim, xscale, yscale, legend):
    """设置matplotlib的轴"""
    axes.set_xlabel(xlabel)
    axes.set_ylabel(ylabel)
    axes.set_xscale(xscale)
    axes.set_yscale(yscale)
    axes.set_xlim(xlim)
    axes.set_ylim(ylim)
    if legend:
        axes.legend(legend)
    axes.grid()
    
#@save
def plot(X, Y=None, xlabel=None, ylabel=None, legend=None, xlim=None,
         ylim=None, xscale='linear', yscale='linear',
         fmts=('-', 'm--', 'g-.', 'r:'), figsize=(3.5, 2.5), axes=None):
    """绘制数据点"""
    if legend is None:
        legend = []

    set_figsize(figsize)
    axes = axes if axes else d2l.plt.gca()

    # 如果X有一个轴，输出True
    def has_one_axis(X):
        return (hasattr(X, "ndim") and X.ndim == 1 or isinstance(X, list)
                and not hasattr(X[0], "__len__"))

    if has_one_axis(X):
        X = [X]
    if Y is None:
        X, Y = [[]] * len(X), X
    elif has_one_axis(Y):
        Y = [Y]
    if len(X) != len(Y):
        X = X * len(Y)
    axes.cla()
    for x, y, fmt in zip(X, Y, fmts):
        if len(x):
            axes.plot(x, y, fmt)
        else:
            axes.plot(y, fmt)
    set_axes(axes, xlabel, ylabel, xlim, ylim, xscale, yscale, legend)

x = np.arange(0, 3, 0.1)
plot(x, [f(x), 2 * x - 3], 'x', 'f(x)', legend=['f(x)', 'Tangent line (x=1)'])

图图：

../_images/output_calculus_7e7694_44_0.svg

偏导数

我们只讨论了仅含一个变量的函数的微分。在深度学习中，函数通常依赖于许多变量。因此，我们需要将微分的思想推广到多元函数（multivariate function）上。

$$
\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}$，$x_1, \ldots, x_{i-1}, x_{i+1}, \ldots, x_n$，并计算$y$关于$x_i$的导数。对于偏导数的表示，以下是等价的：

$$
\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})$相对于$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})$取代。

假设$\mathbf{x}$为$\nabla f(\mathbf{x})$维向量，在微分多元函数时经常使用以下规则：
- 对于所有$\mathbf{A} \in \mathbb{R}^{m \times n}$，都有$\nabla_{\mathbf{x}} \mathbf{A} \mathbf{x} = \mathbf{A}^\top$
- 对于所有$\mathbf{A} \in \mathbb{R}^{m \times n}$，都有$\nabla_{\mathbf{x}} \mathbf{x}^\top \mathbf{A} = \mathbf{A}$
- 对于所有$\mathbf{A} \in \mathbb{R}^{m \times n}$，都有$\nabla_{\mathbf{x}} \mathbf{x}^\top \mathbf{A} \mathbf{x} = (\mathbf{A} + \mathbf{A}^\top)\mathbf{x}$
- $\nabla_{\mathbf{x}} |\mathbf{x} |^2 = \nabla_{\mathbf{x}} \mathbf{x}^\top \mathbf{x} = 2\mathbf{x}$
同样，对于任何矩阵$\mathbf{X}$，都有$\nabla_{\mathbf{X}} |\mathbf{X} |_F^2 = 2\mathbf{X}$。正如我们之后将看到的，梯度对于设计深度学习中的优化算法有很大用处。

链式法则

然而，上面方法可能很难找到梯度。这是因为在深度学习中，多元函数通常是复合（composite）的，所以难以应用上述任何规则来微分这些函数。幸运的是，链式法则可以被用来微分复合函数。

$$
\frac{dy}{dx} = \frac{dy}{du} \frac{du}{dx}.
$$

现在考虑一个更一般的场景，即函数具有任意数量的变量的情况。假设可微分函数$y$，有变量$u_1, u_2, \ldots, u_m$，其中每个可微分函数$u_{i}$都有变量$x_1, x_2, \ldots, x_n$，注意，$y$是$x_1, x_2， \ldots, x_n$的函数。对于任意$i = 1, 2, \ldots, n$，链式法则给出了

$$
\frac{\partial y}{\partial x_i} = \frac{\partial y}{\partial u_1} \frac{\partial u_1}{\partial x_i} + \frac{\partial y}{\partial u_2} \frac{\partial u_2}{\partial x_i} + \cdots + \frac{\partial y}{\partial u_m} \frac{\partial u_m}{\partial x_i}
$$

绘图代码总结

%matplotlib inline
import numpy as np
from matplotlib_inline import backend_inline
from d2l import torch as d2l

#@save
def use_svg_display():
    """使用svg格式在Jupyter中显示绘图"""
    backend_inline.set_matplotlib_formats('svg')

#@save
def set_figsize(figsize=(3.5, 2.5)):
    """设置matplotlib的图表大小"""
    use_svg_display()
    d2l.plt.rcParams['figure.figsize'] = figsize

#@save
def set_axes(axes, xlabel, ylabel, xlim, ylim, xscale, yscale, legend):
    """设置matplotlib的轴"""
    axes.set_xlabel(xlabel)
    axes.set_ylabel(ylabel)
    axes.set_xscale(xscale)
    axes.set_yscale(yscale)
    axes.set_xlim(xlim)
    axes.set_ylim(ylim)
    if legend:
        axes.legend(legend)
    axes.grid()

#@save
def plot(X, Y=None, xlabel=None, ylabel=None, legend=None, xlim=None,
         ylim=None, xscale='linear', yscale='linear',
         fmts=('-', 'm--', 'g-.', 'r:'), figsize=(3.5, 2.5), axes=None):
    """绘制数据点"""
    if legend is None:
        legend = []

    set_figsize(figsize)
    axes = axes if axes else d2l.plt.gca()

    # 如果X有一个轴，输出True
    def has_one_axis(X):
        return (hasattr(X, "ndim") and X.ndim == 1 or isinstance(X, list)
                and not hasattr(X[0], "__len__"))

    if has_one_axis(X):
        X = [X]
    if Y is None:
        X, Y = [[]] * len(X), X
    elif has_one_axis(Y):
        Y = [Y]
    if len(X) != len(Y):
        X = X * len(Y)
    axes.cla()
    for x, y, fmt in zip(X, Y, fmts):
        if len(x):
            axes.plot(x, y, fmt)
        else:
            axes.plot(y, fmt)
    set_axes(axes, xlabel, ylabel, xlim, ylim, xscale, yscale, legend)
    
# 实际绘图
x = np.arange(0, 3, 0.1)
def f(x):
    return 3 * x ** 2 - 4 * x
plot(x, [f(x), 2 * x - 3], 'x', 'f(x)', legend=['f(x)', 'Tangent line (x=1)'])

x = np.arange(0.1, 3, 0.1)
def g(x):
    return x ** 3 - 1 / x
plot(x, [g(x), 4 * x - 4], 'x', 'g(x)', legend=['g(x)', 'Tangent line (x=1)'])

x = np.arange(0.1, 3, 0.1)
plot(x, [f(x), g(x), 2 * x - 3, 4 * x - 4], 'x', 'y', legend=['f(x)', 'g(x)', 'Tangent line (x=1)', 'Tangent line (x=4)'])

第一个参数是变量x，两个参数是要绘制的y的list，y是关于x的函数，第三个和第四个参数参数是横纵坐标的名字，第五个参数legend和第二个参数对应，绘制不同的颜色的函数所对应的标签。

自动微分

求导是几乎所有深度学习优化算法的关键步骤。虽然求导的计算很简单，只需要一些基本的微积分。但对于复杂的模型，手工进行更新是一件很痛苦的事情（而且经常容易出错）。

深度学习框架通过自动计算导数，即自动微分（automatic differentiation）来加快求导。实际中，根据设计好的模型，系统会构建一个计算图（computational graph），来跟踪计算是哪些数据通过哪些操作组合起来产生输出。自动微分使系统能够随后反向传播梯度。这里，反向传播（backpropagate）意味着跟踪整个计算图，填充关于每个参数的偏导数。

一个简单的例子

作为一个演示例子，假设我们想对函数$y=2\mathbf{x}^{\top}\mathbf{x}$关于列向量$x$求导。

1
2
3

import torch

x = torch.arange(4.0)

在我们计算$y$关于$x$的梯度之前，需要一个地方来存储梯度。重要的是，我们不会在每次对一个参数求导时都分配新的内存。因为我们经常会成千上万次地更新相同的参数，每次都分配新的内存可能很快就会将内存耗尽。注意，一个标量函数关于向量$x$的梯度是向量，并且与$x$具有相同的形状。

1 2	`x.requires_grad_(True) # 等价于x=torch.arange(4.0,requires_grad=True) x.grad # 默认值是None`

现在计算$y$。

1	`y = 2 * torch.dot(x, x)`

x是一个长度为4的向量，计算x和x的点积，得到了我们赋值给y的标量输出。接下来，通过调用反向传播函数来自动计算y关于x每个分量的梯度，并打印这些梯度。

y.backward()
x.grad

# result
# y = 4x
tensor([ 0.,  4.,  8., 12.])

x.grad == 4 * x

# result
x.grad == 4 * x

给我个人的感觉是，x.grad是一个属性，这个属性是由x的函数，通过.backward()方法进行赋值的。因此在赋新的值之前，老的值应该清掉

现在计算x的另一个函数。

# 在默认情况下，PyTorch会累积梯度，我们需要清除之前的值
x.grad.zero_()
y = x.sum()
y.backward()
x.grad

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

非标量变量的反向传播

当y不是标量时，向量y关于向量x的导数的最自然解释是一个矩阵。对于高阶和高维的y和x，求导的结果可以是一个高阶张量。虽然这些更奇特的对象确实出现在高级机器学习中（包括深度学习中），但当调用向量的反向计算时，我们通常会试图计算一批训练样本中每个组成部分的损失函数的导数。这里，我们的目的不是计算微分矩阵，而是单独计算批量中每个样本的偏导数之和。

# 对非标量调用backward需要传入一个gradient参数，该参数指定微分函数关于self的梯度。
# 本例只想求偏导数的和，所以传递一个1的梯度是合适的
x.grad.zero_()
y = x * x
# 等价于y.backward(torch.ones(len(x)))
y.sum().backward()
x.grad

# result
tensor([0., 2., 4., 6.])

分离计算

有时，我们希望将某些计算移动到记录的计算图之外。例如，假设y是作为x的函数计算的，而z则是作为y和x的函数计算的。想象一下，我们想计算z关于x的梯度，但由于某种原因，希望将y视为一个常数，并且只考虑到x在y被计算后发挥的作用。
这里可以分离y来返回一个新变量u，该变量与y具有相同的值，但丢弃计算图中如何计算y的任何信息。换句话说，梯度不会向后流经u到x。因此，下面的反向传播函数计算z=u*x关于x的偏导数，同时将u作为常数处理，而不是z=x*x*x关于x的偏导数。

x.grad.zero_()
y = x * x
u = y.detach()
z = u * x

z.sum().backward()
# z' = (u * x)' = u -> 存储在x.grad中
x.grad == u

# result
tensor([True, True, True, True])

由于记录了y的计算结果，我们可以随后在y上调用反向传播，得到y=x*x关于的x的导数，即2*x。

x.grad.zero_()
# y' = (x ^ 2)' = 2 * x -> 存储在x.grad中 
y.sum().backward()
x.grad == 2 * x

Python控制流的梯度计算

使用自动微分的一个好处是：即使构建函数的计算图需要通过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
  
# calc grad
a = torch.randn(size=(), requires_grad=True)
d = f(a)
d.backward()

我们现在可以分析上面定义的f函数。请注意，它在其输入a中是分段线性的。换言之，对于任何a，存在某个常量标量k，使得f(a)=k*a，其中k的值取决于输入a，因此可以用d/a验证梯度是否正确。

a.grad == d / a

# result
tensor(True)

说白了，对于分段等特殊复杂情况，也能很好的适应昂！！！

深度学习框架可以自动计算导数：我们首先将梯度附加到想要对其计算偏导数的变量上，然后记录目标值的计算，执行它的反向传播函数，并访问得到的梯度。

概率

基本概率论

dependencies import:

%matplotlib inline
import torch
from torch.distributions import multinomial
from d2l import torch as d2l

我们把从概率分布中抽取样本的过程称为抽样（sampling）。笼统来说，可以把分布（distribution）看作对事件的概率分配，稍后我们将给出的更正式定义。将概率分配给一些离散选择的分布称为多项分布（multinomial distribution）。为了抽取一个样本，即掷骰子，我们只需传入一个概率向量。输出是另一个相同长度的向量：它在索引$i$处的值是采样结果中$i$出现的次数。

fair_probs = torch.ones([6]) / 6
multinomial.Multinomial(1, fair_probs).sample()

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

在估计一个骰子的公平性时，我们希望从同一分布中生成多个样本。 如果用Python的for循环来完成这个任务，速度会慢得惊人。因此我们使用深度学习框架的函数同时抽取多个样本，得到我们想要的任意形状的独立样本数组。

multinomial.Multinomial(10, fair_probs).sample()

# result
tensor([2., 4., 1., 0., 1., 2.])

现在我们知道如何对骰子进行采样，我们可以模拟1000次投掷。然后，我们可以统计1000次投掷后，每个数字被投中了多少次。具体来说，我们计算相对频率，以作为真实概率的估计。

# 将结果存储为32位浮点数以进行除法
counts = multinomial.Multinomial(1000, fair_probs).sample()
counts / 1000  # 相对频率作为估计值

# result
tensor([0.1620, 0.1600, 0.1740, 0.1680, 0.1570, 0.1790])

说白了就是给深度学习框架一个概率数组，它可以帮你按照这个概率进行采样。 -> 当采样足够多 -> 大数定律

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

counts = multinomial.Multinomial(10, fair_probs).sample((500,))
cum_counts = counts.cumsum(dim=0)
estimates = cum_counts / cum_counts.sum(dim=1, keepdims=True)

d2l.set_figsize((6, 4.5))
for i in range(6):
    d2l.plt.plot(estimates[:, i].numpy(),
                 label=("P(die=" + str(i + 1) + ")"))
d2l.plt.axhline(y=0.167, color='black', linestyle='dashed')
d2l.plt.gca().set_xlabel('Groups of experiments')
d2l.plt.gca().set_ylabel('Estimated probability')
d2l.plt.legend();

Result:

../_images/output_probability_245b7d_66_0.svg

每条实线对应于骰子的6个值中的一个，并给出骰子在每组实验后出现值的估计概率。当我们通过更多的实验获得更多的数据时，这6条实体曲线向真实概率收敛。

概率论公理

所有样本可能出现的集合被称为样本空间（sample space）或结果空间（outcome space），其中每个元素都是结果（outcome）。事件（event）是一组给定样本空间的随机结果。
概率（probability）可以被认为是将集合映射到真实值的函数。在给定的样本空间$\mathcal{S}$中，事件$\mathcal{A}$的概率，表示为$P(\mathcal{A})$，满足以下属性：
- 对于任意事件$\mathcal{A}$，其概率从不会是负数，即$P(\mathcal{A})$≥0；
- 整个样本空间的概率为1，即$P(\mathcal{S}) = 1$；
- 对于互斥（mutually exclusive）事件（对于所有$i \neq j$都有$\mathcal{A}_i \cap \mathcal{A}_j = \emptyset$）的任意一个可数序列$\mathcal{A}_1, \mathcal{A}2, \ldots$，序列中任意一个事件发生的概率等于它们各自发生的概率之和，即$P(\bigcup{i=1}^{\infty} \mathcal{A}i) = \sum{i=1}^{\infty} P(\mathcal{A}_i)$。

以上也是概率论的公理，由科尔莫戈罗夫于1933年提出。有了这个公理系统，我们可以避免任何关于随机性的哲学争论；相反，我们可以用数学语言严格地推理。不可能发生事件的概率是0。

随机变量

随机变量几乎可以是任何数量，并且它可以在随机实验的一组可能性中取一个值。
离散（discrete）随机变量（如骰子的每一面）和连续（continuous）随机变量（如人的体重和身高）之间存在微妙的区别。在这些情况下，我们将这个看到某个数值的可能性量化为密度（density）。

处理多个随机变量

很多时候，我们会考虑多个随机变量。我们需要估计这些概率以及概率之间的关系。

联合概率

第一个被称为联合概率（joint probability）$P(A=a,B=b)$。给定任意值$a$和$b$，联合概率可以回答：$A=a$和$B=b$同时满足的概率是多少？
对于任何$a$和$b$的取值，$P(A = a, B=b) \leq P(A=a)$。这点是确定的，因为要同时发生$A=a$和$B=b$，$A=a$就必须发生，$B=b$也必须发生（反之亦然）。因此，$A=a$和$B=b$同时发生的可能性不大于$A=a$或是$B=b$单独发生的可能性。

条件概率

联合概率的不等式带给我们一个有趣的比率： $0 \leq \frac{P(A=a, B=b)}{P(A=a)} \leq 1$。我们称这个比率为条件概率（conditional probability），并用$P(B=b \mid A=a)$表示它：它是$B=b$的概率，前提是$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)}.
$$

请注意，这里我们使用紧凑的表示法：其中$P(A, B)$是一个联合分布（joint distribution）， $P(A \mid B)$是一个条件分布（conditional distribution）。这种分布可以在给定值$A = a, B=b$上进行求值。

边际化

了能进行事件概率求和，我们需要求和法则（sum rule），即$B$的概率相当于计算$A$的所有可能选择，并将所有选择的联合概率聚合在一起：

$$
P(B) = \sum_{A} P(A, B),
$$

这也称为边际化（marginalization）。边际化结果的概率或分布称为边际概率（marginal probability）或边际分布（marginal distribution）。

独立性

另一个有用属性是依赖（dependence）与独立（independence）。如果两个随机变量$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$。

期望和方差

为了概括概率分布的关键特征，我们需要一些测量方法。

一个随机变量$X$的期望（expectation，或平均值（average））表示为

$$
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.
$$

方差的平方根被称为标准差（standard deviation）。随机变量函数的方差衡量的是：当从该随机变量分布中采样不同值$x$时，函数值偏离该函数的期望的程度：

$$
\mathrm{Var}[f(x)] = E\left[\left(f(x) - E[f(x)]\right)^2\right].
$$

查阅文档

查找模块中的所有函数和类

1
2
3

import torch

print(dir(torch.distributions))

通常可以忽略以“__”（双下划线）开始和结束的函数，它们是Python中的特殊对象，或以单个“_”（单下划线）开始的函数，它们通常是内部函数。根据剩余的函数名或属性名，我们可能会猜测这个模块提供了各种生成随机数的方法，包括从均匀分布（uniform）、正态分布（normal）和多项分布（multinomial）中采样。

查找特定函数和类的用法

Help

1	`help(torch.ones)`

有关如何使用给定函数或类的更具体说明，可以调用help函数。例如，我们来查看张量ones函数的用法。我们可以使用?指令在另一个浏览器窗口中显示文档。例如，list?指令将创建与help(list)指令几乎相同的内容，并在新的浏览器窗口中显示它。此外，如果我们使用两个问号，如list??，将显示实现该函数的Python代码。

我们可以看到ones函数创建一个具有指定形状的新张量，并将所有元素值设置为1。下面来运行一个快速测试来确认这一解释：

1	`torch.ones(4)`

在Jupyter记事本中，我们可以使用?指令在另一个浏览器窗口中显示文档。例如，list?指令将创建与help(list)指令几乎相同的内容，并在新的浏览器窗口中显示它。此外，如果我们使用两个问号，如list??，将显示实现该函数的Python代码。

References

官网：https://zh-v2.d2l.ai/chapter_preliminaries/index.html
Markov chain: https://en.wikipedia.org/wiki/Markov_chain

#研0自学

D2L-2-Preliminaries

https://alexanderliu-creator.github.io/2023/07/23/d2l-2-preliminaries/

作者

Alexander Liu

发布于

2023年7月23日

许可协议

D2L-3-Linear Neural Networks 上一篇

D2L-1-Introduction 下一篇