torch.autograd
自动微分与torch.autograd
在训练神经网络时,最常用的算法是 反向传播。在该算法中,根据损失函数相对于给定参数的梯度来调整参数(模型权重) 。
为了计算这些梯度,PyTorch 有一个名为torch.autograd
的内置微分引擎。它支持任何计算图的梯度自动计算。
考虑最简单的一层神经网络,具有输入x
、参数w
和b
,以及一些损失函数。它可以通过以下方式在 PyTorch 中定义:
import torch
x = torch.ones(5) # input tensor
y = torch.zeros(3) # expected output
w = torch.randn(5, 3, requires_grad=True)
b = torch.randn(3, requires_grad=True)
z = torch.matmul(x, w)+b
loss = torch.nn.functional.binary_cross_entropy_with_logits(z, y)
该代码定义了以下计算图:
在这个网络中,w
和b
是我们需要优化的参数。因此,我们需要能够计算损失函数相对于这些变量的梯度。为了做到这一点,我们设置了这些张量的requires_grad
属性。
您可以在创建张量时设置requires_grad
的值,也可以稍后使用x.requires_grad_(True)
方法设置。
实际上,我们应用于张量来构造计算图的函数是类Function
的对象。该对象知道如何计算前向函数,以及如何在向后传播步骤中计算其导数。对反向传播函数的引用存储在张量的grad_fn
属性中。您可以在Function
文档中找到更多信息。
print(f"Gradient function for z = {z.grad_fn}")
print(f"Gradient function for loss = {loss.grad_fn}")
Out:
Gradient function for z = <AddBackward0 object at 0x7f083264cd60>
Gradient function for loss = <BinaryCrossEntropyWithLogitsBackward0 object at 0x7f083264eec0>
为了优化神经网络中参数的权重,我们需要计算损失函数关于参数的导数。即,在x
和y
为固定值的情况下,计算
?
l
o
s
s
?
w
\frac {\partial loss}{\partial w}
?w?loss?和
?
l
o
s
s
?
b
\frac {\partial loss}{\partial b}
?b?loss?。为了计算这些导数,我们调用 loss.backward()
,然后从w.grad
和b.grad
检索相应的值:
loss.backward()
print(w.grad)
print(b.grad)
Out:
tensor([[0.3313, 0.0626, 0.2530],
[0.3313, 0.0626, 0.2530],
[0.3313, 0.0626, 0.2530],
[0.3313, 0.0626, 0.2530],
[0.3313, 0.0626, 0.2530]])
tensor([0.3313, 0.0626, 0.2530])
grad
属性,其requires_grad
属性设置为True
。对于我们图中的其他节点,梯度将不可用。backward
执行一次梯度计算。如果我们需要在同一个图上进行多次backward
调用,我们需要将retain_graph=True
传递给backward
调用。默认情况下,所有张量都会设置requires_grad=True
,来跟踪其计算历史并支持梯度计算。然而,在某些情况下,我们不需要这样做。例如,当我们训练完模型,并且只想将其应用于某些输入数据时,即我们只想通过网络进行*前向计算。*我们可以通过使用torch.no_grad()
块包围我们的计算代码,来停止跟踪计算:
z = torch.matmul(x, w)+b
print(z.requires_grad)
with torch.no_grad():
z = torch.matmul(x, w)+b
print(z.requires_grad)
Out:
True
False
获得相同结果的另一种方法是在张量上使用detach()
方法:
z = torch.matmul(x, w)+b
z_det = z.detach()
print(z_det.requires_grad)
Out:
False
您可能想要禁用梯度跟踪的原因有:
从概念上讲,在由Function 对象组成的有向无环图 (DAG) 中,autograd 保存数据(张量)和所有执行的操作(以及生成的新张量)的记录 。在这个 DAG 中,叶子是输入张量,根是输出张量。通过从根到叶追踪该图,您可以使用链式法则自动计算梯度。
在前向传递中,autograd 同时执行两件事:
当在 DAG 根上调用.backward()
时,后向传递开始。autograd
然后:
.grad_fn
的梯度,.grad
属性中,将累积它们在 PyTorch 中,DAG 是动态的
需要注意的重要一点是,图是从头开始重新创建的。每次调用 .backward()
后,autograd 都会开始填充新图。这正是允许您在模型中使用控制流语句的原因。如果需要,您可以在每次迭代时更改形状、大小和操作。
在许多情况下,我们有一个标量损失函数,并且需要计算某些参数的梯度。然而,在某些情况下,输出函数是任意张量。在这种情况下,PyTorch 允许您计算所谓的雅可比积,而不是实际的梯度。
对于向量函数 y ? = f ( x ? ) \vec y = f(\vec x) y?=f(x) ,当 x ? = < x 1 , … , x n > \vec x = <x_1,\dots,x_n> x=<x1?,…,xn?> 和 y ? = < y 1 , … , y m > \vec y = <y_1,\dots,y_m> y?=<y1?,…,ym?> 时,相对于 x ? \vec x x 的 y ? \vec y y? 的梯度,是由雅可比矩阵计算的:
J = ( ? y 1 ? x 1 ? ? y 1 ? x n ? ? ? ? y m ? x 1 ? ? y m ? x n ) J= \begin{pmatrix} \frac {\partial y_1}{ \partial x_1} & \cdots & \frac {\partial y_1}{ \partial x_n} \\ \vdots & \ddots & \vdots \\ \frac {\partial y_m}{ \partial x_1} & \cdots & \frac {\partial y_m}{ \partial x_n} \end{pmatrix} J= ??x1??y1????x1??ym????????xn??y1????xn??ym??? ?
对于一个给定的输入向量
v
=
(
v
1
…
v
m
)
v = (v_1 \dots v_m)
v=(v1?…vm?) ,PyTorch 允许您计算雅可比积
v
T
?
J
v^T \cdot J
vT?J,而不是计算雅可比矩阵本身。这是通过把
v
v
v 作为参数,调用backward
,来实现的。
v
v
v 的大小应与原始张量的大小相同,我们要计算其乘积:
inp = torch.eye(4, 5, requires_grad=True)
out = (inp+1).pow(2).t()
out.backward(torch.ones_like(out), retain_graph=True)
print(f"First call\n{inp.grad}")
out.backward(torch.ones_like(out), retain_graph=True)
print(f"\nSecond call\n{inp.grad}")
inp.grad.zero_()
out.backward(torch.ones_like(out), retain_graph=True)
print(f"\nCall after zeroing gradients\n{inp.grad}")
Out:
First call
tensor([[4., 2., 2., 2., 2.],
[2., 4., 2., 2., 2.],
[2., 2., 4., 2., 2.],
[2., 2., 2., 4., 2.]])
Second call
tensor([[8., 4., 4., 4., 4.],
[4., 8., 4., 4., 4.],
[4., 4., 8., 4., 4.],
[4., 4., 4., 8., 4.]])
Call after zeroing gradients
tensor([[4., 2., 2., 2., 2.],
[2., 4., 2., 2., 2.],
[2., 2., 4., 2., 2.],
[2., 2., 2., 4., 2.]])
请注意,当我们使用相同的参数第二次调用backward
时,梯度的值是不同的。发生这种情况是因为在进行backward
传播时,PyTorch会累积梯度。即,将计算出的梯度值添加到计算图所有叶节点的grad
属性中。如果你想计算正确的梯度,你需要先将grad
属性归零 。在实际训练中,优化器可以帮助我们做到这一点。
以前,我们调用不带参数的backward()
函数。这本质上相当于调用 backward(torch.tensor(1.0))
,这是在标量值函数(例如,神经网络训练期间的损失)的情况下,计算梯度的有用方法。
Automatic Differentiation with torch.autograd — PyTorch Tutorials 2.2.0+cu121 documentation
Automatic Differentiation with torch.autograd — PyTorch Tutorials 2.2.0+cu121 documentation
Get_started_with_PyTorch/MarkDown/5.Autograd.md at main · storm-ice/Get_started_with_PyTorch
Get_started_with_PyTorch/MarkDown/5.Autograd.md at main · storm-ice/Get_started_with_PyTorch