【pytorch】（四）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属性为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求偏导：$\frac{\partial loss}{\partial w}$，$\frac{\partial loss}{\partial b}$​。要计算这些导数，我们调用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允许您计算所谓的雅可比积，而不是实际的梯度。

对于一个向量函数$\vec{y}=f(\vec{x})$，其中$\vec{x}=⟨x_1,\dots ,x_n⟩和\vec{y}=⟨y_1,\dots ,y_m⟩$，$\vec{y}$关于$\vec{x}$的梯度由雅可比矩阵给出
$$J=\left(\begin{array}{ccc}\frac{\partial y1}{\partial x1}& \cdots & \frac{\partial y1}{\partial x_n}\\ ⋮& \ddots & ⋮\\ \frac{\partial y_m}{\partial x_1}& \cdots & \frac{\partial y_m}{\partial x_n}\end{array}\right)$$

PyTorch允许你计算雅可比积$v^T\cdot J$，而不是计算雅可比矩阵本身：对于给定的输入向量$v=（v_1\dots v_m）$，可以通过使用$v$作为参数调用backward来实现的。其中$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#