Pytorch学习（4）-Autograd

最新推荐文章于 2022-04-14 16:50:06 发布

nonono吧

最新推荐文章于 2022-04-14 16:50:06 发布

阅读量297

点赞数

分类专栏：强化学习——Pytorch

本文链接：https://blog.csdn.net/ileopard/article/details/104102118

版权

强化学习——Pytorch 专栏收录该内容

8 篇文章 2 订阅

订阅专栏

Autograd（torch.autograd）：一套自动求导引擎，可以根据输入和前向传播过程自动构建计算图，并执行反向传播。

计算图（Computation Graph）是现代深度学习框架（如PyTorch和Tensorflow等）的核心，它为自动求导算法——反向传播（Back Propogation）提供了理论支持。

一、Variable

PyTorch在autograd模块中实现了计算图的相关功能，autograd中的核心数据结构是Variable。Variable中封装了tensor，并记录对tensor的操作记录用来构建计算图。Variable的数据结构如下图：

主要包含三个属性：

data：保存variable所包含的tensor。
grad：保存data对应的梯度，grad也是variable，而非tensor，它与data形状一致。
grad_fn：指向一个Function，记录variable的操作历史，即它是什么操作的输出，用来构建计算图。如果某一个变量是由用户创建的，则它为叶子节点，对应的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相当于链式法则中。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)

# -----------------------------------------
b = V(t.zeros(3, 4))

# 函数的使用与tensor一致
# 也可写成c = a + b
c = a.add(b)

d = c.sum()
d.backward()  # 反向传播

# 输出Variable的三个属性
print(c.data)  # 保存variable中的tensor
print(c.grad)  # 保存data的梯度，也是variable类型
print(c.grad_fn)  # 记录variable的操作历史，如果某一个变量是用户创建的，则它为叶子节点
# 输出为None
# -------------------------------------------------
输出结果：
tensor([[1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [1., 1., 1., 1.]])
None
<AddBackward0 object at 0x000001F699262848> 可以看到操作历史：add
# ---------------------------------------------------

# 此处虽然没有指定c需要求导，但c依赖于a，而a需要求导
# 因此c的requires_grad属性会自动设为True
print(a.requires_grad)

# 由用户创建的variable属于叶子节点，对应的grad_fn是None
print(a.is_leaf)

# c.grad是None，c不是叶子节点，它的梯度是用来计算a的梯度
# 虽然c.requires_grad = True，但其梯度计算完之后即被释放
print(c.grad is None)
# --------------------------------------------------

使用Autograd计算的导数

from __future__ import print_function
import torch as t
from torch.autograd import Variable as V

# 原函数
def f(x):
    # 计算y
    y = pow(x, 2) * t.exp(x)
    return y

# f(x)的导数
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)
print(y)

# 通过反向传播，自动计算梯度，保存在Variable的grad中
# grad_variables形状与y一致
y.backward(t.ones(y.size()))
print(x.grad)

# antograd的计算结果与利用公式手动计算的结果一致
print(gradf(x))

计算图

PyTorch中Autograd的底层采用了计算图，计算图是一种特殊的有向无环图(DAG)，用于记录算子与变量之间的关系。

一般用矩阵表示算子，椭圆形表示变量。

例如：表达式z = wx + b可分解为y = wx和z = y + b，其计算图如下，图中MUL和ADD都是算子，w、x、b为变量。

如上有向无环图中，X和b是叶子节点(leaf node)，这些节点通常由用户自己创建，不依赖于其他变量。

z称为根节点，是计算图的最终目标。利用链式法则很容易求的各个叶子节点的梯度。

而有了计算图，上述链式求导即可利用计算图的反向传播自动完成，其过程如下图：

在PyTorch实现中，autograd会随着用户的操作，记录生成当前variable的所有操作，并由此建立一个有向无环图。每进行一次操作，相应的计算图就会发生改变。

更底层的实现中，计算图中记录了操作Function，每一个变量在图中的位置可通过其grad_fn属性在图中的位置推测得到。

在反向传播中，autograd沿着这个图从当前变量（根节点z）溯源，可以利用链式求导法则计算所有叶子节点的梯度。

每一个前向传播操作的函数都要与之对应的反向传播函数用来计算输入的各个variable的梯度，这些函数的函数名通常以Backward结尾。

from __future__ import print_function
import torch as t
from torch.autograd import Variable as V


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)

# 虽然未指定y.requires_grad为True
# 故而y.requires_grad为True
print(y.requires_grad)

# grad_fn可以查看这个variable的反向传播函数
# z是add函数的输出，所以它的反向传播函数是AddBackward
print(z.grad_fn)

# next_function保存grad_fn的输入，grad_fn的输入是一个tuple
# 第一个是y，它是乘法(mul)的输出，所以对应的反向传播函数y.grad_fn是MulBackward
# 第二个是b，它是叶子节点，由用户创建，grad_fn为None，但是有
print(z.grad_fn.next_functions)

# variable的grad_fn对应着图中的function
print(z.grad_fn.next_functions[0][0] == y.grad_fn)

# 第一个是w，叶子节点，需要求导，梯度是累加的
# 第二个是x，叶子节点，不需要求导，所以为None
print(y.grad_fn.next_functions)

# 叶子节点的grad_fn是None
print(w.grad_fn)
print(x.grad_fn)

计算w的梯度时需要用到x的数值( = x)，这些数值在前向过程中会保存成buffer，在计算完梯度之后会自动清空。

为了能够多次反向传播需要指定retain_graph来保留这些buffer。

# 使用retain_graph保存buffer
z.backward(retain_graph=True)
print(w.grad)

# 多次反向传播，梯度累加，这也就是w中AccumulateGrad标识的含义
z.backward()
print(w.grad)

