导航：首页 > 开发技术 >

Pytorch中autograd的坑有哪些

发表于：2024-11-13 作者：千家信息网编辑

千家信息网最后更新 2024年11月13日，这篇文章主要介绍Pytorch中autograd的坑有哪些，文中介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们一定要看完！关于Variable和Tensor旧版本的Pytorch中，Variab

千家信息网最后更新 2024年11月13日Pytorch中autograd的坑有哪些

这篇文章主要介绍Pytorch中autograd的坑有哪些，文中介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们一定要看完！

关于Variable和Tensor

旧版本的Pytorch中，Variable是对Tensor的一个封装；在Pytorch大于v0.4的版本后，Varible和Tensor合并了，意味着Tensor可以像旧版本的Variable那样运行，当然新版本中Variable封装仍旧可以用，但是对Varieble操作返回的将是一个Tensor。

import torch as tfrom torch.autograd import Variable a = t.ones(3,requires_grad=True)print(type(a))#输出： a=Variable(a)print(type(a))#输出仍旧是： print(a.volatile)#输出：__main__:1: UserWarning: volatile was removed (Variable.volatile is always False)a.volatile=Trueprint(a.volatile)#输出：__main__:1: UserWarning: volatile was removed (Variable.volatile is always False)#现版本pytorch中移除了volatile这个属性，即volatile总是false

叶子节点leaf

对于那些不是任何函数(Function)的输出，由用户创建的节点称为叶子节点，叶子节点的grad_fn为None。

import torch as ta = t.ones(3,requires_grad=True)b = t.rand(3,requires_grad=True)a，a.is_leaf#输出：(tensor([1., 1., 1.], requires_grad=True), True)b#输出：(tensor([0.4254, 0.8763, 0.5901], requires_grad=True), True) c = a*bc.is_leaf#输出：False.说明c不是叶子节点a.grad_fn#输出：None.叶子节点的grad_fn为None.c.grad_fn#输出：

autograd操作

首先Tensor是默认不需要求导的，即requires_grad默认为False。

import torch as ta = t.ones(3)a.requires_grad#输出：False.Tensor默认不需要求导

如果某一个节点requires_grad被设置为True，那么所有依赖它的节点requires_grad都为True。

import torch as t a = t.ones(3)b = t.ones(3,requires_grad=True)b.requires_grad#输出：Truec = a + bc.requires_grad#输出：True.虽然c没有指定需要求导，然是c依赖于b，而b需要求导，所以c.requires_grad=True

只有scalar才能进行反向backward()操作，并且backward对于叶节点的grad的是累加的。当只进行计算操作不做backward，叶节点的grad不发生变化。

更正一下，并不是只有scaler才能进行backward操作，矩阵和向量也可以，只不过backward()中要添加对应维度的参数。

import torch as t a = t.ones(3,requires_grad=True)b = t.rand(3,requires_grad=True)a,b#输出：(tensor([1., 1., 1.], requires_grad=True), #tensor([0.9373, 0.0556, 0.6426], requires_grad=True))c = a*bc#输出：tensor([0.9373, 0.0556, 0.6426], grad_fn=)c.backward(retain_graph=True)#输出：RuntimeError: grad can be implicitly created only for scalar outputs#只有数值scalar才能进行backward操作d = c.sum()d.backward(retain_graph=True)#retain_graph=True是为了保存中间缓存，否则再次backward的时候会报错a.grad#输出：tensor([0.9373, 0.0556, 0.6426])b.grad#输出：tensor([1., 1., 1.])#backward后a和b的grad产生了数值e = c.sum()e.backward(retain_graph=True)b.grad#输出：tensor([2., 2., 2.]).b的grad进行了两次backward后进行了累加.f = c.sum()b.grad#输出：tensor([2., 2., 2.])#只进行计算不backward，梯度不更新

Tensor.data和Tensor.detach()

如过tensor的数值需要参与计算又不想参与到计算图的更新中，计算的时候可以用tensor.data，这样既能利用tensor的数值，又不会更新梯度。

import torch as t a = t.ones(3,4,requires_grad=True)b = t.rand(3,4,requires_grad=True) a.data.requires_grad#输出：False. a.data独立于计算图之外 c = a.data * b.datad = c.sum()d.backward()#输出：RuntimeError: element 0 of tensors does not require grad and does not have a grad_fn#因为独立于计算图之外，requires_grad = False所以不能backward()

