paddle 中的backward（）函数

已于 2022-10-01 18:25:15 修改
阅读量765 收藏 2
点赞数
分类专栏： paddlepaddle 文章标签： paddle
于 2022-10-01 18:24:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Vertira/article/details/127135813
版权

对！ 你没有看错，就是这个：

paddle.autograd.backward(tensors, grad_tensors=None, retain_graph=False)

官方注解：

计算给定的 Tensors 的反向梯度。（问题1，它这个梯度是怎么计算的？，先不管） 

参数

  • tensors (list[Tensor]) – 将要计算梯度的Tensors列表。 Tensors中不能包含有相同的Tensor。

  • grad_tensors (None|list[Tensor|None], 可选) – tensors 的初始梯度值。如果非None, 必须和 tensors 有相同的长度， 并且如果其中某一Tensor元素为None，则该初始梯度值为填充1.0 的默认值；如果是None，所有的 tensors 的初始梯度值为填充1.0 的默认值。默认值：None。

  • retain_graph (bool，可选) – 如果为False，反向计算图将被释放。如果在backward()之后继续添加OP， 需要设置为True，此时之前的反向计算图会保留。将其设置为False会更加节省内存。默认值：False。

返回

None

 官方实例：

import paddle
x = paddle.to_tensor([[1, 2], [3, 4]], dtype='float32', stop_gradient=False)
y = paddle.to_tensor([[3, 2], [3, 4]], dtype='float32')

grad_tensor1 = paddle.to_tensor([[1,2], [2, 3]], dtype='float32')
grad_tensor2 = paddle.to_tensor([[1,1], [1, 1]], dtype='float32')

z1 = paddle.matmul(x, y)
z2 = paddle.matmul(x, y)

paddle.autograd.backward([z1, z2], [grad_tensor1, grad_tensor2], True)
print(x.grad)
#[[12. 18.]
# [17. 25.]]

x.clear_grad()

paddle.autograd.backward([z1, z2], [grad_tensor1, None], True)
print(x.grad)
#[[12. 18.]
# [17. 25.]]

x.clear_grad()

paddle.autograd.backward([z1, z2])
print(x.grad)
#[[10. 14.]
# [10. 14.]]

 只看程序，没有报错，但是不知道这结果是怎么算出来的。

这里将一下求导，矩阵的求导（可以参考  矩阵论，高等数学二元函数求导）

 如果要求x的梯度，先求z的梯度，z的梯度在反馈中，就是这个paddle.autograd.backward（）中，如果这里面默认为none呢，上面官方已经数的很清楚，初始梯度1.0。

官方总归是官方，不实际测试一下，心里不踏实。简单实例测试一下

import paddle
# 下面用命令行执行了，测试
>>> x = paddle.to_tensor([1], dtype='float32', stop_gradient=False)
>>> y = paddle.to_tensor([2], dtype='float32')
>>> z = paddle.matmul(x, y)
>>> print("x: {}".format(x),"y: {}".format(y),"z: {}".format(z))
# 输出情况如下，
x: Tensor(shape=[1], dtype=float32, place=Place(gpu:0), stop_gradient=False,
       [1.]) 
y: Tensor(shape=[1], dtype=float32, place=Place(gpu:0), stop_gradient=True,
       [2.]) 
z: Tensor(shape=[1], dtype=float32, place=Place(gpu:0), stop_gradient=False,
       [2.])

# .在backward之前  看看它们的梯度什么情况 

>>> print("x.grad: {}".format(x.grad), "y.grad: {}".format(y.grad), "z.grad: {}".format(z.grad))
# 输出结果
x.grad: None y.grad: None z.grad: None

 全部都是None，不使用backward，这梯度不存在的

# 先调用backward
>>> paddle.autograd.backward(z, paddle.to_tensor([3], dtype='float32'))
# 再打印他们的梯度
>>> print("x.grad: {}".format(x.grad), "y.grad: {}".format(y.grad), "z.grad: {}".format(z.grad))
#结果如下

x.grad: Tensor(shape=[1], dtype=float32, place=Place(gpu:0), stop_gradient=False,
       [6.]) 
y.grad: None 
z.grad: Tensor(shape=[1], dtype=float32, place=Place(gpu:0), stop_gradient=False,
       [3.])
>>>

大家看到他们的梯度了吧，z.grad （提前设置好的初值，你也可以设置为None,试一试效果）和y矩阵就可以计算出x.grad，自己可以动手算一算

 推算的结果与 上面输出的结果一样，都是6