#----------------------------------------------------------
tensor([1.])
tensor([2.])

PyTorch使用的是动态图，它的计算图在每次前向传播时都是从头开始构建的。所以它能够使用Python控制语句(如for、if等)，根据需求创建计算图。它意味着你不需要事先构建所有可能用到的图的路径，图在运行时才构建。

def abs(x):
    if x.data[0] > 0:
        return x
    else:
        return -x


x = V(t.rand(1), requires_grad=True)
y = abs(x)
y.backward()  # 反向传播，会自动求梯度
# 查看x的梯度
print(x.grad)
#-----------------------
tensor([1.])

# -----------------------------------------
def f(x):
    result = 1
    for ii in x:
        if ii.data.item() > 0:
            result = ii * result
    return result


x = V(t.range(-2, 4), requires_grad=True)
y = f(x)
y.backward()
print(x.grad)
# ----------------------------------------
tensor([ 0.,  0.,  0., 24., 12.,  8.,  6.])

变量的requires_grad属性默认为False，如果某一个节点requires_grad被设置为True，那么所有依赖于它的节点requires_grad都是True。

volatile=True是另一个很重要的标识，它能够将所有依赖于它的节点全部设为volatile=True，其优先级比requires_grad=True高。 volatile=True的节点不会求导，即使requires_grad=True，也无法进行反向传播。

对于不需要反向传播的情景(如inference，即测试推理时），该参数可实现一定程度的速度提升，并节省约一半的显存，因为其不需要分配空间保存梯度。

反向传播过程中非叶子节点的导数计算完之后即被清空。若想查看这些变量的梯度，有以下两种方法：

使用autograd.grad函数
使用hook

autograd.grad和hook方法都是很强大的工具。推荐使用hook方法，但是在实际使用中应尽量避免修改grad的值。

x = V(t.ones(3), requires_grad=True)
w = V(t.rand(3), requires_grad=True)
y = x * w
# y依赖于w，而w.reuires_grad=True
z = y.sum()
# 非叶子节点grad计算完之后自动清空
z.backward()
# 看之前的计算图，可以看出y是非叶子节点，所以y.grad是None
print(x.grad, w.grad, y.grad)
# -------------------------------------
tensor([0.0956, 0.1554, 0.7515]) tensor([1., 1., 1.]) 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的梯度(∂z/∂y)，隐式调用backward()
print(t.autograd.grad(z, y))
# ----------------------------
(tensor([1., 1., 1.]),)

# -------------------------------------
# 第二种方法：使用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的梯度：
 tensor([1., 1., 1.])

二、扩展autograd

目前，绝大多数函数都可以使用autograd实现反向求导，但是如果需要自己写一个复杂的函数，不支持自动反向求导怎么办？

答案是：写一个Function，实现它的前向传播和反向传播代码，Function对应于计算图中的矩形，它接收参数，计算并返回结果。

例子如下：

# 自定义Function需要继承autograd.Function
# 没有构造函数__init__，forward和backward函数都是静态方法
class Mul(Function):
    # forward函数的输入和输出都是tensor
    # backward函数的输入和输出都是variable
    @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

    # backward函数的输出和forward函数的输入一一对应
    # backward函数的输入和forward函数的输出一一对应
    # backward函数的grad_output参数即t.autograd.backward中的grad_variable
    @staticmethod
    def backward(ctx, grad_output):
        w, x = ctx.save_variables
        grad_w = grad_output * x
        # 如果某一个输入不需要求导，直接返回None
        # 例如forward中的输入参数x_requires_grad显然无法对它求导，直接返回None
        # 反向传播可能需要利用前向传播的某些之间结果
        # 在前向传播过程中需要保存中间结果，否则前向传播接收后这些对象即被释放
        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


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_tensors
        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不需要求导，中间过程还是会计算它的导数，但随后被清空
# print(x.grad, w.grad, b.grad)

# 调用MultiplyAdd.backward
# 输出grad_w, grad_x, grad_b
print(z.grad_fn.apply(V(t.ones(1))))
#----------------------------------------------
开始前向传播
type in forward <class 'torch.Tensor'>
开始反向传播
type in backward <class 'torch.Tensor'>
(tensor([1.]), tensor([0.6278], grad_fn=<MulBackward0>), tensor([1.]))
#----------------------------------------------------------------------------

虽然上述方法可以让autograd具有高阶求导功能，但也限制了Tensor的使用。因为autograd中反向传播的函数只能利用当前已经有的Variable操作。

为了更好的灵活性以及兼容旧版本的代码，PyTorch还提供了另外一种扩展autograd方法：利用装饰器@once_differentiable，能够在backward函数中自动将输入的variable提取成tensor，把计算结果的tensor自动封装成variable。有了这个特性，我们就能够很方便地使用numpy/scipy中的函数，操作不再局限于variable所支持的操作。但是这种做法只能求导一次，它打断了反向传播图，不再支持高阶求导。

下面举例说明如何利用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_tensors
        grad_x = output * (1 - output) * grad_output
        return grad_x


# 采用数值逼近的方式检验计算梯度的公式对不对
test_input = V(t.randn(3, 4), requires_grad=True)
print(t.autograd.gradcheck(Sigmoid.apply, (test_input.double(),), eps=1e-3))


def f_sigmoid(x):
    y = Sigmoid.apply(x)
    y.backward(t.ones(x.size()))

nonono吧

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Pytorch学习（4）-Autograd

Autograd（torch.autograd）：一套自动求导引擎，可以根据输入和前向传播过程自动构建计算图，并执行反向传播。计算图（Computation Graph）是现代深度学习框架（如PyTorch和Tensorflow等）的核心，它为自动求导算法——反向传播（Back Propogation）提供了理论支持。一、Variable PyTorch在autog...
复制链接

扫一扫

专栏目录