【动手学深度学习v2】学习笔记02：线性代数、矩阵计算、自动求导

前文回顾：数据操作、数据预处理

一、线性代数实现

1.1 标量和向量

在pytorch中，我们使用一个元素的张量来表示标量。
我们可以将向量视为标量值组成的列表。

x = torch.tensor([3.0])				# 标量
y = torch.tensor([2.0, 1.0, 4.0])	# 向量

1.2 矩阵和多维张量

我们可以通过制定两个分量m和n来创建一个形状为$m\times n$的矩阵。并且，通过T运算，我们可以对矩阵进行转置。

A = torch.arange(20).reshape(4, 5)	# 矩阵
AT = A.T	# 转置

对称矩阵B，等于其转置：$B=B^{\tau }$

就像向量是标量的推广，矩阵是向量的推广一样，我们可以构建具有更多轴的数据结构。

X = torch.arange(24).reshape(2, 3, 4)	# 三维张量

上例中X的内容为：
$$\left[\begin{array}{c}\left[\begin{array}{cccc}0& 1& 2& 3\\ 4& 5& 6& 7\\ 8& 9& 10& 11\end{array}\right]\left[\begin{array}{cccc}12& 13& 14& 15\\ 16& 17& 18& 19\\ 20& 21& 22& 23\end{array}\right]\end{array}\right]$$

1.3 张量的运算

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

1.3.1 基础运算

加减乘除：下例中，A、B和C三个矩阵的形状相同。

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

哈达玛积：两个矩阵的按元素乘法称为哈达玛积（数学符号$⨀$）

A = torch.arange(20, dtype=torch.float32).reshape(4, 5)
B = A.clone()
C = A * B	# 哈达玛积

上例和视为如下运算：
$$\left[\begin{array}{cccc}0.& 1.& 2.& 3.\\ 4.& 5.& 6.& 7.\\ 8.& 9.& 10.& 11.\\ 12.& 13.& 14.& 15.\\ 16.& 17.& 18.& 19.\end{array}\right]⨀\left[\begin{array}{cccc}0.& 1.& 2.& 3.\\ 4.& 5.& 6.& 7.\\ 8.& 9.& 10.& 11.\\ 12.& 13.& 14.& 15.\\ 16.& 17.& 18.& 19.\end{array}\right]=\left[\begin{array}{cccc}0.& 1.& 4.& 9.\\ 16.& 25.& 36.& 49.\\ 64.& 81.& 100.& 121.\\ 144.& 169.& 196.& 225.\\ 256.& 289.& 324.& 361.\end{array}\right]$$
与标量的运算

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

1.3.2 按特定轴运算

运算	方法	保持维度不变
按特定轴求和	sum(axis=n)	sum(axis=n, keepdims=True)
按特定轴求均值	mean(axis=n)	mean(axis=n, keepdims=True)
按特定轴累加	cumsum(axis=n)	cumsum(axis=n, keepdims=True)

按特定轴求和：我们可以使用sum()方法，计算其所有元素的和。也可以通过指定axis参数来对张量的部分维度求和。

A = torch.arange(40, dtype=torch.float32).reshape(2, 5, 4)
A_sum_axis0 = A.sum(axis=0)

上例中，我们创建了一个形状为$2\times 5\times 4$的三维张量A，并通过sum(axis=0)方法对其第一维度进行求和。
$$\left[\begin{array}{c}\left[\begin{array}{cccc}0.& 1.& 2.& 3.\\ 4.& 5.& 6.& 7.\\ 8.& 9.& 10.& 11.\\ 12.& 13.& 14.& 15.\\ 16.& 17.& 18.& 19.\end{array}\right]\left[\begin{array}{cccc}20.& 21.& 22.& 23.\\ 24.& 25.& 26.& 27.\\ 28.& 29.& 30.& 31.\\ 32.& 33.& 34.& 35.\\ 36.& 37.& 38.& 39.\end{array}\right]\end{array}\right]⟶\left[\begin{array}{cccc}20.& 22.& 24.& 26.\\ 28.& 30.& 32.& 34.\\ 36.& 38.& 40.& 42.\\ 44.& 46.& 48.& 50.\\ 52.& 54.& 56.& 58.\end{array}\right]$$
同理，我们也可以按照其他的维度进行按维度求和。
相似地，我们可以按特定轴求均值。

