PyTorch深度学习60分钟入门与实战（二）Autograd：自动求导

太过爱你忘了你带给我的痛 2022-03-28 14:54 260阅读 0赞

> 原文：[github link][]，最新版会首先更新在github上  
> 有误的地方拜托大家指出~

# Autograd：自动求导 #

PyTorch中，所有神经网络的核心是`autograd`包。先简单介绍一下这个包，然后训练我们的第一个的神经网络。

`autograd`包为张量上的所有操作提供了自动求导机制。它是一个在运行时定义（define-by-run）的框架，这意味着反向传播是根据代码如何运行来决定的，并且每次迭代可以是不同的.

让我们用一些简单的例子来看看吧。

## 张量 ##

`torch.Tensor`是这个包的核心类。如果设置它的属性 `.requires_grad`为`True`，那么它将会追踪对于该张量的所有操作。当完成计算后可以通过调用`.backward()`，来自动计算所有的梯度。这个张量的所有梯度将会自动累加到`.grad`属性.

要阻止一个张量被跟踪历史，可以调用`.detach()`方法将其与计算历史分离，并阻止它未来的计算记录被跟踪。

为了防止跟踪历史记录（和使用内存），可以将代码块包装在`with torch.no_grad():`中。在评估模型时特别有用，因为模型可能具有`requires_grad = True`的可训练的参数，但是我们不需要在此过程中对他们进行梯度计算。

还有一个类对于autograd的实现非常重要：`Function`。

`Tensor`和`Function`互相连接生成了一个非循环图，它编码了完整的计算历史。每个张量都有一个`.grad_fn`属性，它引用了一个创建了这个`Tensor`的`Function`（除非这个张量是用户手动创建的，即这个张量的`grad_fn`是`None`）。

如果需要计算导数，可以在`Tensor`上调用`.backward()`。如果`Tensor`是一个标量（即它包含一个元素的数据），则不需要为`backward()`指定任何参数，但是如果它有更多的元素，则需要指定一个`gradient`参数，它是形状匹配的张量。

import torch

创建一个张量并设置`requires_grad=True`用来追踪其计算历史

x = torch.ones(2, 2, requires_grad=True)
    print(x)

输出：

tensor([[1., 1.],
            [1., 1.]], requires_grad=True)

对这个张量做一次运算：

y = x + 2
    print(y)

输出：

tensor([[3., 3.],
            [3., 3.]], grad_fn=<AddBackward0>)

`y`是计算的结果，所以它有`grad_fn`属性。

print(y.grad_fn)

输出：

对y进行更多操作

z = y * y * 3
    out = z.mean()
    
    print(z, out)

输出：

tensor([[27., 27.],
            [27., 27.]], grad_fn=<MulBackward0>) tensor(27., grad_fn=<MeanBackward0>)

`.requires_grad_(...)` 原地改变了现有张量的 `requires_grad` 标志。如果没有指定的话，默认输入的这个标志是`False`。

a = torch.randn(2, 2)
    a = ((a * 3) / (a - 1))
    print(a.requires_grad)
    a.requires_grad_(True)
    print(a.requires_grad)
    b = (a * a).sum()
    print(b.grad_fn)

输出：

False
    True
    <SumBackward0 object at 0x7f1b24845f98>

## 梯度 ##

因为`out`是一个标量。所以让我们直接进行反向传播，`out.backward()`和`out.backward(torch.tensor(1.))`等价

out.backward()

输出导数`d(out)/dx`

print(x.grad)

输出：

tensor([[4.5000, 4.5000],
            [4.5000, 4.5000]])

得到都是`4.5`的矩阵。调用`out`张量  “ o ” “o” “o”。

得到

o = 1 4 ∑ i z i o = \\frac\{1\}\{4\}\\sum\_i z\_i o=41i∑zi

z i = 3 ( x i + 2 ) 2 z\_i = 3(x\_i+2)^2 zi=3(xi\+2)2

和

z i ∣ x i = 1 = 27 z\_i\\bigr\\rvert\_\{x\_i=1\} = 27 zi∣∣xi=1=27

因此,

∂ o ∂ x i = 3 2 ( x i + 2 ) \\frac\{\\partial o\}\{\\partial x\_i\} = \\frac\{3\}\{2\}(x\_i+2) ∂xi∂o=23(xi\+2)

所以，

∂ o ∂ x i ∣ x i = 1 = 9 2 = 4.5 \\frac\{\\partial o\}\{\\partial x\_i\}\\bigr\\rvert\_\{x\_i=1\} = \\frac\{9\}\{2\} = 4.5 ∂xi∂o∣∣xi=1=29=4.5

数学上，若有向量值函数  y ⃗ = f ( x ⃗ ) \\vec\{y\}=f(\\vec\{x\}) y=f(x)，那么  y ⃗ \\vec\{y\} y 相对于  x ⃗ \\vec\{x\} x 的梯度是一个雅可比矩阵：