这里backword 不能重复调用计算，容易出错，

RuntimeError: (Unavailable) auto_0_ trying to backward through the same graph a second time, but this graph have already been freed. Please specify Tensor.backward(retain_graph=True) when calling backward at the first time.
  [Hint: Expected var->GradVarBase()->GraphIsFreed() == false, but received var->GradVarBase()->GraphIsFreed():1 != false:0.] (at /paddle/paddle/fluid/imperative/basic_engine.cc:74)

即使调用 clear_grad()，也无法保证重新计算backward()

x.clear_grad()
y.clear_grad()
z.clear_grad()

将autograd.backward函数中的retain_graph设置为TRUE。

paddle.autograd.backward(z, TT([3], dtype='float32'), retain_graph=True)

 此时就可以重复调用backward。

print("x.grad: {}".format(x.grad), "y.grad: {}".format(y.grad), "z.grad: {}".format(z.grad))

x.grad: Tensor(shape=[1], dtype=float32, place=CPUPlace, stop_gradient=False,
       [6.])
y.grad: None
z.grad: Tensor(shape=[1], dtype=float32, place=CPUPlace, stop_gradient=False,
       [3.])

第二次调用则

x.grad: Tensor(shape=[1], dtype=float32, place=CPUPlace, stop_gradient=False,
       [12.])
y.grad: None
z.grad: Tensor(shape=[1], dtype=float32, place=CPUPlace, stop_gradient=False,
       [3.])

实例二（接着上面的，我就不重复调用paddle包了）

>>> x = paddle.to_tensor([[1,2],[3,4]], dtype='float32', stop_gradient=False)
>>> y = paddle.to_tensor([[3,2],[3,4]], dtype='float32')
>>> z = paddle.matmul(x, y)
# 打印x,y,z的结果，可以手动计算一下z，看看和计算机计算的是否一样
>>> print("x: {}".format(x),"y: {}".format(y),"z: {}".format(z))
x: Tensor(shape=[2, 2], dtype=float32, place=Place(gpu:0), stop_gradient=False,
       [[1., 2.],
        [3., 4.]]) y: Tensor(shape=[2, 2], dtype=float32, place=Place(gpu:0), stop_gradient=True,
       [[3., 2.],
        [3., 4.]]) z: Tensor(shape=[2, 2], dtype=float32, place=Place(gpu:0), stop_gradient=False,
       [[9. , 10.],
        [21., 22.]])
# 下面调用了 backward
>>> paddle.autograd.backward(z, paddle.to_tensor([[1,2],[2,3]], dtype='float32'), retain_graph=True)
# 然后打印 x，y，z的梯度，z的初始梯度已经在上面初始化好了
>>> print("x.grad: {}".format(x.grad), "y.grad: {}".format(y.grad), "z.grad: {}".format(z.grad))
x.grad: Tensor(shape=[2, 2], dtype=float32, place=Place(gpu:0), stop_gradient=False,
       [[7. , 11.],
        [12., 18.]]) 
y.grad: None 
z.grad: Tensor(shape=[2, 2], dtype=float32, place=Place(gpu:0), stop_gradient=False,
       [[1., 2.],
        [2., 3.]])

从中可以看到，对于矩阵的自动反向梯度，所遵循的与标量基本是一样的。

>>> print("y*z.grad: {}".format(y.numpy().dot(z.grad.numpy())))
y*z.grad: [[ 7. 12.]
 [11. 18.]]
>>>


>>> x = paddle.to_tensor([[1,2],[3,4]], dtype='float32', stop_gradient=False)
>>> y = paddle.to_tensor([[3,2],[3,4]], dtype='float32')
>>> z1 = paddle.matmul(x, y)
>>> z2 = paddle.matmul(x, y)
>>> print("x: {}".format(x),"y: {}".format(y),"z: {}".format(z))
# 输出x，y，z的值
x: Tensor(shape=[2, 2], dtype=float32, place=Place(gpu:0), stop_gradient=False,
       [[1., 2.],
        [3., 4.]]) 
y: Tensor(shape=[2, 2], dtype=float32, place=Place(gpu:0), stop_gradient=True,
       [[3., 2.],
        [3., 4.]]) 
z: Tensor(shape=[2, 2], dtype=float32, place=Place(gpu:0), stop_gradient=False,
       [[9. , 10.],
        [21., 22.]])
