PyTorch Tutorials 2 AUTOGRAD: AUTOMATIC DIFFERENTIATION

%matplotlib inline

Autograd: 自动求导机制

PyTorch 中全部神经网络的核心是 autograd 包。
咱们先简单介绍一下这个包，而后训练第一个简单的神经网络。

autograd包为张量上的全部操做提供了自动求导。
它是一个在运行时定义的框架，这意味着反向传播是根据你的代码来肯定如何运行，而且每次迭代能够是不一样的。

示例

张量（Tensor）

torch.Tensor是这个包的核心类。若是设置
.requires_grad 为 True，那么将会追踪全部对于该张量的操做。
当完成计算后经过调用 .backward()，自动计算全部的梯度，
这个张量的全部梯度将会自动积累到 .grad 属性。

要阻止张量跟踪历史记录，能够调用.detach()方法将其与计算历史记录分离，并禁止跟踪它未来的计算记录。

为了防止跟踪历史记录（和使用内存），能够将代码块包装在with torch.no_grad()：中。
在评估模型时特别有用，由于模型可能具备requires_grad = True的可训练参数，可是咱们不须要梯度计算。

在自动梯度计算中还有另一个重要的类Function.

Tensor and Function are interconnected and build up an acyclic
graph, that encodes a complete history of computation. Each tensor has
a .grad_fn attribute that references a Function that has created
the Tensor (except for Tensors created by the user - their
grad_fn is None).

Tensor 和 Function互相链接并生成一个非循环图，它表示和存储了完整的计算历史。
每一个张量都有一个.grad_fn属性，这个属性引用了一个建立了Tensor的Function（除非这个张量是用户手动建立的，即，这个张量的
grad_fn 是 None）。

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

译者注：在其余的文章中你可能会看到说将Tensor包裹到Variable中提供自动梯度计算，Variable 这个在0.41版中已经被标注为过时了，如今能够直接使用Tensor，官方文档在这里：
(https://pytorch.org/docs/stable/autograd.html#variable-deprecated)

具体的后面会有详细说明

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=<AddBackward>)

结果y已经被计算出来了，因此，grad_fn已经被自动生成了。

print(y.grad_fn)

<AddBackward object at 0x00000232535FD860>

对y进行一个操做

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

print(z, out)

tensor([[27., 27.],
        [27., 27.]], grad_fn=<MulBackward>) tensor(27., grad_fn=<MeanBackward1>)

.requires_grad_( ... ) 能够改变现有张量的 requires_grad属性。
若是没有指定的话，默认输入的flag是 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 0x000002325360B438>

梯度

反向传播
由于 out是一个纯量（scalar），out.backward() 等于out.backward(torch.tensor(1))。

out.backward()

print gradients d(out)/dx

print(x.grad)

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

获得矩阵 4.5.调用 out
Tensor “\(o\)”.

获得 \(o = \frac{1}{4}\sum_i z_i\),
\(z_i = 3(x_i+2)^2\) and \(z_i\bigr\rvert_{x_i=1} = 27\).

所以,
\(\frac{\partial o}{\partial x_i} = \frac{3}{2}(x_i+2)\), hence
\(\frac{\partial o}{\partial x_i}\bigr\rvert_{x_i=1} = \frac{9}{2} = 4.5\).

可使用 autograd 作更多的操做

x = torch.randn(3, requires_grad=True)

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

print(y)

tensor([-920.6895, -115.7301, -867.6995], grad_fn=<MulBackward>)

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

print(x.grad)

tensor([ 51.2000, 512.0000,   0.0512])

若是.requires_grad=True可是你又不但愿进行autograd的计算，
那么能够将变量包裹在 with torch.no_grad()中:

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

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

True
True
False

稍后阅读:

autograd 和 Function 的官方文档 https://pytorch.org/docs/autograd