0
点赞
收藏
分享

微信扫一扫

【pytorch】(四)torch.autograd自动微分



文章目录

  • 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)

张量、函数与计算图

以上代码定义了以下计算图:

【pytorch】(四)torch.autograd自动微分_神经网络

在这个网络中,​​w​​和​​b​​是需要优化的参数。因此,我们需要能够计算损失函数相对于这些变量的梯度。为了做到这一点,我们设置了这些张量的​​requires_grad​​属性为​​True​​。

​:

你可以在创建张量时设置​​requires_grad​​的值,或创建之后使用​​x.requires_grad_(True)​​方法设定。

我们构造计算图的函数实际上是​​Function​​​类的对象。该对象知道如何计算正向函数,以及如何在反向传播步骤中计算其导数。对反向传播函数的引用存储在张量的​​grad_fn​​属性中。

print('Gradient function for z =', z.grad_fn)
print('Gradient function for loss =', loss.grad_fn)

输出:

Gradient function for z = <AddBackward0 object at 0x7efc61a05240>
Gradient function for loss = <BinaryCrossEntropyWithLogitsBackward0 object at 0x7efc61a05240>

计算梯度

为了优化神经网络中参数的权重,我们需要计算损失函数对参数的导数,即我们需要对​​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)

输出:

tensor([[0.3178, 0.3126, 0.0038],
[0.3178, 0.3126, 0.0038],
[0.3178, 0.3126, 0.0038],
[0.3178, 0.3126, 0.0038],
[0.3178, 0.3126, 0.0038]])
tensor([0.3178, 0.3126, 0.0038])

​:

我们只能获得计算图中叶节点(​​requires_grad=True​​)的​​grad​​属性。对于图中的其他节点,梯度将不可用。

出于性能方面的原因,我们只能在给定的图形上使用一次​​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)

输出:

True
False

另一种方法是对张量使用​​detach()​​方法:

z = torch.matmul(x, w)+b
z_det = z.detach()
print(z_det.requires_grad)

输出:

False

下面是禁用梯度跟踪的几个原因:

  • 将神经网络中的某些参数标记为冻结参数。这常用于预训练和微调(fine tuning)网络。
  • 当你只做前向传播时,这可以加快计算速度,因为在不跟踪梯度的张量上计算会更高效。

更多关于计算图的信息

从概念上讲,自动梯度在由函数对象组成的有向无环图(DAG)中记录数据(张量)和所有执行的操作(以及生成的新张量)。在这个DAG中,叶是输入张量,根是输出张量。通过从根到叶跟踪此图形,可以使用链式法则自动计算梯度。

在前向传播中,​​autograd​​同时做两件事:

  • 运行请求的操作以计算结果张量
  • 在DAG中梯度函数的操作。

对DAG根调用​​.backward()​​​时反向传播开始,然后​​autograd​​:

  • 从​​.grad_fn​​计算每个对象的梯度
  • 将它们累加到各自的张量​​.grad​​属性
  • 使用链式法则,传播到叶张量。

​:

在PyTorch中,DAG是动态的。需要注意的一点是,每次调用​​.backward()​​,图形都会从头开始重新创建的。这正是允许你在模型中使用控制流语句的原因;如果需要,你可以在每次迭代中更改形状、大小和操作。

可选阅读:张量梯度和雅可比积

在很多情况下,我们有一个标量损失函数,我们需要计算一些参数的梯度。然而,在某些情况下,输出函数是任意张量。在这种情况下,PyTorch允许您计算所谓的雅可比积,而不是实际的梯度。

对于一个向量函数 y ⃗ = f ( x ⃗ ) \vec{y}=f(\vec{x}) y ​=f(x ),其中 x ⃗ = ⟨ x 1 , … , x n ⟩ 和 y ⃗ = ⟨ y 1 , … , y m ⟩ \vec{x}=\left\langle x_{1}, \ldots, x_{n}\right\rangle 和 \vec{y}=\left\langle y_{1}, \ldots, y_{m}\right\rangle x =⟨x1​,…,xn​⟩和y ​=⟨y1​,…,ym​⟩, y ⃗ \vec{y} y ​关于 x ⃗ \vec{x} x 的梯度由雅可比矩阵给出

J = ( ∂ y 1 ∂ x 1 ⋯ ∂ y 1 ∂ x n ⋮ ⋱ ⋮ ∂ y m ∂ x 1 ⋯ ∂ y m ∂ x n ) J=\left(\begin{array}{ccc} \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{array}\right) J=⎝⎜⎛​∂x1∂y1​⋮∂x1​∂ym​​​⋯⋱⋯​∂xn​∂y1​⋮∂xn​∂ym​​​⎠⎟⎞​

PyTorch允许你计算雅可比积 v T ⋅ J v^T\cdot J vT⋅J,而不是计算雅可比矩阵本身。对于给定的输入向量 v = ( v 1 … v m ) v=(v_1\dots v_m) v=(v1​…vm​),这是通过使用 v v v作为参数调​​backward​​来实现的。 v v v的大小应与我们要计算乘积的原始张量的大小相同:

inp = torch.range(0, 5, requires_grad=True)
out = (inp + 1).pow(2)
out.backward(torch.ones_like(inp), retain_graph=True) # v=torch.ones_like(inp)
print("First call\n", inp.grad)
out.backward(torch.ones_like(inp), retain_graph=True)
print("\nSecond call\n", inp.grad)
inp.grad.zero_()
out.backward(torch.ones_like(inp), retain_graph=True)
print("\nCall after zeroing gradients\n", inp.grad)
First call
tensor([ 2., 4., 6., 8., 10., 12.])

Second call
tensor([ 4., 8., 12., 16., 20., 24.])

Call after zeroing gradients
tensor([ 2., 4., 6., 8., 10., 12.])
inp = torch.eye(5, requires_grad=True)
out = (inp+1).pow(2)
out.backward(torch.ones_like(inp), retain_graph=True) #v=torch.ones_like(inp)
print("First call\n", inp.grad)
out.backward(torch.ones_like(inp), retain_graph=True)
print("\nSecond call\n", inp.grad)
inp.grad.zero_()
out.backward(torch.ones_like(inp), retain_graph=True)
print("\nCall after zeroing gradients\n", inp.grad)

输出:

First call
tensor([[4., 2., 2., 2., 2.],
[2., 4., 2., 2., 2.],
[2., 2., 4., 2., 2.],
[2., 2., 2., 4., 2.],
[2., 2., 2., 2., 4.]])

Second call
tensor([[8., 4., 4., 4., 4.],
[4., 8., 4., 4., 4.],
[4., 4., 8., 4., 4.],
[4., 4., 4., 8., 4.],
[4., 4., 4., 4., 8.]])

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.],
[2., 2., 2., 2., 4.]])

请注意,当我们使用相同的参数第二次调用​​backward​​​时,梯度的值是不同的。这是因为在进行​​backward​​​时,Pytorch会累积梯度,即计算的梯度值会添加到计算图的所有叶节点的​​grad​​​属性中。如果要计算正确的梯度,则需要先将​​grad​​特性归零。在实际训练中,优化器可以帮助我们做到这一点。

注意:

之前我们调用的是​​backward()​​​函数,没有参数。实际上,这相当于调用​​backward(torch.tensor(1.0))​​,这是一种计算标量值函数梯度的有用方法,例如在神经网络训练期间的损失。

[1] https://pytorch.org/tutorials/beginner/basics/autogradqs_tutorial.html#



举报

相关推荐

0 条评论