【Pytorch教程】Pytorch tutorials 02-Autograd 中文翻译

Autograd

本篇文章是本人对Pytorch官方教程的原创翻译(原文链接)仅供学习交流使用，转载请注明出处！

autograd是Pytorch搭建神经网络最关键的包。它可以自动计算tensor操作产生的微分，也就是说，autograd是一个define-by-run的框架，可以自动对你的网络进行反向传播。

在声明一个tesnor时，可以指定参数.requires_grad=True开启自动求导，这样Pytorch就会跟踪它的所有操作，在tensor运算完成后，可以调用.backward()方法计算梯度，tesnor的梯度存放在它的.grad属性当中。

.detach()方法可以取消对tensor的梯度追踪，这样Pytorch就会把tensor从追踪记录中移除，不再继续追踪。

为了节约内存、提高效率，可以在代码块前注明with torch.no_grad()，因为有些变量虽然requires_grad=True但其实并不需要计算梯度。

在autograd包中，还有一个非常重要的类就是Function，除了用户基于数据直接创建的Tensor（像a=torch.Tensor([1, 2, 3,])这样），其他的Tensor必然是根据某些Tensor通过运算得到的，Function类就记录了这一运算过程，并存储在.grad_fn属性中。

当需要计算梯度时，首先需要调用y.backward()如果y是一个标量的话，则无需传参，否则，必须传入一个与y规模相同的tensor。

这是因为，在autograd包中，实际计算的是vector-Jacobian积。也就是给定任意的向量 $v=(v_1 v_2 \cdots v_m)^T$ ,计算 $v$ 与Jacobian矩阵 $J$ 的积 ${v^T}·J$ 。如果 $v$ 恰好是某个标量函数 $l=g(\overrightarrow{y})$ 的梯度，即:

$v=\left( \frac{\partial{l}}{\partial{y_1}} \frac{\partial{l}}{\partial{y_2}} \cdots \frac{\partial{l}}{\partial{y_m}}\right)^T$

Jacobian矩阵：

$J= \begin{pmatrix} \frac{\partial y_1}{\partial x_1} & \frac{\partial y_1}{\partial x_2} & \cdots & \frac{\partial y_1}{\partial x_n} \\ \frac{\partial y_2}{\partial x_1} & \frac{\partial y_2}{\partial x_2} & \cdots & \frac{\partial y_2}{\partial x_n} \\ \vdots & \vdots & \ddots & \vdots \\ \frac{\partial y_m}{\partial x_1} & \frac{\partial y_m}{\partial x_2} & \cdots & \frac{\partial y_m}{\partial x_n} \\ \end{pmatrix}$

其中: ${y_i}$ 是关于 ${x_1,x_2,\cdots,x_n}$ 的多元函数,即： ${y_i}={y_i}\left( x_1,x_2,\cdots,x_n \right)$

那么根据链式法则,v-J积的结果即是 $l$ 关于 $\overrightarrow x$ 的梯度：

${J^T}·v={\begin{pmatrix}\frac{\partial y_1}{\partial x_1} & \frac{\partial y_1}{\partial x_2} & \cdots & \frac{\partial y_1}{\partial x_n} \\ \frac{\partial y_2}{\partial x_1} & \frac{\partial y_2}{\partial x_2} & \cdots & \frac{\partial y_2}{\partial x_n} \\ \vdots & \vdots & \ddots & \vdots \\ \frac{\partial y_m}{\partial x_1} & \frac{\partial y_m}{\partial x_2} & \cdots & \frac{\partial y_m}{\partial x_n} \\ \end{pmatrix}}·{\begin{pmatrix} \frac{\partial{l}}{\partial{y_1}} \\ \frac{\partial{l}}{\partial{y_2}} \\ \vdots \\ \frac{\partial{l}}{\partial{y_m}} \end{pmatrix}} = {\begin{pmatrix} \frac{\partial{l}}{\partial{x_1}} \\ \frac{\partial{l}}{\partial{x_2}} \\ \vdots \\ \frac{\partial{l}}{\partial{x_n}} \end{pmatrix}}$

定理： $({AB})^T={B^T}{A^T}$ ，因此计算 ${v^T}·J$ 等价于 ${J^T}·v$

vector-Jacobian积的这种特性使得模型非常容易扩展。

接下来看一些例子：

import torch

初始化一个tensor，并将它的requires_grad属性设为True,追踪它的运算。

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

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

创建一个tensory = x + 2

y = x + 2
print(y)

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

y是由x计算得到的，所以它的.grad_fn不为空

print(y.grad_fn)

<AddBackward0 object at 0x0000028CCEE770C8>

做一些其他运算：

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_(...)方法可以改变tensor的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 0x0000028CCEE83CC8>

接下来尝试使用自动求导机制，上文中使用到的out是一个标量，那么对out反向传播则可以直接调用out.backward()，等价于out.backward(torch.tensor(1))

out.backward()

print(x.grad)

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

检验：

$\begin{equation}\begin{split} out&=\frac{1}{4}\sum_i{z_i}\\ z_i&=3({x_i}+2)^2\\ {z_i}\big|_{{x_i}=1}&=27\\ \frac{\partial out}{\partial x_i}&=\frac{3}{2}({x_i}+2)=4.5\\ \end{split}\end{equation}$

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

y = x * 2
while y.data.norm() < 1000:  #norm是L-p范数，默认求2范数
    y = y * 2
    
print(y)

tensor([939.6540, 998.4269,   6.6829], grad_fn=<MulBackward0>)

L-P范数 $L_p=\left\|x\right\|_p=\sqrt[p]{\sum_{i=1}^n{x_{i}^{p}}}$

此时y不再是标量，自动求导机制不能直接计算Jacobian行列式，反向传播得到的.grad是vector-Jacobian积。

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

print(x.grad)

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

with torch.no_grad():可以临时取消对代码块内的tensor的追踪。

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

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

True
True
False
True

.detach()方法可以将tensor从自动求导机制中隔离出来，得到的新tensor将不再需要求导。

print(x.requires_grad)
# y和x数据相同，不需要求导
# y不是x的拷贝，对y的修改也会影响x
# 如果直接令y = x，那么是不会取消追踪的
y = x.detach() 
print(y.requires_grad)
print(x.eq(y).all())  # 对比全部数据

True
False
tensor(True)