【动手学深度学习】2.5. 自动微分

---

目录

• • [2.5. 自动微分](#2.5. 自动微分)
  • • 1）自动微分的示例
    • 2）非标量变量的反向传播
    • 3）分离计算
    • 4）控制流的梯度计算
    • 5）小结

---

.

2.5. 自动微分

求导是几乎所有深度学习优化算法的关键步骤。 手动求导是很繁琐且容易出错的。深度学习框架通过自动计算导数，即自动微分来加快求导。

自动微分 （automatic differentiation）：

• 将计算过程分解为一系列基本数学运算，然后计算每个步骤的导数；

• 并将它们组合得到最终导数结果。

计算图 （computational graph）：

• 是一种数据结构，用于表示数学表达式的计算过程。

• 神经网络中，计算图 = 节点（神经元/参数/数学运算等）+ 边（数据流动方向）。

反向传播 （backpropagate）：

• 是自动微分在神经网络中的具体实现方式之一。

• 它从输出端（损失函数）开始，向输入端（模型参数）反向计算梯度。

自动微分的过程：

• 当设计好一个模型时，深度学习框架会构建一个计算图。

• 这个计算图记录了从输入数据到输出结果的所有操作步骤。

• 随后通过反向传播，自动计算出目标函数关于模型参数的导数。

.

1）自动微分的示例

为了更好理解自动微分，下面对函数 y = 2 x ⊤ x y=2\mathbf{x}^{\top}\mathbf{x} y=2x⊤x（x的点积的2倍）关于列向量x求导。

# 1.定义向量x
import torch
x = torch.arange(4.0, requires_grad=True)
print(x)  # tensor([0., 1., 2., 3.], requires_grad=True)

# 2.定义函数 y（x的点积的2倍）
y = 2 * torch.dot(x, x)
print(y)  # tensor(28., grad_fn=<MulBackward0>)

# 3.对y进行反向传播，查看y关于x的梯度
y.backward()
print(x.grad)  # tensor([ 0.,  4.,  8., 12.])

# 4.手动验证梯度：验证y=2⋅x^T⋅x的梯度为4x
print(x.grad == 4 * x)  # tensor([True, True, True, True])

在默认情况下，PyTorch会累积梯度，我们需要清除之前的值，使用：

x.grad.zero_()

.

2）非标量变量的反向传播

当函数的输出 y 不是标量时，向量y关于向量x的导数 的最自然解释是一个矩阵 。 对于高阶和高维的y和x ，求导的结果可以是一个高阶张量。

当调用向量的反向计算时 ，我们通常会试图计算 一批训练样本中每个组成部分的损失函数的导数。 这里，我们的目的不是计算微分矩阵，而是单独计算批量中每个样本的偏导数之和。

示例 ：计算张量x的平方（y = x * x）关于x的梯度（即导数）。

x = torch.arange(4.0, requires_grad=True)
print(x)  # tensor([0., 1., 2., 3.], requires_grad=True)
y = x * x
print(y)  # tensor([0., 1., 4., 9.], grad_fn=<MulBackward0>)


# 输出y是一个向量。可以先进行求和操作，再计算梯度：
y.sum().backward()
print(x.grad)  # tensor([0., 2., 4., 6.])

对"y.sum().backward()"的说明：

假设 x 是一个一维张量 [a, b, c]，那么：

• y = x * x 是 [a², b², c²]

• y.sum() 是 a² + b² + c²

当我们对 y.sum() 调用 backward() 时，PyTorch 会计算损失（即 y.sum()）关于 x 的梯度：

• 损失对 x 的梯度是 [2a, 2b, 2c]

这个结果会被存储在 x.grad 中。

.

3）分离计算

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

比如，在某个计算步骤中，我们不希望"追踪"变量的变化 ------我们想把它当作一个常量来使用，而不是用来计算梯度的变量。这时，就可以用"分离计算图"的方法，把计算图中的一部分"切断"，让它不参与反向传播。

分离计算 ：通过.detach()创建与y值相同但无计算历史 的新变量u，使反向传播时将u视为常数。

	操作	计算图	梯度结果
不分离y求导	z = x*x*x	x → y → z	dz/dx = 3x²
分离y后求导	u = y.detach()	x → y & (u) → z	dz/dx = u = x²

代码：

# 1.不分离y求导：z = x*x*x → dz/dx = 3x²
x = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)  
y = x * x           # print(y) --> # tensor([1., 4., 9.], grad_fn=<MulBackward0>)
z = y * x           # print(z) --> # tensor([1., 8., 27.], grad_fn=<MulBackward0>) 
z.sum().backward()
print(x.grad)       # tensor([ 3., 12., 27.]) --> x梯度为3x²


# 2.分离y后求导：z = u*x（u 为常数）→ dz/dx = u = x²
import torch
x = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)  
y = x * x           # print(y) --> # tensor([1., 4., 9.], grad_fn=<MulBackward0>)
u = y.detach()      # 切断y的计算历史
z = u * x           # print(z) --> # tensor([1., 8., 27.], grad_fn=<MulBackward0>) 
z.sum().backward()
print(x.grad)       # tensor([1., 4., 9.])  --> x梯度为x²
print(x.grad == u)  # tensor([True, True, True]) --> x梯度为u==x²，而非3x²

.

4）控制流的梯度计算

自动微分的强大之处在于，即使我们的函数包含复杂的控制流结构（如条件判断或循环），我们依然能够计算出梯度。

在下面的代码中，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 = torch.randn(size=(), requires_grad=True)
d = f(a)
d.backward()

分析上面定义的f函数:

• 它在其输入a中是分段线性的。

• 换言之，对于任何a，存在某个常量标量k，使得f(a)=k*a，其中k的值取决于输入a；

• 因此可以用d/a验证梯度是否正确。

print(a.grad == d / a)  # tensor(True)

.

5）小结

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

.

---

声明：资源可能存在第三方来源，若有侵权请联系删除！