1.2 Autograd：自动求导

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)
x

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

对张量进行操作:

y是由于操作而创建的，因此具有grad_fn。

y=x+2
y

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

y.grad_fn

<AddBackward0 at 0xdd2c2b0>

对y进行一个操作

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

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

.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 0x000000000DD0DC88>

梯度

现在我们进行反向传播。 因为out包含一个标量(scalar)，所以out.backward()等同于out.backward(torch.tensor（1.))。

out

tensor(27., grad_fn=<MeanBackward0>)

#z.sum().backward() #如果没有输出out这一项的时候进行求导  得出x.grad=18
out.backward() #如果out是标量(scalar)，则不需要

计算梯度 d(out)/dx

x

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

x.grad

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

可以得到一个包含值4.5的矩阵.

调用 out Tensor “$o$”.前面的函数$y=x+2$,$z=y\times y\times 3$

得到 $o=\frac{1}{4}{\sum }_i{z}_i$, $z_i=3(x_i+2{)}^2$ and $z_i{|}_{x_i=1}=27$.

因此, $\frac{\partial o}{\partial x_i}=\frac{3}{2}(x_i+2)$, hence $\frac{\partial o}{\partial x_i}{|}_{x_i=1}=\frac{9}{2}=4.5$.

之所以前面有$\frac{1}{4}$是因为矩阵$x$中含有四个值，如果含有九个值，就是$\frac{1}{9}$

如果你有一个向量值函数$\vec{y}=f(\vec{x})$,那么$\vec{y}$相对于$\vec{x}$的梯度是一个Jacobian矩阵:
$$J=\left(\begin{array}{ccc}\frac{\partial y_1}{\partial x_1}& \cdots & \frac{\partial y_1}{\partial x_n}\\ ⋮& \ddots & ⋮\\ \frac{\partial y_m}{\partial x_1}& \cdots & \frac{\partial y_m}{\partial x_n}\end{array}\right)$$

可以使用 autograd 做更多的操作

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

tensor([0.4658, 0.8040, 0.6128], requires_grad=True)

y=x * 2
y

tensor([0.9316, 1.6080, 1.2256], grad_fn=<MulBackward0>)

y.data.norm() # 等价于 torch.sqrt(torch.sum(torch.pow(y,2)))

tensor(2.2261)

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

tensor([ 679.1189, 1172.2533,  893.4659], grad_fn=<MulBackward0>)

现在，在这种情况下，y不再是标量(Scalar)。 torch.autograd无法直接计算完整的雅可比行列式，但是如果我们只想要向量-雅可比积，只需将向量传递给backward作为参数即可：

v = torch.tensor([0.1, 1.0, 0.0001], dtype=torch.float) #V是因为形势和y类似才这样类比
v

tensor([1.0000e-01, 1.0000e+00, 1.0000e-04])

y.backward(v)
print(x.grad)

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

如果.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 的官方文档