当前位置：首页 > news >正文

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

news 来源：原创 2025/6/1 11:32:09

2.5. 自动微分

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

自动微分（automatic differentiation）：

将计算过程分解为一系列基本数学运算，然后计算每个步骤的导数；
并将它们组合得到最终导数结果。

计算图（computational graph）：

是一种数据结构，用于表示数学表达式的计算过程。
神经网络中，计算图 = 节点（神经元/参数/数学运算等）+ 边（数据流动方向）。

反向传播（backpropagate）：

是自动微分在神经网络中的具体实现方式之一。
它从输出端（损失函数）开始，向输入端（模型参数）反向计算梯度。

自动微分的过程：

当设计好一个模型时，深度学习框架会构建一个计算图。
这个计算图记录了从输入数据到输出结果的所有操作步骤。
随后通过反向传播，自动计算出目标函数关于模型参数的导数。

1）自动微分的示例

为了更好理解自动微分，下面对函数 $y=2\mathbf{x}^{\top}\mathbf{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 = xxx`	`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 * 2while b.norm() < 1000:b = b * 2if b.sum() > 0:c = belse:c = 100 * breturn c# 计算梯度
a = torch.randn(size=(), requires_grad=True)
d = f(a)
d.backward()