A = torch.arange(40, dtype=torch.float32).reshape(2, 5, 4)
A_ave_axis0 = A.mean(axis=0)

按特定轴累加求和：下例是按第1维度累加求和

A.cumsum(axis=1)

$$\left[\begin{array}{c}\left[\begin{array}{cccc}0.& 1.& 2.& 3.\\ 4.& 5.& 6.& 7.\\ 8.& 9.& 10.& 11.\\ 12.& 13.& 14.& 15.\\ 16.& 17.& 18.& 19.\end{array}\right]\left[\begin{array}{cccc}20.& 21.& 22.& 23.\\ 24.& 25.& 26.& 27.\\ 28.& 29.& 30.& 31.\\ 32.& 33.& 34.& 35.\\ 36.& 37.& 38.& 39.\end{array}\right]\end{array}\right]⟶\left[\begin{array}{c}\left[\begin{array}{cccc}0.& 1.& 2.& 3.\\ 4.& 6.& 8.& 10.\\ 12.& 15.& 18.& 21.\\ 24.& 28.& 32.& 36.\\ 40.& 45.& 50.& 55.\end{array}\right]\left[\begin{array}{cccc}20.& 21.& 22.& 23.\\ 44.& 46.& 48.& 50.\\ 72.& 75.& 78.& 81.\\ 104.& 108.& 112.& 116.\\ 140.& 145.& 150.& 155.\end{array}\right]\end{array}\right]$$
保持维度不变：我们可以通过指定keepdims参数，在计算总和或均值时保持轴数（维度）不变。这样做的好处是，我们可以保持原张量的维度，便于利用广播机制——因为广播机制只能作用于维度相同的两个张量。

A = torch.arange(40, dtype=torch.float32).reshape(2, 5, 4)
sum_A = A.sum(axis=1, keepdims=True)

上例对矩阵A的第1维度进行按轴求和，并保持轴数不变，这样做实际上是将第1维度的大小设置为1。
$$\left[\begin{array}{c}\left[\begin{array}{cccc}0.& 1.& 2.& 3.\\ 4.& 5.& 6.& 7.\\ 8.& 9.& 10.& 11.\\ 12.& 13.& 14.& 15.\\ 16.& 17.& 18.& 19.\end{array}\right]\left[\begin{array}{cccc}20.& 21.& 22.& 23.\\ 24.& 25.& 26.& 27.\\ 28.& 29.& 30.& 31.\\ 32.& 33.& 34.& 35.\\ 36.& 37.& 38.& 39.\end{array}\right]\end{array}\right]⟶\left[\begin{array}{c}\left[\begin{array}{c}\left[\begin{array}{cccc}40.& 45.& 50.& 55.\end{array}\right]\left[\begin{array}{cccc}140.& 145.& 150.& 155.\end{array}\right]\end{array}\right]\end{array}\right]$$

1.3.3 乘积运算

乘积	方法
向量向量点积	dot(x, y)
矩阵向量积	mv(A, x)
矩阵矩阵乘法	mm(A, B)

点积：相同位置的按元素乘积的和。

X = torch.arange(4, dtype=torch.float32)
Y = torch.ones(4, dtype=torch.float32)
Z = torch.dot(X, Y)

上例可视为如下运算：
$$\left[\begin{array}{cccc}0.& 1.& 2.& 3.\end{array}\right]\cdot \left[\begin{array}{cccc}1.& 1.& 1.& 1.\end{array}\right]=0\times 1+1\times 1+2\times 1+3\times 1=6$$
此外，我们还可以通过执行按元素乘法，然后进行求和来表示两个向量的点积：torch.sum(X * Y)。

矩阵向量积$A\vec{x}$：是一个长度为m的列向量，其$i^{th}$元素是点积${\vec{a}}_i^{\tau }x$

A = torch.arange(20, dtype=torch.float32).reshape(5, 4)
X = torch.arange(4, dtype=torch.float32)
torch.mv(A, X)

