本文将介绍Pytorch的以下内容

自动微分函数

优化

模型保存和载入

好了，我们首先介绍一下关于微分的内容。

在训练神经网络时，最常用的算法是反向传播算法。在该算法中，根据损失函数相对于给定参数的梯度来调整参数（模型权重）。

为了计算这些梯度，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属性。

我们应用于张量来构造计算图的函数实际上是函数类的对象。该对象知道如何在正向方向上计算函数，以及如何在反向传播步骤中计算其导数。对反向传播函数的引用存储在张量的grad_fn属性中。您可以在文档中找到Function的更多信息。

print(f"Gradient function for z = {
     z.grad_fn}")
print(f"Gradient function for loss = {
     loss.grad_fn}")

输出为：

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

计算梯度

为了优化神经网络中参数的权重，我们需要计算损失函数对参数的导数，即我们需要∂loss/∂w和∂loss/∂B。为了计算这些导数，我们调用loss.backward()，然后从w.g grad和b.g grad中检索值：

loss.backward()
print(w.grad)
print(b.grad)

输出为：

tensor([[0.0549, 0.1796, 0.0399],
        [0.0549, 0.1796, 0.0399],
        [0.0549, 0.1796, 0.0399],
        [0.0549, 0.1796, 0.0399],
        [0.0549, 0.1796, 0.0399]])
tensor([0.0549, 0.1796, 0.0399])

禁用梯度跟踪

默认情况下，所有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

你可能想要禁用渐变跟踪的原因如下：

• 将神经网络中的一些参数标记为冻结参数。

• 当你只做正向传递时，为了加快计算速度，因为在不跟踪梯度的张量上的计算会更有效率。

更多关于计算图的知识

从概念上讲，autograd在由Function对象组成的有向无环图（DAG）中保存数据（张量）和所有执行的操作（以及产生的新张量）的记录。在DAG中，叶是输入张量，根是输出张量。通过从根到叶的跟踪图，您可以使用链式法则自动计算梯度。

在向前传递中，autograd同时做两件事：

• 运行请求的操作来计算结果张量

• 在DAG中维持操作的梯度函数。

当在DAG根上调用.backward（）时，向后传递开始。autograd:

• 计算每个。grad_fn的梯度，

• 在各自张量的.grad属性中累积它们

• 利用链式法则，一直传播到叶张量。

[!TIP]

PyTorch中的dag是动态的，需要注意的重要一点是图形是从头开始重新创建的；在每次.backward（）调用之后，autograd开始填充一个新图。这正是允许您在模型中使用控制流语句的原因；如果需要，您可以在每次迭代中更改形状、大小和操作

张量梯度和雅可比积

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

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}")

输出为：

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.,