#调用backward
>>> paddle.autograd.backward(z1, paddle.to_tensor([[1,2],[2,3]], dtype='float32'))
>>> paddle.autograd.backward(z2, paddle.to_tensor([[1,1],[1,1]], dtype='float32'))
#输出结果命令
>>> print("x.grad: {}".format(x.grad), "y.grad: {}".format(y.grad), "z.grad: {}".format(z.grad))
# 结果如下
x.grad: Tensor(shape=[2, 2], dtype=float32, place=Place(gpu:0), stop_gradient=False,
       [[12., 18.],
        [17., 25.]]) 
y.grad: None 
z.grad: Tensor(shape=[2, 2], dtype=float32, place=Place(gpu:0), stop_gradient=False,
       [[1., 2.],
        [2., 3.]])
>>>

检验x的梯度矩阵：

# 首先要 import numpy as np,避免报错

print("y*(z1+z2).grad: {}".format(y.numpy().dot((z1.grad+z2.grad).numpy())))



输出结果
>>> print("y*(z1+z2).grad: {}".format(y.numpy().dot((z1.grad+z2.grad).numpy())))
# 结果如下
y*(z1+z2).grad: [[12. 17.]
 [18. 25.]]
>>>

欢迎点赞收藏加关注

(18条消息) paddle中的自动求解梯度 ： autograd.backward_卓晴的博客-CSDN博客