上例可视为如下运算：
$$\left[\begin{array}{cccc}0.& 1.& 2.& 3.\\ 4.& 5.& 6.& 7.\\ 8.& 9.& 10.& 11.\\ 12.& 13.& 14.& 15.\\ 16.& 17.& 18.& 19.\end{array}\right]\left[\begin{array}{c}0.\\ 1.\\ 2.\\ 3.\end{array}\right]=\left[\begin{array}{c}14.\\ 38.\\ 62.\\ 86.\\ 110.\end{array}\right]$$
矩阵矩阵乘法：

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

上例可看成如下运算：
$$\left[\begin{array}{cccc}0.& 1.& 2.& 3.\\ 4.& 5.& 6.& 7.\\ 8.& 9.& 10.& 11.\\ 12.& 13.& 14.& 15.\\ 16.& 17.& 18.& 19.\end{array}\right]\left[\begin{array}{ccc}1& 1& 1\\ 1& 1& 1\\ 1& 1& 1\\ 1& 1& 1\end{array}\right]=\left[\begin{array}{ccc}6.& 6.& 6.\\ 22.& 22.& 22.\\ 38.& 38.& 38.\\ 54.& 54.& 54.\\ 70.& 70.& 70.\end{array}\right]$$

1.3.4 范数

范数	方法
$L_1$范数	abs(向量).sum()
$L_2$范数	norm(向量)
F范数	norm(矩阵)

$L_1$范数：它表示为向量元素的绝对值之和：
$$||x|{|}_1=\sum _{i=1}^n|x_i|$$

u = torch.tensor([3.0, -4.0])
v = torch.abs(u).sum()

$L_2$范数：是向量元素平方和的平方根：
$$||x|{|}_2=\sqrt{\sum _{i=1}^n{x}_i^2}$$

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

F范数：是矩阵元素的平方和的平方根：
$$||x|{|}_F=\sqrt{\sum _{i=1}^m\sum _{j=1}^n{x}_{ij}^2}$$

vf = torch.norm(torch.ones((4, 9)))

二、矩阵计算

2.1 标量导数

$y$	$a$（常数）	$x^n$	$e^x$	$\ln x$	$\sin x$
$\frac{dy}{dx}$	$0$	$n{x}^{n-1}$	$e^x$	$\frac{1}{x}$	$\cos x$

$y$	$u+v$	$uv$	$y=f(u),u=g(x)$
$\frac{dy}{dx}$	$\frac{du}{dx}+\frac{dv}{dx}$	$\frac{du}{dx}v+\frac{dv}{dx}u$	$\frac{dy}{du}\frac{du}{dx}$

2.2 向量导数

类别	$x$	$\vec{x}$
$y$	$\frac{\partial y}{\partial x}$（标量）	$\frac{\partial y}{\partial \vec{x}}$（向量）
$\vec{y}$	$\frac{\partial \vec{y}}{\partial x}$（向量）	$\frac{\partial \vec{y}}{\partial \vec{x}}$（矩阵）

2.2.1 标量-向量求导

这种情况实际上是标量对向量中的每一个元素分别求偏导，再将结果组合成一个行向量。
$$\vec{x}=\left[\begin{array}{c}{x}_1\\ x_2\\ ⋮\\ x_n\end{array}\right]\frac{\partial y}{\partial \vec{x}}=\left[\begin{array}{cccc}\frac{\partial y}{\partial x_1}& \frac{\partial y}{\partial x_2}& \cdots & \frac{\partial y}{\partial x_n}\end{array}\right]$$
常见的导数如下所示：

$y$	$a$（常数）	$au$	$sum(x)$	$\mid \mid x\mid {\mid }^2$
$\frac{\partial y}{\partial \vec{x}}$	${\vec{0}}^T$	$a\frac{\partial u}{\partial \vec{x}}$	${\vec{1}}^T$	$2{\vec{x}}^T$

$y$	$u+v$	$uv$	$⟨\vec{u},\vec{v}⟩$
$\frac{\partial u}{\partial \vec{x}}$	$\frac{\partial u}{\partial \vec{x}}+\frac{\partial v}{\partial \vec{x}}$	$\frac{\partial u}{\partial \vec{x}}v+\frac{\partial v}{\partial \vec{x}}u$	${\vec{u}}^T\frac{\partial \vec{v}}{\partial \vec{x}}+{\vec{v}}^T\frac{\partial \vec{u}}{\partial \vec{x}}$

