tensor 自动求导

自动求导(autograd)

直接用张量定义的运算时无法求导的,自动求导功能由 autograde 模块提供。

这小结主要包括:

  • 计算图(computation graph)

  • autograde.Variable

  • backward( )

先来举一个简单的例子:实现

并计算其在 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

  1. 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
  1. 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)


叶子节点(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, )
# next_functions 保存 grad_fn 的输入,y 中两个节点均为叶子节点,需要求导,梯度是累加的。
y.grad_fn.next_functions
((, 0),
 (, 0))
  1. 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=)

这里我们要掌握函数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.])

你可能感兴趣的:(tensor 自动求导)