Vertira
关注
专栏目录
8.paddlepaddle之loss损失函数自定义
kakaccys的博客
08-06 1622
损失函数是是用来估量你模型的预测值f(x)与真实值Y的不一致程度。不同的损失函数对模型拟合会有不同的效果，损失函数越小，一般模型的鲁棒性就越好。在深度学习中，我们经常需要调整损失函数来达到一些效果倾斜的目的。使用paddle内置的cross_entropy算子实现算法如上，一个二分类问题，我们即使用了交叉熵损失，又使用了均方损失，并赋予两个损失不同的权重。使用自定义损失函数训练也是相当简单的。在这里我们使用MNIST作为我们的数据集，并使用paddle内置的lenet进行训练，验证自定义损失函数。...
Paddle平台中搭建CNN模型，在训练模型中采用tensor类型
m0_48736242的博客
11-23 1675
在构建好CNN网络模型之后，接下来便是通过训练集来对模型进行训练： 下面是这次搭建“”美食分类”深度学习代码中，所用到的训练部分的代码： # CNN网络组建完毕之后，开始进行模型训练 print(train_parameters['class_dim']) print(train_parameters['label_dict']) model = CNN() optimizer = paddle.optimizer.Adam(learning_rate = train_parameters['l
paddle中的自动求解梯度 ： autograd.backward
TSINGHUAJOKING
12-22 1640
简 介： 对于paddle中的autograd.backward进行测试。并对集中常见到的函数进行测试。 关键词： gradient #mermaid-svg-kNKThUrgh5NxYdPf .label{font-family:'trebuchet ms', verdana, arial;font-family:var(--mermaid-font-family);fill:#333;color:#333}#mermaid-svg-kNKThUrgh5NxYdPf .label text{fill:.
pytorch 梯度计算相关内容总结
Andy.Wang的博客
04-24 1901
一、梯度计算准备工作 调用backward()函数前，叶子/非叶子节点的grad属性均为none，无论是否设置了requires_grad=True（叶子节点），或者调用了retain_grad()（非叶子节点），非叶子节点不能设置requires_grad=True，否则会报错：“RuntimeError: you can only change requires_grad flags of leaf variables.”）。 叶子/非叶子节点定义： 1.叶子节点： 所有requires_gra
paddle学习笔记（1）--clear_grad（）函数
weixin_52205764的博客
09-03 645
在梯度更新的时候，使用了一个clear_grad函数，当时在想，如果没有清空梯度会怎么样（其实我主要是想了解损失函数是怎么backforward的，但是那个代码调试到。这里面就是说如果不把之前的清空就会一直累加。
学习 backward
FULISANREN的博客
08-31 447
backward
Pytorch梯度检查 torch.autograd.gradcheck
hxxjxw的博客
04-20 4510
在编写好自己的 autograd function 后，可以利用gradcheck中提供的gradcheck和gradgradcheck接口，对数值算得的梯度和求导算得的梯度进行比较，以检查backward是否编写正确。 即用它可以check自己写的反向传播函数是否正确 这个函数可以自己计算通过数值法求得的梯度，然后和我们写的backward的结果比较 在下面的例子中，我们自己实现了Sigmoid函数，并利用gradcheck来检查backward的编写是否正确。 impo...
【paddle paddle-GNN】=0，1=python基础复习，paddle paddle快速入门
Patrick6789的博客
02-01 1560
python基础；导入库； 查看sample数据；创建x，y，y_pred(网络定义）；定义损失优化；训练模型，保存模型，评估模型；模型预测
paddle中如何显示train
05-24
# 前向计算和损失函数 pred = net(x) loss = paddle.nn.functional.mse_loss(pred, y) # 反向传播和优化器更新 loss.backward() opt.step() opt.clear_grad() # 打印训练日志 if batch_id % 100 == 0: ...
paddle中使用逻辑回归的代码 要图
最新发布
10-01
# 定义损失函数（交叉熵损失）和优化器（如SGD） loss_fn = paddle.nn.CrossEntropyLoss() optimizer = paddle.optimizer.SGD(learning_rate=0.01, parameters=logistic_regression.parameters()) # 训练步骤 for ...
pytorch tensor维度；tensor求导 backward、获取梯度grad；optimizer梯度更新zero_grad、step；获取loss值item
weixin_42357472的博客
12-06 2409
1、tensor维度 shape 3维： dim 0：高（黄色） dim 1：长（蓝色） dim 2：宽（绿色） 2、tensor求导 backward() import torch x=torch.tensor([[1.0,0.],[1.0,-1.0]],requires_grad=True) z=x.pow(2).sum() z.backward() x.grad
pytoch 设置了requires_grad=True，但是计算梯度(grad)为none
热门推荐
yinizhilianlove的博客
01-18 1万+
来源：AINLPer微信公众号（点击了解一下吧） 编辑: ShuYini 校稿: ShuYini 时间: 2019-8-16 代码示例 x_in=torch.tensor([[0, 1, 2], [3, 4, 5], [6, 7, 8]]).view((1,1,3,3)).type(torch.FloatTensor) y_out=torch.tensor([[19, 25],[37, 43]...
pytorch之backward(）
weixin_42797179的博客
02-10 498
torch.Tensor backward(gradient=None, retain_graph=None, create_graph=False) 使用链规则区分图表。如果张量是非标量的（即其数据具有多个元素）并且需要梯度，则该函数还需要指定gradient。它应该是匹配类型和位置的张量，它包含差分函数wrt的梯度self。 此函数在叶子中累积渐变 - 您可能需要在调用之前将它们归零。 参数：...
Pytorch中backward(retain_graph=True)的 retain_graph参数解释
今晚打老虎
02-28 1万+
每次 backward() 时，默认会把整个计算图free掉。一般情况下是每次迭代，只需一次 forward() 和一次backward() ,前向运算forward() 和反向传播backward()是成对存在的，一般一次backward()也是够用的。 但是不排除，由于自定义loss等的复杂性，需要一次forward()，多个不同loss的backward()来累积同一个网络的gra...
Pytorch多次自动求导
程序员小祝的博客
10-13 2218
在Pytorch中，通过调用 backward 我们可以进行一次自动求导，如果我们再调用一次 backward，会发现程序报错，没有办法再做一次。这是因为 PyTorch 默认做完一次自动求导之后，计算图就被丢弃了，所以两次自动求导需要手动设置一个东西，我们通过下面的小例子来说明。 import torch from torch.autograd import Variable ...
paddle2.0创建张量Tensor方法
weixin_46308523的博客
03-09 3894
Tensor 是paddle最基本的数据结构，paddle创建tensor有下面这些方式: 1.利用原有的数据创建tensor #假设原有数据为[3,4,5] import paddle x = paddle.to_tensor([1,2,3],dtype='float32') print(x) ##输出： Tensor(shape=[3], dtype=float32, place=CPUPlace, stop_gradient=True, [1., 2., 3.]) paddle的
texstudio消除大量红线问题
taxuewuhenxiaoer
03-13 952
options----------configure texstudio
Paddle中的自动微分功能测试
TSINGHUAJOKING
12-12 1081
  §01 自动微分 PaddlePaddle的神经网络核心是自动微分，本篇文章主要为你介绍如何使用飞桨的自动微分，以及飞桨的自动微分机制，帮助你更好的使用飞桨进行训练。 一、背景 神经网络是由节点和节点间的相互连接组成的。网络中每层的每个节点代表一种特定的函数，来对输入进行计算。每个函数都是由不同参数（权重w和偏置b）组成。神经网络训练的过程，就是不断让这些函数的参数进行学习、优化，以能够更好的处理后面输入的过程。 为了让神经网络的判断更加准确，首先需要有衡量效果的工具，于是损失函数应运而生.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值