2.2.2 向量-标量求导

这种情况相当于向量的每一个元素分别求导。
$$\vec{y}=\left[\begin{array}{c}{y}_1\\ y_2\\ ⋮\\ y_m\end{array}\right]\frac{\partial \vec{y}}{\partial x}=\left[\begin{array}{c}\frac{\partial y_1}{\partial x}\\ \frac{\partial y_2}{\partial x}\\ ⋮\\ \frac{\partial y_m}{\partial x}\end{array}\right]$$
我们发现$\frac{\partial y}{\partial \vec{x}}$是行向量，而$\frac{\partial \vec{y}}{\partial x}$是列向量。这个被称之为分子布局符号，反过来的版本叫分母布局符号。

2.2.3 向量-向量求导

这种情况相当于分别进行前述两种求导。
$$x=\left[\begin{array}{c}{x}_1\\ x_2\\ ⋮\\ x_n\end{array}\right]y=\left[\begin{array}{c}{y}_1\\ y_2\\ ⋮\\ y_m\end{array}\right]\frac{\partial \vec{y}}{\partial \vec{x}}=\left[\begin{array}{c}\frac{\partial y_1}{\partial \vec{x}}\\ \frac{\partial y_2}{\partial \vec{x}}\\ ⋮\\ \frac{\partial y_m}{\partial \vec{x}}\end{array}\right]=\left[\begin{array}{cccc}\frac{\partial y_1}{\partial x_1}& \frac{\partial y_1}{\partial x_2}& \cdots & \frac{\partial y_1}{\partial x_n}\\ \frac{\partial y_2}{\partial x_1}& \frac{\partial y_2}{\partial x_2}& \cdots & \frac{\partial y_2}{\partial x_n}\\ ⋮& ⋮& & ⋮\\ \frac{\partial y_m}{\partial x_1}& \frac{\partial y_m}{\partial x_2}& \cdots & \frac{\partial y_m}{\partial x_n}\end{array}\right]$$
常见的导数如下所示：

$\vec{y}$	$\vec{a}$（常数）	$\vec{x}$	$A\vec{x}$	${\vec{x}}^{T}A$
$\frac{\partial \vec{y}}{\partial \vec{x}}$	$\vec{0}$	$I$（单位矩阵）	$A$	$A^T$

$\vec{y}$	$a\vec{u}$	$A\vec{u}$	$\vec{u}+\vec{v}$
$\frac{\partial \vec{y}}{\partial \vec{x}}$	$a\frac{\partial \vec{u}}{\partial \vec{x}}$	$A\frac{\partial \vec{u}}{\partial \vec{x}}$	$\frac{\partial \vec{u}}{\partial \vec{x}}+\frac{\partial \vec{v}}{\partial \vec{x}}$

除本文中提到的求导，张量间的求导还可以进一步往矩阵扩展，甚至向更高维度扩展。

三、自动求导

3.1 链式法则

我们可以通过求导的链式法则，实现对复杂函数导数的求解。

例：
假设 $X\in R^{m\times n}$，$\vec{w}\in R^n$，$\vec{y}\in R^m$，$z=||X\vec{w}-\vec{y}|{|}^2$
计算 $\frac{\partial z}{\partial \vec{w}}$

---

分解 $\vec{a}=X\vec{w}$，$\vec{b}=\vec{a}-\vec{y}$，$z=||\vec{b}|{|}^2$
求导
$$\frac{\partial z}{\partial \vec{w}}=\frac{\partial z}{\partial \vec{b}}\frac{\partial \vec{b}}{\partial \vec{a}}\frac{\partial \vec{a}}{\partial \vec{w}}=\frac{\partial ||\vec{b}|{|}^2}{\partial \vec{b}}\frac{\partial \vec{a}-\vec{y}}{\partial \vec{a}}\frac{\partial X\vec{w}}{\partial \vec{w}}=2{\vec{b}}^T\times I\times X=2(X\vec{w}-\vec{y}{)}^{T}X$$

3.2 自动求导

自动求导：计算一个函数在指定值上的导数。
它有别于

• 符号求导（显式计算）
  $$\begin{gathered} In[1]:=D[4x^3+x^2+3,x] \\ Out[1]:=2x+12x^2 \end{gathered}$$
