自动求导(autograd)
直接用张量定义的运算时无法求导的，自动求导功能由 autograde 模块提供。
这小结主要包括：
计算图(computation graph)
autograde.Variablebackward( )
先来举一个简单的例子：实现
并计算其在 x = 3 处的导数。因为
所以
import torch
from torch.autograd import Variable
# 定义变量x
x = Variable(torch.Tensor([3]), requires_grad = True)
# 定义函数
f = x*x - x # 向前构建计算图
# 求导数
f.backward() # 向后传播求导数
print(x)
print('f(3)=', f.data[0])
print('f\'(3)=', x.grad.data[0])
tensor([3.], requires_grad=True)
f(3)= tensor(6.)
f'(3)= tensor(5.)
上面的例子演示了一个典型的自动求导的过程。
首先定义了 Variable 生产变量，x = Variable(value,requires_grad = True)
接着向前传播计算函数(同时构建计算图): y = f(x)
反向传播计算导数: y.backward(), 导数 dy/dx 自动储存在 x.grad
下面我们来看一下每一步在做什么。
Variable
Variable 类封装了 Tensor 类，其支持几乎所有 Tensor 支持的运算。和 Tensor 不同基于 Variable 的运算是会同时构建计算图。这个计算图能帮助我们自动求导。Variable 主要包含三个部分：
autograde.Variable:
data
grade
grad_fn
-
Variable.data: 储存 Variable 的值，有以下两个可选参数：
- require_grad (boolean): 是否需要对该变量进行求导
- volatile (boolean): 为 True 时意味着构建在该 variable 之上的图都不会求导，且 volatile 的优先级高于 require_grade
value = torch.Tensor([1,2])
x = Variable(value, requires_grad = True)
print(x.data is value) # 检查x.data 与 value 是否共享内存
False
- Variable.grade_fn: 存储该 Variable 是通过什么样的基本运算得到，它将被用于 backward 的时候求导。譬如 y = x+x，那么 grad_fn 记录的就是 y 由 x 和 x 做加法得到。根据链式法则，有了 dy ，那么 grad_fn 就会告诉我们如何求出 dx 。
y = x + x
z = x**3
print(y.grad_fn)
print(z.grad_fn)
<AddBackward0 object at 0x000001B529EE0CF8>
<PowBackward0 object at 0x000001B529EE06D8>
叶子节点（leaf node）：由用户自己创建，不依赖于其他变量的节点。叶子节点的 grad_fn 为 None。
# check whether is leaf node
x.is_leaf,y.is_leaf
(True, False)
# 查看该变量的反向传播函数
x.grad_fn,y.grad_fn
(None, <AddBackward0 at 0x1b529f04048>)
# next_functions 保存 grad_fn 的输入，y 中两个节点均为叶子节点，需要求导，梯度是累加的。
y.grad_fn.next_functions
((<AccumulateGrad at 0x1b529f040f0>, 0),
(<AccumulateGrad at 0x1b529f040f0>, 0))
- Variable.grad: 存储导数。注意：
- Variable.grad 本身还是个 Variable
- 一个变量 x 可能会属于多个计算图，每次调用
backward(), 导数是累加的。所以如果不想导数累加，运行backward()之前需要用x.grad.data.zero_()对导数清零。 - 在计算 x 的导数时，导数值会在向前的过程中形成 buffer ，在计算完成后会自动清空。若是需要多次反向传播，需要使用
backward(retain_graph = True)来保留这些 buffer 。
x = Variable(torch.Tensor([1]),requires_grad = True)
y = x + x # 计算图1
z = x**3 # 计算图2
# 第一次求导
y.backward()
print(x.grad.data) # dy/dx = 2
z.backward()
print(x.grad.data) # dy/dx + dz/dx = 2+3 = 5
tensor([2.])
tensor([5.])
x = Variable(torch.Tensor([1]),requires_grad = True)
y = x + x # 计算图1
z = x**3 # 计算图2
# 第一次求导
y.backward()
print(x.grad.data) # dy/dx = 2
x.grad.data.zero_()
z.backward()
print(x.grad.data) # dy/dx + dz/dx = 2+3 = 5
tensor([2.])
tensor([3.])
高阶导数
在很多实际应用中我们需要求高阶导数。在实际大规模问题中，直接二阶导数，是 Hessian 矩阵，而这个矩阵往往是非常巨大的，计算起来代价是不能接受的。因此 PyTorch 提供的高阶导数功能并不是直接求二阶导数，而是提供对梯度的函数求导，也就是说我们可以做如下运算：
下面我们举例子说明：
x = Variable(torch.Tensor([1,2,3]),requires_grad = True)
y = x*x
f = y.sum() # y 是一个向量
df = torch.autograd.grad(f, x, create_graph = True) # create_graph = True 会对反向传播构建计算图，用于计算二阶导数
print(df[0])
tensor([2., 4., 6.], grad_fn=<AddBackward0>)
这里我们要掌握函数torch.autograd.grad(y,x,creat_graph = False), 该函数直接返回导数 dy/dx. 不同于backward()， 它并不会把导数累加到 x.grad 上面。另外creat_graph 参数表示反向传播的时候是否构建新计算图，如果需要计算二阶导数，其值必须为True；否则没法对导数继续求导。下面让我们完成导数的导数：
G = df[0].pow(2).sum()
dG = torch.autograd.grad(G,x)
print(dG[0])
tensor([ 8., 16., 24.])