J = ( ∂ y 1 ∂ x 1 ⋯ ∂ y m ∂ x 1 ⋮ ⋱ ⋮ ∂ y 1 ∂ x n ⋯ ∂ y m ∂ x n ) J=\\left(\\begin\{array\}\{ccc\} \\frac\{\\partial y\_\{1\}\}\{\\partial x\_\{1\}\} & \\cdots & \\frac\{\\partial y\_\{m\}\}\{\\partial x\_\{1\}\}\\\\ \\vdots & \\ddots & \\vdots\\\\ \\frac\{\\partial y\_\{1\}\}\{\\partial x\_\{n\}\} & \\cdots & \\frac\{\\partial y\_\{m\}\}\{\\partial x\_\{n\}\} \\end\{array\}\\right) J=⎝⎜⎛∂x1∂y1⋮∂xn∂y1⋯⋱⋯∂x1∂ym⋮∂xn∂ym⎠⎟⎞

通常来说，`torch.autograd` 是计算雅可比向量积的一个“引擎”。也就是说，给定任意向量  v = ( v 1 v 2 ⋯ v m ) T v=\\left(\\begin\{array\}\{cccc\} v\_\{1\} & v\_\{2\} & \\cdots & v\_\{m\}\\end\{array\}\\right)^\{T\} v=(v1v2⋯vm)T，计算乘积  J ⋅ v J\\cdot v J⋅v。如果  v v v 恰好是一个标量函数  l = g ( y ⃗ ) l=g\\left(\\vec\{y\}\\right) l=g(y) 的导数，即  v = ( ∂ l ∂ y 1 ⋯ ∂ l ∂ y m ) T v=\\left(\\begin\{array\}\{ccc\}\\frac\{\\partial l\}\{\\partial y\_\{1\}\} & \\cdots & \\frac\{\\partial l\}\{\\partial y\_\{m\}\}\\end\{array\}\\right)^\{T\} v=(∂y1∂l⋯∂ym∂l)T，那么根据链式法则，雅可比向量积应该是  l l l 对  x ⃗ \\vec\{x\} x 的导数：

J ⋅ v = ( ∂ y 1 ∂ x 1 ⋯ ∂ y m ∂ x 1 ⋮ ⋱ ⋮ ∂ y 1 ∂ x n ⋯ ∂ y m ∂ x n ) ( ∂ l ∂ y 1 ⋮ ∂ l ∂ y m ) = ( ∂ l ∂ x 1 ⋮ ∂ l ∂ x n ) J\\cdot v=\\left(\\begin\{array\}\{ccc\} \\frac\{\\partial y\_\{1\}\}\{\\partial x\_\{1\}\} & \\cdots & \\frac\{\\partial y\_\{m\}\}\{\\partial x\_\{1\}\}\\\\ \\vdots & \\ddots & \\vdots\\\\ \\frac\{\\partial y\_\{1\}\}\{\\partial x\_\{n\}\} & \\cdots & \\frac\{\\partial y\_\{m\}\}\{\\partial x\_\{n\}\} \\end\{array\}\\right)\\left(\\begin\{array\}\{c\} \\frac\{\\partial l\}\{\\partial y\_\{1\}\}\\\\ \\vdots\\\\ \\frac\{\\partial l\}\{\\partial y\_\{m\}\} \\end\{array\}\\right)=\\left(\\begin\{array\}\{c\} \\frac\{\\partial l\}\{\\partial x\_\{1\}\}\\\\ \\vdots\\\\ \\frac\{\\partial l\}\{\\partial x\_\{n\}\} \\end\{array\}\\right) J⋅v=⎝⎜⎛∂x1∂y1⋮∂xn∂y1⋯⋱⋯∂x1∂ym⋮∂xn∂ym⎠⎟⎞⎝⎜⎛∂y1∂l⋮∂ym∂l⎠⎟⎞=⎝⎜⎛∂x1∂l⋮∂xn∂l⎠⎟⎞

雅可比向量积的这一特性使得将外部梯度输入到具有非标量输出的模型中变得非常方便。

现在我们来看一个雅可比向量积的例子:

x = torch.randn(3, requires_grad=True)
    
    y = x * 2
    while y.data.norm() < 1000:
        y = y * 2
    
    print(y)

输出：

tensor([-278.6740,  935.4016,  439.6572], grad_fn=<MulBackward0>)

在这种情况下，`y`不再是标量。`torch.autograd`不能直接计算完整的雅可比矩阵，但是如果我们只想要雅可比向量积，只需将这个向量作为参数传给`backward`：

v = torch.tensor([0.1, 1.0, 0.0001], dtype=torch.float)
    y.backward(v)
    
    print(x.grad)

输出：

tensor([4.0960e+02, 4.0960e+03, 4.0960e-01])

也可以通过将代码块包装在 `with torch.no_grad():` 中，来阻止autograd跟踪设置了 `.requires_grad=True` 的张量的历史记录。

print(x.requires_grad)
    print((x ** 2).requires_grad)
    
    with torch.no_grad():
        print((x ** 2).requires_grad)

输出：