• 数学求导
  $$\frac{\partial f(x)}{\partial x}=\underset{h\to 0}{\lim }\frac{f(x+h)-f(x)}{h}$$

3.3 计算图

• 将代码分解成操作子
• 将计算表示成无环图
• 对于一个计算图，我们可以显式构造（Tensorflow/Theano/MXNet）也可以隐式构造（PyTorch/MXNet）。
  

3.4 两种模式

3.4.1 正向累积与反向累积

• 链式法则：$\frac{\partial y}{\partial x}=\frac{\partial y}{\partial u_n}\frac{\partial u_n}{\partial u_{n-1}}\cdots \frac{\partial u_2}{\partial u_1}\frac{\partial u_1}{\partial x}$
• 正向累积：$\frac{\partial y}{\partial x}=\frac{\partial y}{\partial u_n}(\frac{\partial u_n}{\partial u_{n-1}}(\cdots (\frac{\partial u_2}{\partial u_1}\frac{\partial u_1}{\partial x})))$
• 反向累积（反向传递）：$\frac{\partial y}{\partial x}=(((\frac{\partial y}{\partial u_n}\frac{\partial u_n}{\partial u_{n-1}})\cdots )\frac{\partial u_2}{\partial u_1})\frac{\partial u_1}{\partial x}$

3.4.2 反向累积步骤

首先，构造计算图。
前向：执行图，存储中间结果。
反向：从相反方向执行图，并去除不需要的枝。

3.4.3 复杂度

• 正向累积：
  • 计算复杂度：O(n)，用来计算一个变量的梯度。
  • 内存复杂度：O(1)
• 反向累积：
  • 计算复杂度：O(n)，n是操作子个数。
  • 内存复杂度：O(n)，因为需要存储正向的所有中间结果。

四、自动求导实现

4.1 常用函数

函数	功能
x.requires_grade_(True)	表示需要存储梯度
y.backward()	自动计算梯度
y.sum().backward()	先求和再自动计算梯度
x.grad	查看梯度
x.grad.zero_()	梯度清零
y.detach()	将与x相关的函数y转变为与x无关的常数

4.2 简易流程

在我们计算y关于x的梯度之前，我们需要一个地方来存储梯度。

x = torch.arange(4.0)
x.requires_grad_(True)	# 表示需要存储梯度

我们也可以通过requires_grad参数来表示需要存储梯度。上下两段代码是等价的，但是要主要上面的代码中requires_grad_()方法最后还有一个_。

x = torch.arange(4.0, requires_grad=True)

现在让我们计算y。

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

通过调用反向传播函数来自动计算y关于x每个分量的梯度。

y.backward()	# 自动求梯度
print(x.grad)	# 查看梯度

接下来，我们来计算另一个函数中y关于x每个分量的梯度。
在默认情况下，PyTorch会累积梯度，我们需要清除之前的值。
我们这里使用的是zero_()方法，_的意识是“把xx写进xx”，因此x.grad.zero_()的含义为：把零写进x的梯度。

x.grad.zero_()  # _表示将xx写进xx，即将zero写进x.grad
y = x.sum()		# 另一个函数
y.backward()
print(x.grad)

4.3 进一步

深度学习中，我们的目的不是计算微分矩阵，而是批量中每个样本单独计算的偏导数之和。

x.grad.zero_()
y = x * x

# 等价于y.backward(torch.ones(len(x)))
y.sum().backward()	# 先求和再自动求梯度
print(x.grad)

我们还可以将一些计算移动到记录的计算图之外。
其中，我们用detach()方法将与x相关的函数转变为与x无关的常数，这个技巧可以用来固定网络中的参数。

x.grad.zero_()
y = x * x
u = y.detach()		# 将u转变为与x无关的常数
z = u * x
z.sum().backward()	# 先求和，再求梯度
print(x.grad, x.grad==u)

即使构建函数的计算图需要通过Python控制流（例如，条件、循环或者任意函数调用），我们仍然可以计算得到的变量的梯度。

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

# size = () 意为：a为标量
a = torch.randn(size=(), requires_grad=True)
d = f(a)
d.backward()
print(a.grad, a.grad==d/a)

下一篇：【动手学深度学习v2】学习笔记03：线性回归、基础优化算法、线性回归实现