当tensor.data被修改的时候，tensor也会同步的被修改，此时用该tensor进行计算并backward的时候梯度的值就不再准确了，因为tensor已经被修改了！

import torch as t a = t.ones(3,4,requires_grad=True)b = t.rand(3,4,requires_grad=True)c = a*bd = c.sum()a.data.sigmoid_()#输出：tensor([[0.7311, 0.7311, 0.7311, 0.7311],#        [0.7311, 0.7311, 0.7311, 0.7311],#        [0.7311, 0.7311, 0.7311, 0.7311]])#虽然对a.data进行sigmoid操作，但是a的值已经被修改了.d.backward()b.grad#输出：tensor([[0.7311, 0.7311, 0.7311, 0.7311],#        [0.7311, 0.7311, 0.7311, 0.7311],#        [0.7311, 0.7311, 0.7311, 0.7311]])#b的grad不准了，本来应该都是1！

为了避免因为对tensor.data修改导致grad变化的情况，可以利用tensor.detach，同样可以保证tensor不参与到计算图当中，但是当tensor的值被改变的时候，再进行backward就会报错而不会有先前的因为tensor的值被改变而导致不准的情况了。

import torch as t a = t.ones(3,4,requires_grad=True)b = t.rand(3,4,requires_grad=True)c = a * bd = c.sum()a_ = a.detach()a_.sigmoid_()a#输出：tensor([[0.7311, 0.7311, 0.7311, 0.7311],#        [0.7311, 0.7311, 0.7311, 0.7311],#        [0.7311, 0.7311, 0.7311, 0.7311]], requires_grad=True)#a的值已经发生了改变d.backward()#报错：RuntimeError: one of the variables needed for gradient computation has been modified by an inplace operation#因为a的值被修改了，所以不能再进行backward

推荐用tensor.detach的方式而不是tensor.data的方式，因为这样更保险！

autograd.grad和hook

在计算的时候有时候我们可能会用到非叶节点的grad，但是非叶节点的grad在backward之后就会被自动清空：

import torch as t a = t.ones(3,4,requires_grad=True)b = t.rand(3,4,requires_grad=True)c = a*bd = c.sum()d.backward()a.grad#输出：tensor([[0.3114, 0.3017, 0.8461, 0.6899],#        [0.3878, 0.8712, 0.2406, 0.7396],#        [0.6369, 0.0907, 0.4984, 0.5058]])c.grad#输出：None#c为非叶子节点，计算后被清空

可以用autograd.grad和hook来处理这种情况：

#利用autograd.grad获取中间节点梯度t.autograd.grad(d,c)#输出：(tensor([[1., 1., 1., 1.],#        [1., 1., 1., 1.],#        [1., 1., 1., 1.]]),)#利用hook获取中间节点梯度import torch as t a = t.ones(3,4,requires_grad=True)b = t.rand(3,4,requires_grad=True)c = a*bd = c.sum() def print_grad(grad):    print(grad) #给c注册hookc_hook = c.register_hook(print_grad) d.backward()#输出：tensor([[1., 1., 1., 1.],#        [1., 1., 1., 1.],#        [1., 1., 1., 1.]]) #移除钩子c_hook.remove()

补充：关于Pytorch中autograd和backward的一些笔记

1 Tensor

Pytorch中所有的计算其实都可以回归到Tensor上，所以有必要重新认识一下Tensor。

如果我们需要计算某个Tensor的导数，那么我们需要设置其.requires_grad属性为True。为方便说明，在本文中对于这种我们自己定义的变量，我们称之为叶子节点(leaf nodes)，而基于叶子节点得到的中间或最终变量则可称之为结果节点。

另外一个Tensor中通常会记录如下图中所示的属性：

data: 即存储的数据信息

requires_grad: 设置为True则表示该 Tensor 需要求导

grad: 该 Tensor 的梯度值，每次在计算 backward 时都需要将前一时刻的梯度归零，否则梯度值会一直累加，这个会在后面讲到。

grad_fn: 叶子节点通常为 None，只有结果节点的 grad_fn 才有效，用于指示梯度函数是哪种类型。

is_leaf: 用来指示该 Tensor 是否是叶子节点。

举例：

