3.2 Autograd
用 Tensor 训练网络很方便，但从上一小节最后的线性回归例子来看，反向传播过程需要手动实现。这对于像线性回归等较为简单的模型来说，还可以应付，但实际使用中经常出现非常复杂的网络结构，此时如果手动实现反向传播，不仅费时费力，而且容易出错，难以检查。torch.autograd 就是为方便用户使用，而专门开发的一套自动求导引擎，它能够根据输入和前向传播过程自动构建计算图，并执行反向传播。
计算图(Computation Graph) 是现代深度学习框架如 PyTorch 和 TensorFlow 等的核心，其为高效自动求导算法——反向传播(Back Propogation) 提供了理论支持，了解计算图在实际写程序过程中会有极大的帮助。本节将涉及一些基础的计算图知识，但并不要求读者事先对此有深入的了解。关于计算图的基础知识推荐阅读 Christopher Olah 的文章 ^1 。
3.2.1 Variable
PyTorch 在 autograd 模块中实现了计算图的相关功能，autograd 中的核心数据结构是 Variable。Variable 封装了 tensor，并记录对 tensor 的操作记录用来构建计算图。Variable 的数据结构如图 3-2 所示，主要包含三个属性：
data：保存 variable 所包含的 tensorgrad：保存data对应的梯度，grad也是 variable，而不是 tensor，它与data形状一致。grad_fn： 指向一个Function，记录 tensor 的操作历史，即它是什么操作的输出，用来构建计算图。如果某一个变量是由用户创建，则它为叶子节点，对应的 grad_fn 等于 None。
Variable 的构造函数需要传入 tensor，同时有两个可选参数：
requires_grad (bool)：是否需要对该 variable 进行求导volatile (bool)：意为 挥发，设置为 True，则构建在该 variable 之上的图都不会求导，专为推理阶段设计
Variable 提供了大部分 tensor 支持的函数，但其不支持部分 inplace 函数，因这些函数会修改 tensor 自身，而在反向传播中，variable 需要缓存原来的 tensor 来计算反向传播梯度。如果想要计算各个 Variable 的梯度，只需调用根节点 variable 的 backward 方法，autograd 会自动沿着计算图反向传播，计算每一个叶子节点的梯度。
variable.backward(grad_variables=None, retain_graph=None, create_graph=None) 主要有如下参数：
- grad_variables：形状与 variable 一致，对于 y.backward() ，grad_variables 相当于链式法则${dz \over dx}={dz \over dy} \times {dy \over dx}$中的$\textbf {dz} \over \textbf {dy}$。grad_variables 也可以是 tensor 或序列。
- retain_graph：反向传播需要缓存一些中间结果，反向传播之后，这些缓存就被清空，可通过指定这个参数不清空缓存，用来多次反向传播。
- create_graph：对反向传播过程再次构建计算图，可通过
backward of backward实现求高阶导数。
上述描述可能比较抽象，如果没有看懂，不用着急，会在本节后半部分详细介绍，下面先看几个例子。
from __future__ import print_function
import torch as t
from torch.autograd import Variable as V
# 从 tensor 中创建 variable，指定需要求导
a = V(t.ones(3,4), requires_grad = True)
a
Variable containing:
1 1 1 1
1 1 1 1
1 1 1 1
[torch.FloatTensor of size 3x4]
b = V(t.zeros(3,4))
b
Variable containing:
0 0 0 0
0 0 0 0
0 0 0 0
[torch.FloatTensor of size 3x4]
# 函数的使用与 tensor 一致
# 也可写成 c = a + b
c = a.add(b)
c
Variable containing:
1 1 1 1
1 1 1 1
1 1 1 1
[torch.FloatTensor of size 3x4]
d = c.sum()
d.backward() # 反向传播
# 注意二者的区别
# 前者在取 data 后变为 tensor，而后从 tensor 计算 sum 得到 float
# 后者计算 sum 后仍然是 Variable
c.data.sum(), c.sum()
(12.0, Variable containing:
12
[torch.FloatTensor of size 1])
a.grad
Variable containing:
1 1 1 1
1 1 1 1
1 1 1 1
[torch.FloatTensor of size 3x4]
# 此处虽然没有指定 c 需要求导，但 c 依赖于 a，而 a 需要求导，
# 因此 c 的 requires_grad 属性会自动设为 True
a.requires_grad, b.requires_grad, c.requires_grad
(True, False, True)
# 由用户创建的 variable 属于叶子节点，对应的 grad_fn 是 None
a.is_leaf, b.is_leaf, c.is_leaf
(True, True, False)
# c.grad 是 None, 因 c 不是叶子节点，它的梯度是用来计算 a 的梯度
# 所以虽然 c.requires_grad = True,但其梯度计算完之后即被释放
c.grad is None
True
计算下面这个函数的导函数： $$ y = x^2\bullet e^x $$ 它的导函数是： $$ {dy \over dx} = 2x\bullet e^x + x^2 \bullet e^x $$ 来看看 autograd 的计算结果与手动求导计算结果的误差。
def f(x):
'''计算 y'''
y = x**2 * t.exp(x)
return y
def gradf(x):
'''手动求导函数'''
dx = 2*x*t.exp(x) + x**2*t.exp(x)
return dx
x = V(t.randn(3,4), requires_grad = True)
y = f(x)
y
Variable containing:
0.4254 0.7854 0.1049 0.1510
6.6284 0.0255 13.9725 0.5228
0.0014 0.0011 11.7116 0.0647
[torch.FloatTensor of size 3x4]
y.backward(t.ones(y.size())) # grad_variables 形状与 y 一致
x.grad
Variable containing:
2.1057 3.2296 -0.4269 -0.4547
16.6229 -0.2674 30.9761 2.4259
-0.0712 -0.0652 26.6793 0.6344
[torch.FloatTensor of size 3x4]
# autograd 的计算结果与利用公式手动计算的结果一致
gradf(x)
Variable containing:
2.1057 3.2296 -0.4269 -0.4547
16.6229 -0.2674 30.9761 2.4259
-0.0712 -0.0652 26.6793 0.6344
[torch.FloatTensor of size 3x4]
3.2.2 计算图
PyTorch 中 autograd 的底层采用了计算图，计算图是一种特殊的有向无环图（DAG），用于记录算子与变量之间的关系。一般用矩形表示算子，椭圆形表示变量。如表达式 $\textbf{z = wx + b}$ 可分解为 $\textbf{y = wx}$ 和 $\textbf{z = y + b}$，其计算图如图 3-3 所示，图中 MUL ， ADD 都是算子，$\textbf{w}$，$\textbf{x}$，$\textbf{b}$ 即变量。
如上有向无环图中，$\textbf{X}$和$\textbf{b}$是叶子节点（leaf node），这些节点通常由用户自己创建，不依赖于其他变量。$\textbf{z}$称为根节点，是计算图的最终目标。利用链式法则很容易求得各个叶子节点的梯度。 $${\partial z \over \partial b} = 1,\space {\partial z \over \partial y} = 1\ {\partial y \over \partial w }= x,{\partial y \over \partial x}= w\ {\partial z \over \partial x}= {\partial z \over \partial y} {\partial y \over \partial x}=1 * w\ {\partial z \over \partial w}= {\partial z \over \partial y} {\partial y \over \partial w}=1 * x\ $$ 而有了计算图，上述链式求导即可利用计算图的反向传播自动完成，其过程如图 3-4 所示。
在 PyTorch 实现中，autograd 会随着用户的操作，记录生成当前 variable 的所有操作，并由此建立一个有向无环图。用户每进行一个操作，相应的计算图就会发生改变。更底层的实现中，图中记录了操作 Function ，每一个变量在图中的位置可通过其 grad_fn 属性在图中的位置推测得到。在反向传播过程中，autograd 沿着这个图从当前变量（根节点$\textbf{z}$）溯源，可以利用链式求导法则计算所有叶子节点的梯度。每一个前向传播操作的函数都有与之对应的反向传播函数用来计算输入的各个 variable 的梯度，这些函数的函数名通常以 Backward 结尾。下面结合代码学习 autograd 的实现细节。
x = V(t.ones(1))
b = V(t.rand(1), requires_grad = True)
w = V(t.rand(1), requires_grad = True)
y = w * x # 等价于 y=w.mul(x)
z = y + b # 等价于 z=y.add(b)
x.requires_grad, b.requires_grad, w.requires_grad
(False, True, True)
# 虽然未指定 y.requires_grad 为 True，但由于 y 依赖于需要求导的 w
# 故而 y.requires_grad 为 True
y.requires_grad
True
x.is_leaf, w.is_leaf, b.is_leaf
(True, True, True)
y.is_leaf, z.is_leaf
(False, False)
# grad_fn 可以查看这个 variable 的反向传播函数，
# z 是 add 函数的输出，所以它的反向传播函数是 AddBackward
z.grad_fn
<AddBackward1 at 0x7f2b86eed400>
# next_functions 保存 grad_fn 的输入，是一个 tuple，tuple 的元素也是 Function
# 第一个是 y，它是乘法(mul) 的输出，所以对应的反向传播函数 y.grad_fn 是 MulBackward
# 第二个是 b，它是叶子节点，由用户创建，grad_fn 为 None，但是有
z.grad_fn.next_functions
((<MulBackward1 at 0x7f2b86eed8d0>, 0),
(<AccumulateGrad at 0x7f2b86eed898>, 0))
# variable 的 grad_fn 对应着和图中的 function 相对应
z.grad_fn.next_functions[0][0] == y.grad_fn
True
# 第一个是 w，叶子节点，需要求导，梯度是累加的
# 第二个是 x，叶子节点，不需要求导，所以为 None
y.grad_fn.next_functions
((<AccumulateGrad at 0x7f2b86eed358>, 0), (None, 0))
# 叶子节点的 grad_fn 是 None
w.grad_fn,x.grad_fn
(None, None)
计算 w 的梯度的时候，需要用到 x 的数值(${\partial y\over \partial w} = x $)，这些数值在前向过程中会保存成 buffer，在计算完梯度之后会自动清空。为了能够多次反向传播需要指定 retain_graph 来保留这些 buffer。
# 使用 retain_graph 来保存 buffer
z.backward(retain_graph=True)
w.grad
Variable containing:
1
[torch.FloatTensor of size 1]
# 多次反向传播，梯度累加，这也就是 w 中 AccumulateGrad 标识的含义
z.backward()
w.grad
Variable containing:
2
[torch.FloatTensor of size 1]
PyTorch 使用的是动态图，它的计算图在每次前向传播时都是从头开始构建，所以它能够使用 Python 控制语句（如 for、if 等）根据需求创建计算图。这点在自然语言处理领域中很有用，它意味着你不需要事先构建所有可能用到的图的路径，图在运行时才构建。
def abs(x):
if x.data[0]>0: return x
else: return -x
x = V(t.ones(1),requires_grad=True)
y = abs(x)
y.backward()
x.grad
Variable containing:
1
[torch.FloatTensor of size 1]
x = V(-1*t.ones(1),requires_grad=True)
y = abs(x)
y.backward()
print(x.grad)
Variable containing:
-1
[torch.FloatTensor of size 1]
def f(x):
result = 1
for ii in x:
if ii.data[0]>0: result=ii*result
return result
x = V(t.arange(-2,4),requires_grad=True)
y = f(x) # y = x[3]*x[4]*x[5]
y.backward()
x.grad
Variable containing:
0
0
0
6
3
2
[torch.FloatTensor of size 6]
变量的 requires_grad 属性默认为 False，如果某一个节点 requiresgrad 被设置为 True，那么所有依赖它的节点 requires_grad 都是 True。这其实很好理解，对于$ \textbf{x}\to \textbf{y} \to \textbf{z}$，x.requiresgrad = True，当需要计算$\partial z \over \partial x$时，根据链式法则，$\frac{\partial z}{\partial x} = \frac{\partial z}{\partial y} \frac{\partial y}{\partial x}$，自然也需要求$ \frac{\partial z}{\partial y}$，所以 y.requires_grad 会被自动标为 True.
volatile=True 是另外一个很重要的标识，它能够将所有依赖于它的节点全部都设为 volatile=True ，其优先级比 requires_grad=True 高。 volatile=True 的节点不会求导，即使 requires_grad=True ，也无法进行反向传播。对于不需要反向传播的情景（如 inference，即测试推理时），该参数可实现一定程度的速度提升，并节省约一半显存，因其不需要分配空间计算梯度。
x = V(t.ones(1))
w = V(t.rand(1), requires_grad=True)
y = x * w
# y 依赖于 w，而 w.requires_grad = True
x.requires_grad, w.requires_grad, y.requires_grad
(False, True, True)
x = V(t.ones(1), volatile=True)
w = V(t.rand(1), requires_grad = True)
y = x * w
# y 依赖于 w 和 x，但 x.volatile = True，w.requires_grad = True
x.requires_grad, w.requires_grad, y.requires_grad
(False, True, False)
x.volatile, w.volatile, y.volatile
(True, False, True)
在反向传播过程中非叶子节点的导数计算完之后即被清空。若想查看这些变量的梯度，有两种方法：
- 使用 autograd.grad 函数
- 使用 hook
autograd.grad 和 hook 方法都是很强大的工具，更详细的用法参考官方 api 文档，这里举例说明基础的使用。推荐使用 hook 方法，但是在实际使用中应尽量避免修改 grad 的值。
x = V(t.ones(3), requires_grad=True)
w = V(t.rand(3), requires_grad=True)
y = x * w
# y 依赖于 w，而 w.requires_grad = True
z = y.sum()
x.requires_grad, w.requires_grad, y.requires_grad
(True, True, True)
# 非叶子节点 grad 计算完之后自动清空，y.grad 是 None
z.backward()
(x.grad, w.grad, y.grad)
(Variable containing:
0.6855
0.2406
0.7724
[torch.FloatTensor of size 3], Variable containing:
1
1
1
[torch.FloatTensor of size 3], None)
# 第一种方法：使用 grad 获取中间变量的梯度
x = V(t.ones(3), requires_grad=True)
w = V(t.rand(3), requires_grad=True)
y = x * w
z = y.sum()
# z 对 y 的梯度，隐式调用 backward()
t.autograd.grad(z, y)
(Variable containing:
1
1
1
[torch.FloatTensor of size 3],)
# 第二种方法：使用 hook
# hook 是一个函数，输入是梯度，不应该有返回值
def variable_hook(grad):
print('y 的梯度： \r\n',grad)
x = V(t.ones(3), requires_grad=True)
w = V(t.rand(3), requires_grad=True)
y = x * w
# 注册 hook
hook_handle = y.register_hook(variable_hook)
z = y.sum()
z.backward()
# 除非你每次都要用 hook，否则用完之后记得移除 hook
hook_handle.remove()
y 的梯度：
Variable containing:
1
1
1
[torch.FloatTensor of size 3]
最后再来看看 variable 中 grad 属性和 backward 函数 grad_variables 参数的含义，这里直接下结论：
- variable $\textbf{x}$的梯度是目标函数${f(x)} $对$\textbf{x}$的梯度，$\frac{df(x)}{dx} = (\frac {df(x)}{dx0},\frac {df(x)}{dx1},…,\frac {df(x)}{dx_N})$，形状和$\textbf{x}$一致。
- 对于 y.backward(gradvariables) 中的 gradvariables 相当于链式求导法则中的$\frac{\partial z}{\partial x} = \frac{\partial z}{\partial y} \frac{\partial y}{\partial x}$中的$\frac{\partial z}{\partial y}$。z 是目标函数，一般是一个标量，故而$\frac{\partial z}{\partial y}$的形状与 variable $\textbf{y}$的形状一致。
z.backward()在一定程度上等价于 y.backward(grady)。z.backward()省略了 gradvariables 参数，是因为$z$是一个标量，而$\frac{\partial z}{\partial z} = 1$
x = V(t.arange(0,3), requires_grad=True)
y = x**2 + x*2
z = y.sum()
z.backward() # 从 z 开始反向传播
x.grad
Variable containing:
2
4
6
[torch.FloatTensor of size 3]
x = V(t.arange(0,3), requires_grad=True)
y = x**2 + x*2
z = y.sum()
y_grad_variables = V(t.Tensor([1,1,1])) # dz/dy
y.backward(y_grad_variables) #从 y 开始反向传播
x.grad
Variable containing:
2
4
6
[torch.FloatTensor of size 3]
另外值得注意的是，只有对 variable 的操作才能使用 autograd，如果对 variable 的 data 直接进行操作，将无法使用反向传播。除了对参数初始化，一般我们不会修改 variable.data 的值。
在 PyTorch 中计算图的特点可总结如下：
- autograd 根据用户对 variable 的操作构建其计算图。对变量的操作抽象为
Function。 - 对于那些不是任何函数(Function) 的输出，由用户创建的节点称为叶子节点，叶子节点的
grad_fn为 None。叶子节点中需要求导的 variable，具有AccumulateGrad标识，因其梯度是累加的。 - variable 默认是不需要求导的，即
requires_grad属性默认为 False，如果某一个节点 requires_grad 被设置为 True，那么所有依赖它的节点requires_grad都为 True。 - variable 的
volatile属性默认为 False，如果某一个 variable 的volatile属性被设为 True，那么所有依赖它的节点volatile属性都为 True。volatile 属性为 True 的节点不会求导，volatile 的优先级比requires_grad高。 - 多次反向传播时，梯度是累加的。反向传播的中间缓存会被清空，为进行多次反向传播需指定
retain_graph=True 来保存这些缓存。 - 非叶子节点的梯度计算完之后即被清空，可以使用
autograd.grad或hook技术获取非叶子节点的值。 - variable 的 grad 与 data 形状一致，应避免直接修改 variable.data，因为对 data 的直接操作无法利用 autograd 进行反向传播
- 反向传播函数
backward的参数grad_variables可以看成链式求导的中间结果，如果是标量，可以省略，默认为 1 - PyTorch 采用动态图设计，可以很方便地查看中间层的输出，动态的设计计算图结构。
3.2.3 扩展 autograd
目前绝大多数函数都可以使用 autograd 实现反向求导，但如果需要自己写一个复杂的函数，不支持自动反向求导怎么办? 写一个 Function ，实现它的前向传播和反向传播代码， Function 对应于计算图中的矩形， 它接收参数，计算并返回结果。下面给出一个例子。
class Mul(Function):
@staticmethod
def forward(ctx, w, x, b, x_requires_grad = True):
ctx.x_requires_grad = x_requires_grad
ctx.save_for_backward(w,x)
output = w * x + b
return output
@staticmethod
def backward(ctx, grad_output):
w,x = ctx.saved_variables
grad_w = grad_output * x
if ctx.x_requires_grad:
grad_x = grad_output * w
else:
grad_x = None
grad_b = grad_output * 1
return grad_w, grad_x, grad_b, None
分析如下：
- 自定义的 Function 需要继承 autograd.Function，没有构造函数
__init__，forward 和 backward 函数都是静态方法 - forward 函数的输入和输出都是 Tensor，backward 函数的输入和输出都是 Variable
- backward 函数的输出和 forward 函数的输入一一对应，backward 函数的输入和 forward 函数的输出一一对应
- backward 函数的 grad_output 参数即 t.autograd.backward 中的
grad_variables - 如果某一个输入不需要求导，直接返回 None，如 forward 中的输入参数 xrequiresgrad 显然无法对它求导，直接返回 None 即可
- 反向传播可能需要利用前向传播的某些中间结果，需要进行保存，否则前向传播结束后这些对象即被释放
Function 的使用利用 Function.apply(variable)
from torch.autograd import Function
class MultiplyAdd(Function):
@staticmethod
def forward(ctx, w, x, b):
print('type in forward',type(x))
ctx.save_for_backward(w,x)
output = w * x + b
return output
@staticmethod
def backward(ctx, grad_output):
w,x = ctx.saved_variables
print('type in backward',type(x))
grad_w = grad_output * x
grad_x = grad_output * w
grad_b = grad_output * 1
return grad_w, grad_x, grad_b
x = V(t.ones(1))
w = V(t.rand(1), requires_grad = True)
b = V(t.rand(1), requires_grad = True)
print('开始前向传播')
z=MultiplyAdd.apply(w, x, b)
print('开始反向传播')
z.backward() # 等效
# x 不需要求导，中间过程还是会计算它的导数，但随后被清空
x.grad, w.grad, b.grad
开始前向传播
type in forward <class 'torch.FloatTensor'>
开始反向传播
type in backward <class 'torch.autograd.variable.Variable'>
(None, Variable containing:
1
[torch.FloatTensor of size 1], Variable containing:
1
[torch.FloatTensor of size 1])
x = V(t.ones(1))
w = V(t.rand(1), requires_grad = True)
b = V(t.rand(1), requires_grad = True)
print('开始前向传播')
z=MultiplyAdd.apply(w,x,b)
print('开始反向传播')
# 调用 MultiplyAdd.backward
# 输出 grad_w, grad_x, grad_b
z.grad_fn.apply(V(t.ones(1)))
开始前向传播
type in forward <class 'torch.FloatTensor'>
开始反向传播
type in backward <class 'torch.autograd.variable.Variable'>
(Variable containing:
1
[torch.FloatTensor of size 1], Variable containing:
0.6617
[torch.FloatTensor of size 1], Variable containing:
1
[torch.FloatTensor of size 1])
之所以 forward 函数的输入是 tensor，而 backward 函数的输入是 variable，是为了实现高阶求导。backward 函数的输入输出虽然是 variable，但在实际使用时 autograd.Function 会将输入 variable 提取为 tensor，并将计算结果的 tensor 封装成 variable 返回。在 backward 函数中，之所以也要对 variable 进行操作，是为了能够计算梯度的梯度（backward of backward）。下面举例说明，有关 torch.autograd.grad 的更详细使用请参照文档。
x = V(t.Tensor([5]), requires_grad=True)
y = x ** 2
grad_x = t.autograd.grad(y, x, create_graph=True)
grad_x # dy/dx = 2 * x
(Variable containing:
10
[torch.FloatTensor of size 1],)
grad_grad_x = t.autograd.grad(grad_x[0],x)
grad_grad_x # 二阶导数 d(2x)/dx = 2
(Variable containing:
2
[torch.FloatTensor of size 1],)
这种设计虽然能让 autograd 具有高阶求导功能，但其也限制了 Tensor 的使用，因 autograd 中反向传播的函数只能利用当前已经有的 Variable 操作。这个设计是在 0.2 版本新加入的，为了更好的灵活性，也为了兼容旧版本的代码，PyTorch 还提供了另外一种扩展 autograd 的方法。PyTorch 提供了一个装饰器 @once_differentiable ，能够在 backward 函数中自动将输入的 variable 提取成 tensor，把计算结果的 tensor 自动封装成 variable。有了这个特性我们就能够很方便的使用 numpy/scipy 中的函数，操作不再局限于 variable 所支持的操作。但是这种做法正如名字中所暗示的那样只能求导一次，它打断了反向传播图，不再支持高阶求导。
上面所描述的都是新式 Function，还有个 legacy Function，可以带有 __init__ 方法， forward 和 backwad 函数也不需要声明为 @staticmethod ，但随着版本更迭，此类 Function 将越来越少遇到，在此不做更多介绍。
此外在实现了自己的 Function 之后，还可以使用 gradcheck 函数来检测实现是否正确。 gradcheck 通过数值逼近来计算梯度，可能具有一定的误差，通过控制 eps 的大小可以控制容忍的误差。 关于这部份的内容可以参考 github 上开发者们的讨论 ^3 。
下面举例说明如何利用 Function 实现 sigmoid Function。
class Sigmoid(Function):
@staticmethod
def forward(ctx, x):
output = 1 / (1 + t.exp(-x))
ctx.save_for_backward(output)
return output
@staticmethod
def backward(ctx, grad_output):
output, = ctx.saved_variables
grad_x = output * (1 - output) * grad_output
return grad_x
# 采用数值逼近方式检验计算梯度的公式对不对
test_input = V(t.randn(3,4), requires_grad=True)
t.autograd.gradcheck(Sigmoid.apply, (test_input,), eps=1e-3)
True
def f_sigmoid(x):
y = Sigmoid.apply(x)
y.backward(t.ones(x.size()))
def f_naive(x):
y = 1/(1 + t.exp(-x))
y.backward(t.ones(x.size()))
def f_th(x):
y = t.sigmoid(x)
y.backward(t.ones(x.size()))
x=V(t.randn(100, 100), requires_grad=True)
%timeit -n 100 f_sigmoid(x)
%timeit -n 100 f_naive(x)
%timeit -n 100 f_th(x)
406 µs ± 51.1 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
425 µs ± 25.5 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
426 µs ± 98.5 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
显然 f_sigmoid 要比单纯利用 autograd 加减和乘方操作实现的函数快不少，因为 f_sigmoid 的 backward 优化了反向传播的过程。另外可以看出系统实现的 buildin 接口(t.sigmoid) 更快。
3.2.4 小试牛刀: 用 Variable 实现线性回归
在上一节中讲解了利用 tensor 实现线性回归，在这一小节中，将讲解如何利用 autograd/Variable 实现线性回归，以此感受 autograd 的便捷之处。
import torch as t
from torch.autograd import Variable as V
%matplotlib inline
from matplotlib import pyplot as plt
from IPython import display
# 设置随机数种子，为了在不同人电脑上运行时下面的输出一致
t.manual_seed(1000)
def get_fake_data(batch_size=8):
''' 产生随机数据：y = x*2 + 3，加上了一些噪声'''
x = t.rand(batch_size,1) * 20
y = x * 2 + (1 + t.randn(batch_size, 1))*3
return x, y
# 来看看产生 x-y 分布是什么样的
x, y = get_fake_data()
plt.scatter(x.squeeze().numpy(), y.squeeze().numpy())
<matplotlib.collections.PathCollection at 0x7f2c6f759eb8>
# 随机初始化参数
w = V(t.rand(1,1), requires_grad=True)
b = V(t.zeros(1,1), requires_grad=True)
lr =0.001 # 学习率
for ii in range(8000):
x, y = get_fake_data()
x, y = V(x), V(y)
# forward：计算 loss
y_pred = x.mm(w) + b.expand_as(y)
loss = 0.5 * (y_pred - y) ** 2
loss = loss.sum()
# backward：手动计算梯度
loss.backward()
# 更新参数
w.data.sub_(lr * w.grad.data)
b.data.sub_(lr * b.grad.data)
# 梯度清零
w.grad.data.zero_()
b.grad.data.zero_()
if ii%1000 ==0:
# 画图
display.clear_output(wait=True)
x = t.arange(0, 20).view(-1, 1)
y = x.mm(w.data) + b.data.expand_as(x)
plt.plot(x.numpy(), y.numpy()) # predicted
x2, y2 = get_fake_data(batch_size=20)
plt.scatter(x2.numpy(), y2.numpy()) # true data
plt.xlim(0,20)
plt.ylim(0,41)
plt.show()
plt.pause(0.5)
print(w.data.squeeze()[0], b.data.squeeze()[0])
2.0188677310943604 2.8898630142211914
用 autograd 实现的线性回归最大的不同点就在于 autograd 不需要计算反向传播，可以自动计算微分。这点不单是在深度学习，在许多机器学习的问题中都很有用。另外需要注意的是在每次反向传播之前要记得先把梯度清零。
本章主要介绍了 PyTorch 中两个基础底层的数据结构：Tensor 和 autograd 中的 Variable。Tensor 是一个类似 Numpy 数组的高效多维数值运算数据结构，有着和 Numpy 相类似的接口，并提供简单易用的 GPU 加速。Variable 是 autograd 封装了 Tensor 并提供自动求导技术的，具有和 Tensor 几乎一样的接口。 autograd 是 PyTorch 的自动微分引擎，采用动态计算图技术，能够快速高效的计算导数。
如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。
绑定邮箱获取回复消息
由于您还没有绑定你的真实邮箱，如果其他用户或者作者回复了您的评论，将不能在第一时间通知您！
发布评论