[PyTorch入门之60分钟入门闪击战]之自动推倒

AUTOGRAD: AUTOMATIC DIFFERENTIATION（自动分化）

来源于这里。

autograd包是PyTorch中所有神经网络的核心。首先我们先简单地了解下它，然后我们将训练我们的第一个神经网络。

autograd包为Tensors上的所有操作提供自动分化。它是一个逐步执行的框架，这意味着你的反向传播(backprop)函数是由你的代码运行方式定义的，而且每个迭代器可以是不同的。接下来通过一些例子用更简单的术语来了解autograd。

Tensor

torch.tensor是autograd包的核心。如果你将它的属性.requires_grad设置为True，那么它将开始追踪其上的所有操作。当完成你的计算之后，你可以调用.backward()是所有的梯度自动计算完成。这个张量的梯度会被累积到.grad属性中。

要停止张量追踪记录，你可以使用.detach()将它熊计算记录中分离出来，并防止将来的计算被追踪。

为了阻止追踪记录（和使用内存），你可以使用with torch.no_grad()打包代码块。这在评估模型的时候非常有用，因为当模型的requires_grad=True时，可能具有可训练的参数，但我们并不需要这些梯度。

另外还有一个对自动推倒非常重要的类 --- Function。

Tensor和Function相互关联、构建出一个无环图，它编码了一个完整的计算历史记录。每个tensor都有一个.grad_fn属性，该属性引用自一个创建张量（用户创建的张量除外，它们的.grad_fn是空）的函数。

如果你想计算导数，你可以调用张量上的backward()。如果张量是一个标量（比如它只有一个数据元素），那么你不需要给backward()传递任何特殊的参数；但是如果它拥有多个元素，你需要指定一个特殊的梯度参数，它是一个与形状匹配的张量。

创建一个张量，并设置requires_grad=True来追踪计算。

import torch
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)

输出：

<AddBackward0 object at 0x121669470>

对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 0x121726588>

Gradients(梯度)

现在进行反向传播。因为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填充的2x2的矩阵。我们将out张量命名为\(\omicron\)。我们知道\(\omicron = \frac{1}{4}\sum_iz_i,z_i = 3(x_i+2)^2\)，而且\(z_i|_{x_i=1} = 27\)，那么，\(\frac{\sigma_\omicron}{\sigma_{x_i}} = \frac{3}{2}(x_i + 2)\)，因此\(\frac{\sigma_\omicron}{\sigma_{x_i}}|_{x_i=1} = \frac{9}{2} = 4.5\)。

在数学上，如果你有一个向量值函数\(\vec{y} = f(\vec{x})\)，那么遵循\(\vec{x}\)的\(\vec{y}\)的梯度是一个Jacobian矩阵：

\[ J = \begin{pmatrix}
\frac{\sigma_{y_1}}{\sigma_{x_1}} \quad \cdots \quad \frac{\sigma_{y_1}}{\sigma_{x_n}} \\
\vdots \quad \ddots \quad \vdots \\
\frac{\sigma_{y_m}}{\sigma_{x_1}} \quad \cdots \quad \frac{\sigma_{y_m}}{\sigma_{x_n}}
\end{pmatrix}\]

通常来讲，torch.autograd是一个计算vector-Jacobian结果的引擎。也就是说，给定任意的\(v = (v_1 \quad v_2 \quad \cdots \quad v_m)^T\)，计算\(v^T \cdot J\)的结果。如果\(v\)恰好是标量函数\(l = g(\vec{y})\)的梯度，那么\(v = (\frac{\sigma_l}{\sigma_{y_1}} \quad \cdots \quad \frac{\sigma_l}{\sigma_{y_n}})\)，然后根据链接规则，vector-Jacobain的结果就是遵循\(\vec{x}\)的\(l\)的梯度：

\[J^T \cdot v = \begin{pmatrix}
\frac{\sigma_{y_1}}{\sigma_{x_1}} \quad \cdots \quad \frac{\sigma_{y_m}}{\sigma_{x_1}} \\
\vdots \quad \ddots \quad \vdots \\
\frac{\sigma_{y_1}}{\sigma_{x_n}} \quad \cdots \quad \frac{\sigma_{y_m}}{\sigma_{x_n}}
\end{pmatrix} \begin{pmatrix}
\frac{\sigma_l}{\sigma_{y_1}} \\
\vdots \\
\frac{\sigma_l}{\sigma_{y_m}}
\end{pmatrix} = \begin{pmatrix}
\frac{\sigma_l}{\sigma_{x_1}} \\
\vdots \\
\frac{\sigma_l}{\sigma_{x_n}}
\end{pmatrix}\]

注意 \(v^T \cdot J\)给出了一个可以看做是从\(J^T \cdot v\)获取的列向量的行向量。

vector-Jacobain结果的特性使得在一个非标量输出的模型中反馈外部梯度非常方便。

现在我们来看一个vector-Jacobain结果的例子：

x = torch.rands(3,requires_grad=True)
y = x * 2

while y.data.norm() < 1000:
    y = y * 2

print(y)

输出：

tensor([805.7939, -90.6879, 624.5883], grad_fn=<MulBackward0>)

现在这种情况下，y不再是一个标量。torch.autograd不能直接计算完整的Jacobain矩阵，但如果我们只想要vector-Jacobain结果，那么只需将向量作为参数传递给backward即可。

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

print(x.grad)

输出：

tensor([2.5600e+01, 2.5600e+02, 2.5600e-02])

你也可以通过使用with torch.no_grad()打包代码块的方式在.requires_grad=True的张量上停止追踪历史记录的自动推倒。

print(x.requires_grad)
print((x ** 2).requires_grad)

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

输出：

True
True
False

进阶阅读

更详细的autograd和Function文档在这里。