x = torch.rand(3, requires_grad=True)y = x ** 2z = x + xprint(    'x requires grad: {},  is leaf: {},  grad: {},  grad_fn: {}.'        .format(x.requires_grad, x.is_leaf, x.grad, x.grad_fn))print(    'y requires grad: {},  is leaf: {},  grad: {},  grad_fn: {}.'        .format(y.requires_grad, y.is_leaf, y.grad, y.grad_fn))print(    'z requires grad: {},  is leaf: {},  grad: {},  grad_fn: {}.'        .format(z.requires_grad, z.is_leaf, z.grad, z.grad_fn))

运行结果：

x requires grad: True, is leaf: True, grad: None, grad_fn: None.
y requires grad: True, is leaf: False, grad: None, grad_fn: .
z requires grad: True, is leaf: False, grad: None, grad_fn: .

2 torch.autograd.backward

如下代码：

x = torch.tensor(1.0, requires_grad=True)y = torch.tensor(2.0, requires_grad=True)z = x**2+yz.backward()print(z, x.grad, y.grad)>>> tensor(3., grad_fn=) tensor(2.) tensor(1.)

当 z 是一个标量，当调用它的 backward 方法后会根据链式法则自动计算出叶子节点的梯度值。

但是如果遇到 z 是一个向量或者是一个矩阵的情况，这个时候又该怎么计算梯度呢？这种情况我们需要定义grad_tensor来计算矩阵的梯度。

在介绍为什么使用之前我们先看一下源代码中backward的接口是如何定义的：

torch.autograd.backward(        tensors,         grad_tensors=None,         retain_graph=None,         create_graph=False,         grad_variables=None)

tensor: 用于计算梯度的 tensor。也就是说这两种方式是等价的：torch.autograd.backward(z) == z.backward()

grad_tensors: 在计算非标量的梯度时会用到。他其实也是一个tensor，它的shape一般需要和前面的tensor保持一致。

retain_graph: 通常在调用一次 backward 后，pytorch 会自动把计算图销毁，所以要想对某个变量重复调用 backward，则需要将该参数设置为True

create_graph: 当设置为True的时候可以用来计算更高阶的梯度

grad_variables: 这个官方说法是 grad_variables' is deprecated. Use 'grad_tensors' instead. 也就是说这个参数后面版本中应该会丢弃，直接使用grad_tensors就好了。

pytorch设计了grad_tensors这么一个参数。它的作用相当于"权重"。

先看一个例子：

x = torch.ones(2,requires_grad=True)z = x + 2z.backward()>>> ...RuntimeError: grad can be implicitly created only for scalar outputs

上面的报错信息意思是只有对标量输出它才会计算梯度，而求一个矩阵对另一矩阵的导数束手无策。

x = torch.ones(2,requires_grad=True)z = x + 2z.sum().backward()print(x.grad)>>> tensor([1., 1.])

而grad_tensors这个参数就扮演了帮助求和的作用。

换句话说，就是对 Z 和一个权重张量grad_tensors进行 hadamard product 后求和。这也是 grad_tensors 需要与传入的 tensor 大小一致的原因。

x = torch.ones(2,requires_grad=True)z = x + 2z.backward(torch.ones_like(z)) # grad_tensors需要与输入tensor大小一致print(x.grad)>>> tensor([1., 1.])

3 torch.autograd.grad

torch.autograd.grad(        outputs,         inputs,         grad_outputs=None,         retain_graph=None,         create_graph=False,         only_inputs=True,         allow_unused=False)

看了前面的内容后再看这个函数就很好理解了，各参数作用如下：

outputs: 结果节点，即被求导数

inputs: 叶子节点

grad_outputs: 类似于backward方法中的grad_tensors

retain_graph: 同上

create_graph: 同上

only_inputs: 默认为True，如果为True，则只会返回指定input的梯度值。若为False，则会计算所有叶子节点的梯度，并且将计算得到的梯度累加到各自的.grad属性上去。

allow_unused: 默认为False, 即必须要指定input,如果没有指定的话则报错。

注意该函数返回的是 tuple 类型。

以上是"Pytorch中autograd的坑有哪些"这篇文章的所有内容，感谢各位的阅读！希望分享的内容对大家有帮助，更多相关知识，欢迎关注行业资讯频道！

很赞哦！