[Pytorch系列-21]：Pytorch基础 - 全自动链式求导backward

最新推荐文章于 2023-05-02 17:43:12 发布
最新推荐文章于 2023-05-02 17:43:12 发布
阅读量1.2k 收藏 14
点赞数 5
分类专栏： 人工智能-PyTorch 人工智能-深度学习 文章标签： pytorch python 深度学习 链式求导
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HiWangWenBing/article/details/120298291
版权

作者主页(文火冰糖的硅基工坊)：文火冰糖（王文兵）的博客_文火冰糖的硅基工坊_CSDN博客

本文网址：[Pytorch系列-21]：Pytorch基础 - 全自动链式求导backward_文火冰糖（王文兵）的博客-CSDN博客

目录

第一章 Pytorch自动求导的两种方法

1.1 半自动

1.2 全自动

第2章 自动求导的基本原理

2.1 自动链式求导的基本原理

2.2 前向计算数据流图与反向链式求导数据流图

2.3 万能的数值求导的方法

2.4 自动求导关键代码的隐含操作！！！！

 第3章 Variable对象的全自动链式求导案例

3.1 定义支持全自动求导的 Variable对象

3.2 一元函数全自动求导

3.3 二元函数全自动求导案例

3.4 梯度的自动累加现象

3.5 梯度的清零操作：data.zero_()

3.6 数据图的手工重选构建

3.7 全自动求导的应用：梯度下降迭代

第4章 Tensor对象的全自动该链式求导拆解

4.1 环境准备

4.2 Variable对象与Tensor对象的统一

4.3 定义支持自动求导的tensor

4.4 定义复合函数

4.5 全自动求导（求梯度）

4.6 指定函数链自动求导

4.7 用半自动求导分解全自动求导过程

第一章 Pytorch自动求导的两种方法

Pytorch有两种方式进行自动求导。

1.1 半自动

这种方法，使用torch的全局函数，需要指定求导的函数以及相应的偏导数对象。

步骤1：y = wx + b

步骤2：dy = torch.autograd.grad(y, [w,b], retain_graph=True)

备注：这种方式获得的梯度，直接通过函数返回，并没有存放到w，b的tensor中。

详见：

[Pytorch系列-20]：Pytorch基础 - Varialbe变量的手工求导和半自动链式求导torch.autograd.grad_文火冰糖（王文兵）的博客-CSDN博客

1.2 全自动

这种方法，使用输出tensor的成员函数，不需要指定偏导数对象，它对函数中所有的表示了requires_grad=True的参数，自动全部求导。

步骤1：y = wx + b

步骤2：y.backward(retain_graph=True)

备注：这种方式获得的梯度，自动存放在w和b的tensor中。

第2章 自动求导的基本原理

2.1 自动链式求导的基本原理

2.2 前向计算数据流图与反向链式求导数据流图

2.3 万能的数值求导的方法

[数值计算-19]：万能的任意函数的数值求导数方法_文火冰糖（王文兵）的博客-CSDN博客

2.4 自动求导关键代码的隐含操作！！！！

关键代码1（自动构建计算图）：y = wx + b

  • 自动创建前向传播的动态计算图
  • 自动创建反向传播的动态计算图和上下文

关键代码2（半自动求导）：dy = torch.autograd.grad(y, [w,b], retain_graph=True) 

  • 只对计算图中，指定的变量列表[ ] 进行求导
  • 自动求导的最终输出结果，保放在dy中。
  • 自动求导的中间输出结果，保存在y所指定的动态计算图以及自动求导的上下文中。
  • 本次自动求导结束后，如果retain_graph=True，则保留、不释放由y指定的动态计算图以及上下文。
  • 本次自动求导结束后，如果retain_graph=False，自动释放由y指定的动态计算图以及上下文。

关键代码3（全自动求导）：y.backward(retain_graph=True)  

  • 对计算图中，标志位requires_grad = True的所有tensor/variable进行搜索并自动求导。
  • 自动求导的最终输出结果，自动保放tensor/variabl各自对应的grad属性中。
  • 自动求导的中间输出结果，保存在y所指定的动态计算图以及自动求导的上下文中。
  • 本次自动求导结束后，如果retain_graph=True，则保留、不释放由y指定的动态计算图以及上下文。
  • 本次自动求导结束后，如果retain_graph=False，自动释放由y指定的动态计算图以及上下文。

 第3章 Variable对象的全自动链式求导案例

3.1 定义支持全自动求导的 Variable对象

print("自变量：张量tensor => 自变量值")
x_variable =  Variable(torch.Tensor([0]), requires_grad = True)
print("x_variable =", x_variable)

自变量：张量tensor => 自变量值 x_variable = tensor([0.], requires_grad=True)

3.2 一元函数全自动求导

# 一元函数全自动求导
# 自动求导只能在某一个点,如一元点(x）处一次自动求导，不能对一个点序列进行多次的连续自动求导
print("自变量：张量tensor => 自变量值")
x_variable =  Variable(torch.Tensor([0]), requires_grad = True)
print("x_variable =", x_variable)

print("\n因变量：一元原函数     => 函数值")
y_variable = x_variable ** 2 + 1
print("y_variable =", y_variable)

print("\n因变量：自动求导前     => 导数值")
print("x_variable =", x_variable)
print("x_variable.grad =", x_variable.grad)

print("\n对原函数的所有变量分别自动求偏导（通过系统提供的backward（）成员函数）")
y_variable.backward()  

print("\n因变量：自动求导后     => 导数值 ")
print("x_variable =", x_variable)
print("x_variable.grad =", x_variable.grad)
自变量：张量tensor => 自变量值
x_variable = tensor([0.], requires_grad=True)

因变量：一元原函数     => 函数值
y_variable = tensor([1.], grad_fn=<AddBackward0>)

因变量：自动求导前     => 导数值
x_variable = tensor([0.], requires_grad=True)
x_variable.grad = None

对原函数的所有变量分别自动求偏导（通过系统提供的backward（）成员函数）

因变量：自动求导后     => 导数值 
x_variable = tensor([0.], requires_grad=True)
x_variable.grad = tensor([0.])

3.3 二元函数全自动求导案例

# 二元函数全自动求导
# 自动求导只能在某一个点,如二元点(x1,x2）处一次自动求导，不能对一个点序列进行多次的连续自动求导
print("自变量：张量tensor => 自变量值")
x_variable1 =  Variable(torch.Tensor([-1]), requires_grad = True)
x_variable2 =  Variable(torch.Tensor([1]), requires_grad = True)
print("x_variable1 =", x_variable1)
print("x_variable2 =", x_variable2)

print("\n因变量：二元原函数     => 函数值")
y_variable = x_variable1**2 +  x_variable2**2 + 1
print("y_variable =", y_variable)

print("\n因变量：自动求导前     => 导数值")
print("x_variable1 =", x_variable1)
print("x_variable1.grad =", x_variable1.grad)
print("x_variable2 =", x_variable2)
print("x_variable2.grad =", x_variable2.grad)

print("\n对原函数的所有变量分别自动求偏导（通过系统提供的backward（）成员函数）")
y_variable.backward()  

print("\n因变量：自动求导后     => 导数值 ")
#获取导数值
print("x_variable1 =", x_variable1)
print("x_variable1.grad =", x_variable1.grad)
print("x_variable2 =", x_variable2)
print("x_variable2.grad =", x_variable2.grad)

自变量：张量tensor => 自变量值
x_variable1 = tensor([-1.], requires_grad=True)
x_variable2 = tensor([1.], requires_grad=True)

因变量：二元原函数     => 函数值
y_variable = tensor([3.], grad_fn=<AddBackward0>)

因变量：自动求导前     => 导数值
x_variable1 = tensor([-1.], requires_grad=True)
x_variable1.grad = None
x_variable2 = tensor([1.], requires_grad=True)
x_variable2.grad = None

对原函数的所有变量分别自动求偏导（通过系统提供的backward（）成员函数）

因变量：自动求导后     => 导数值 
x_variable1 = tensor([-1.], requires_grad=True)
x_variable1.grad = tensor([-2.])
x_variable2 = tensor([1.], requires_grad=True)
x_variable2.grad = tensor([2.])

3.4 梯度的自动累加现象

Pytorch全自动求导backward，有一个很奇特的现象：即每一次计算，都会在原有的梯度的基础之上，叠加上最新的导数值，导致每个参数变的梯度值不断的累加，如下所示：

# 梯度自动累加：即使点的位置没有变化，每次计算出来的梯度值是累加的。
x_variable =  Variable(torch.Tensor([1]), requires_grad = True)
print("x_variable =", x_variable)
print("x_variable.grad = ", x_variable.grad)
y_variable = x_variable ** 2 + 1
print("y_variable=", y_variable)

# 自动求导
count = 5
while(count):
    print("\n", count)

    y_variable.backward(retain_graph=True)  
    
    y_variable = x_variable ** 2 + 1
    print("x_variable=", x_variable)
    print("y_variable=", y_variable)
    print("x_variable.grad = ", x_variable.grad)
    
    count = count - 1
x_variable = tensor([1.], requires_grad=True)
x_variable.grad =  None
y_variable= tensor([2.], grad_fn=<AddBackward0>)

 5
x_variable= tensor([1.], requires_grad=True)
y_variable= tensor([2.], grad_fn=<AddBackward0>)
x_variable.grad =  tensor([2.])

 4
x_variable= tensor([1.], requires_grad=True)
y_variable= tensor([2.], grad_fn=<AddBackward0>)
x_variable.grad =  tensor([4.])

 3
x_variable= tensor([1.], requires_grad=True)
y_variable= tensor([2.], grad_fn=<AddBackward0>)
x_variable.grad =  tensor([6.])

 2
x_variable= tensor([1.], requires_grad=True)
y_variable= tensor([2.], grad_fn=<AddBackward0>)
x_variable.grad =  tensor([8.])

 1
x_variable= tensor([1.], requires_grad=True)
y_variable= tensor([2.], grad_fn=<AddBackward0>)
x_variable.grad =  tensor([10.])


3.5 梯度的清零操作：data.zero_()

在实际使用中，梯度的自动累加功能，并不是我们所期望的，这就需要在每次全自动求导后，

要对梯度进行手工清零：data.zero_()。

# 梯度自动累加 
x_variable =  Variable(torch.Tensor([1]), requires_grad = True)
print("x_variable =", x_variable)
print("x_variable.grad = ", x_variable.grad)
y_variable = x_variable ** 2 + 1
print("y_variable=", y_variable)

# 自动求导
count = 5
while(count):
    print("\n", count)

    y_variable.backward(retain_graph=True)  
    
    y_variable = x_variable ** 2 + 1
    print("x_variable=", x_variable)
    print("y_variable=", y_variable)
    print("x_variable.grad = ", x_variable.grad)
    
    count = count - 1
    
    #清除x_variable以前的梯度值
    x_variable.grad.data.zero_()
x_variable = tensor([1.], requires_grad=True)
x_variable.grad =  None
y_variable= tensor([2.], grad_fn=<AddBackward0>)

 5
x_variable= tensor([1.], requires_grad=True)
y_variable= tensor([2.], grad_fn=<AddBackward0>)
x_variable.grad =  tensor([2.])

 4
x_variable= tensor([1.], requires_grad=True)
y_variable= tensor([2.], grad_fn=<AddBackward0>)
x_variable.grad =  tensor([2.])

 3
x_variable= tensor([1.], requires_grad=True)
y_variable= tensor([2.], grad_fn=<AddBackward0>)
x_variable.grad =  tensor([2.])

 2
x_variable= tensor([1.], requires_grad=True)
y_variable= tensor([2.], grad_fn=<AddBackward0>)
x_variable.grad =  tensor([2.])

 1
x_variable= tensor([1.], requires_grad=True)
y_variable= tensor([2.], grad_fn=<AddBackward0>)
x_variable.grad =  tensor([2.])

3.6 数据图的手工重选构建

在上面的案例中，每次进行全自动求导时，都会设置retain_graph=True，如：

y_variable.backward(retain_graph=True)  

设置该标志位的原因是：Pytorch是动态构建数据图，每一次被调用，执行自动求导前，都会重选构建反向求导的数据图和上下文，执行完自动求导后，都会释放相应数据图和上下文。

为了能够进行多次迭代求导，执行万一次自动求导后，需要保留数据图和上下文，这就是这个标志位的作用。但这种方法的缺点是，最后的数据图和上下文需要手工释放。

为了克服上述缺点，也可以有采用另一种方法：

在每次自动求导前，手工构建数据图和上下文，自动求导后，由backward自动释放。

    # 重选构建数据图和自动求导的上下文
    y_variable = x_variable ** 2 + 1 
    
    # 执行自动求导，自动释放自动求导的上下文
    y_variable.backward()  
    

其作用与y_variable.backward(retain_graph=True)  是相似的，但程序迭代后，不需要手工释放自动求导的上下文。

详细代码如下：

# 梯度自动累加 
x_variable =  Variable(torch.Tensor([1]), requires_grad = True)
print("x_variable =", x_variable)
print("x_variable.grad = ", x_variable.grad)
y_variable = x_variable ** 2 + 1
print("y_variable=", y_variable)

# 自动求导
count = 5
while(count):
    print("\n", count)
    
    # 重选构建数据图和自动求导的上下文
    y_variable = x_variable ** 2 + 1 
    
    # 执行自动求导，自动释放自动求导的上下文
    y_variable.backward()  
    
    y_variable = x_variable ** 2 + 1
    print("x_variable=", x_variable)
    print("y_variable=", y_variable)
    print("x_variable.grad = ", x_variable.grad)
    
    count = count - 1
    
    #清除x_variable以前的梯度值
    x_variable.grad.data.zero_()
x_variable = tensor([1.], requires_grad=True)
x_variable.grad =  None
y_variable= tensor([2.], grad_fn=<AddBackward0>)

 5
x_variable= tensor([1.], requires_grad=True)
y_variable= tensor([2.], grad_fn=<AddBackward0>)
x_variable.grad =  tensor([2.])

 4
x_variable= tensor([1.], requires_grad=True)
y_variable= tensor([2.], grad_fn=<AddBackward0>)
x_variable.grad =  tensor([2.])

 3
x_variable= tensor([1.], requires_grad=True)
y_variable= tensor([2.], grad_fn=<AddBackward0>)
x_variable.grad =  tensor([2.])

 2
x_variable= tensor([1.], requires_grad=True)
y_variable= tensor([2.], grad_fn=<AddBackward0>)
x_variable.grad =  tensor([2.])

 1
x_variable= tensor([1.], requires_grad=True)
y_variable= tensor([2.], grad_fn=<AddBackward0>)
x_variable.grad =  tensor([2.])

3.7 全自动求导的应用：梯度下降迭代

（1）迭代过程

print("定义迭代的自变量参数以及初始值")
x1_variable =  Variable(torch.Tensor([2]), requires_grad = True)
x2_variable =  Variable(torch.Tensor([2]), requires_grad = True)
print("x1_variable =", x1_variable)
print("x2_variable =", x2_variable)

# 定义原函数
def loss_fun(x1, x2):
    y = x1**2 + x2**2 + 1
    return (y)

# 获取y初始值
y_variable = loss_fun (x1_variable, x2_variable)
print("y_variable   =", y_variable)

#定义学习率
learnning_rate = 0.1

#定义迭代次数
iterations = 30

#定义存放迭代过程数据的列表
x1_data = []
x2_data = []
y_data  = []

# 保存初始值：需转换成numpy，便于matlab可视化
x1_data.append(x1_variable.data.numpy())
x2_data.append(x2_variable.data.numpy())
y_data.append(y_variable.data.numpy())
print("\n初始点：", x1_data[0], x2_data[0], y_data[0])


while(iterations):    
    # 对任意函数在当前位置求导数
    y_variable.backward()
    
    # 梯度下降迭代
    x1_variable.data = x1_variable.data - learnning_rate * x1_variable.grad
    x2_variable.data = x2_variable.data - learnning_rate * x2_variable.grad
    
    #计算当前最新的y值
    y_variable = loss_fun (x1_variable, x2_variable)
    
    #保存数据
    x1_data.append(x1_variable.data.numpy())
    x2_data.append(x2_variable.data.numpy())
    y_data.append(y_variable.data.numpy())
    
    #下次迭代做准备
    iterations = iterations -1
    x1_variable.grad.data.zero_()
    x2_variable.grad.data.zero_()
    
print("\n迭代后的数据:")
print("x1_variable =", x1_variable.data.numpy())
print("x2_variable =", x2_variable.data.numpy())
print("y_variable   =", y_variable.data.numpy())

定义迭代的自变量参数以及初始值
x1_variable = tensor([2.], requires_grad=True)
x2_variable = tensor([2.], requires_grad=True)
y_variable   = tensor([9.], grad_fn=<AddBackward0>)

初始点： [2.] [2.] [9.]

迭代后的数据:
x1_variable = [0.00247588]
x2_variable = [0.00247588]
y_variable   = [1.0000123]

（2）迭代过程的可视化

fig = plt.figure()
ax1 = plt.axes(projection='3d')        #使用matplotlib.pyplot创建坐标系
ax1.scatter3D(x1_data, x2_data, y_data, cmap='Blues')  #绘制三维散点图
plt.show()

（3）原函数的可视化

# 可视化原函数的图形
x1_sample = np.arange(-10, 10, 1)
x2_sample = np.arange(-10, 10, 1)    #X,Y的范围

x1_grid, x2_grid = np.meshgrid(x1_sample,x2_sample)      #空间的点序列转换成网格点

y_grid = loss_fun(x1_grid,x2_grid)                 #生成z轴的网格数据

figure = plt.figure()
ax1 = plt.axes(projection='3d')             #创建三维坐标系

ax1.plot_surface(x1_grid, x2_grid, y_grid ,rstride=1,cstride=1,cmap='rainbow')

第4章 Tensor对象的全自动该链式求导拆解

4.1 环境准备

#环境准备
import numpy as np
import math
import matplotlib.pyplot as plt
%matplotlib inline
import torch
from torch.autograd import Variable

print("Hello World")
print(torch.__version__)
print(torch.cuda.is_available())

4.2 Variable对象与Tensor对象的统一

print("定义样本tensor")
x = torch.Tensor([2.])
y = torch.Tensor([2.])

print("定义参数tensor")
w = torch.Tensor([1.])
b = torch.tensor([1.], requires_grad=True)  # 使能自动梯度计算方法1
print(x)
print(w)
print(b)

print("\n使能tensor的梯度属性，替代variable变量")
w.requires_grad_()                         # 使能自动梯度计算方法2
print(w)
print(b)

print("\n生成loss函数的动态数据流图")
f_pred = w * x + b
loss = (f_pred - y)**2

print("\n自动计算梯度")
torch.autograd.grad(loss, [w,b], retain_graph=True)
print(loss)
print(w.grad)   #autograd.grad的计算结果被函数返回，并为存放到w和b的grad参数中！！！
print(b.grad)

print("\n生成loss函数的动态数据流图")
f_pred = w * x + b
loss = (f_pred - y)**2
print("自动反向求梯度")
loss.backward()  
print(loss)
print(w.grad)
print(b.grad)
定义样本tensor
定义参数tensor
tensor([2.])
tensor([1.])
tensor([1.], requires_grad=True)

使能tensor的梯度属性，替代variable变量
tensor([1.], requires_grad=True)
tensor([1.], requires_grad=True)

生成loss函数的动态数据流图

自动计算梯度
tensor([1.], grad_fn=<PowBackward0>)
None
None

生成loss函数的动态数据流图
自动反向求梯度
tensor([1.], grad_fn=<PowBackward0>)
tensor([4.])
tensor([2.])
​

4.3 定义支持自动求导的tensor

print("定义样本数据")
x = torch.Tensor([1])

print("\n定义参数tensor")
w2 = torch.tensor([4.], requires_grad=True)
b2 = torch.tensor([5.], requires_grad=True)
w1 = torch.tensor([2.], requires_grad=True)
b1 = torch.tensor([3.], requires_grad=True)
print("w2=", w2)
print("b2=", b2)
print("w1=", w1)
print("b1=", b1)

定义样本数据

定义参数tensor
w2= tensor([4.], requires_grad=True)
b2= tensor([5.], requires_grad=True)
w1= tensor([2.], requires_grad=True)
b1= tensor([3.], requires_grad=True)

备注，在最新的pytorch中，Varialbe对象以及与tensor对象进行完美的整合与统一。

因此使用tensor对象来替代Varialbe对象。

4.4 定义复合函数

print("\n定义一级函数")
y1 = w1 * x  + b1
print("y1=", y1)

print("\n定义二级函数")
y2 = w2 * y1 + b2
print("y2=", y2)

定义一级函数
y1= tensor([5.], grad_fn=<AddBackward0>)

定义二级函数
y2= tensor([25.], grad_fn=<AddBackward0>)

4.5 全自动求导（求梯度）

print("\n(1)全过程自动链式求导")
y2.backward(retain_graph=True)
print("w1.grad=", w1.grad)
print("b1.grad=", b1.grad)
print("w2.grad=", w2.grad)
print("b2.grad=", b2.grad)

(1)全过程自动链式求导
w1.grad= tensor([4.])
b1.grad= tensor([4.])
w2.grad= tensor([5.])
b2.grad= tensor([1.])

4.6 指定函数链自动求导

print("\n(2)指定链自动链式求导")
dy2_dw1 = torch.autograd.grad(y2, [w1], retain_graph=True)[0]
dy2_db1 = torch.autograd.grad(y2, [b1], retain_graph=True)[0]
dy2_dw2 = torch.autograd.grad(y2, [w2], retain_graph=True)[0]
dy2_db2 = torch.autograd.grad(y2, [b2], retain_graph=True)[0]
print("dy2_dw1=", dy2_dw1)
print("dy2_db1=", dy2_db1)
print("dy2_dw2=", dy2_dw2)
print("dy2_db2=", dy2_db2)

(2)指定链自动链式求导
dy2_dw1= tensor([4.])
dy2_db1= tensor([4.])
dy2_dw2= tensor([5.])
dy2_db2= tensor([1.])

4.7 用半自动求导分解全自动求导过程

print("\n(3)分步式自动链式求导")
dy2_dw2 = torch.autograd.grad(y2, [w2], retain_graph=True)[0]
dy2_db2 = torch.autograd.grad(y2, [b2], retain_graph=True)[0]
print("dy2_dw2=", dy2_dw2)
print("dy2_db2=", dy2_db2)
print("")

dy2_dy1 = torch.autograd.grad(y2, [y1], retain_graph=True)[0]
print("dy2_dy1=", dy2_dy1)
dy1_dw1 = torch.autograd.grad(y1, [w1], retain_graph=True)[0]
dy1_db1 = torch.autograd.grad(y1, [b1], retain_graph=True)[0]
print("dy1_dw1=", dy1_dw1)
print("dy1_db1=", dy1_db1)
print("")
print("dy2_dw1=", dy2_dy1 * dy1_dw1)
print("dy2_db1=", dy2_dy1 * dy1_db1)
(3)分步式自动链式求导
dy2_dw2= tensor([5.])
dy2_db2= tensor([1.])

dy2_dy1= tensor([4.])
dy1_dw1= tensor([1.])
dy1_db1= tensor([1.])

dy2_dw1= tensor([4.])
dy2_db1= tensor([4.])

 作者主页(文火冰糖的硅基工坊)：文火冰糖（王文兵）的博客_文火冰糖的硅基工坊_CSDN博客

本文网址：[Pytorch系列-21]：Pytorch基础 - 全自动链式求导backward_文火冰糖（王文兵）的博客-CSDN博客

文火冰糖的硅基工坊
关注
  • 5
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
深度ritz方法求解高维泊松方程
forrestguang的博客
05-03 1058
此时样本数目过于庞大，一定会导致训练特别耗时。为此可以采取的策略是，每训练一定次数，就重新撒点，对于边界点也是类似的。举例子，如果我们在区域内部采集1000个样本点，扩散到每个维度，那么每个维度最多采集了2个点，因为。，这样导致样本数目过小，如果一开始每个维度采集20个点，那么需要采集的样本数目就是。长度因子需要满足在边界上取值为0，在内部区域恒大于0.，利用netg训练边界数据，构建均方误差函数，训练完以后netg满足。表示区域维度，这里我们使用PFNN算法来求解这个问题。即可，这个思想非常简单。
基于pytorch的PINN求解含时间项的泊松方程
forrestguang的博客
05-06 3016
方程引出 ut−uxx−uyy−uzz=f,x∈Ω,u_t-u_{xx}-u_{yy}-u_{zz}=f,x\in \Omega,ut​−uxx​−uyy​−uzz​=f,x∈Ω, u(0,x,y,z)=u0,u(0,x,y,z)=u_0,u(0,x,y,z)=u0​, u(t,x,y,z)=h,(x,y,z)∈∂Ωu(t,x,y,z)=h,(x,y,z)\in \partial \Omegau(t,x,y,z)=h,(x,y,z)∈∂Ω 这里同样使用PINN来求解方程。 难点 第一个困难在于我们需要给出几
解决PyTorch 出现RuntimeError: Function AddBackward0 returned an invalid gradient at index 1 问题
热门推荐
andyL_05的博客
08-12 1万+
解决PyTorch 出现RuntimeError: Function AddBackward0 returned an invalid gradient at index 1 问题 在使用pytorch框架训练中，进行loss.backward()一步时可能出现如下的问题： RuntimeError: Function AddBackward0 returned an invalid gradient at index 1 - expected type TensorOptions(dtype=float,
pytorch如何计算导数_PyTorch的梯度用法图解
weixin_28703507的博客
01-13 598
在本节中, 我们讨论了派生工具及其如何在PyTorch上应用。所以开始吧梯度用于查找函数的导数。用数学术语来说, 导数是指部分区分函数并找到值。下面是如何计算函数导数的图。 我们在上图中完成的工作将在带有梯度的PyTorch中完成。有以下步骤可找到该函数的导数。1.我们首先要初始化函数(y = 3×3 + 5×2 + 7x + 1), 然后为其计算导数。2.下一步是设置函数中使用的变量的值。 x的...
神经网络求解偏微分方程时遇到的一些问题
ion_ura的博客
01-06 887
记录了自己编写神经网络解算偏微分方程时遇到的一些问题，并附上了完整的代码.
A-Tentative-Autograd-Implementation:这是在Python中的暂定autograd实现，因为Pytorch不再提供在Python中的实现
04-15
在Python编程环境中，Autograd是一种自动微分库，它对于深度学习模型的训练至关重要，因为自动微分是反向传播算法的基础。PyTorch通常以其C++和CUDA实现的高效性能而闻名，但它确实提供了Python接口供用户进行交互。...
numpy-mnist:使用numpy使用简单FNN对MNIST进行分类
04-07
在本项目"numpy-mnist"中，我们关注的是如何利用Python中的NumPy库构建一个简单的全连接神经网络（Feedforward Neural Network，FNN）来对MNIST数据集进行图像分类。MNIST数据集是一个广泛使用的手写数字识别数据集...
一个用于学习的仿Pytorch纯Python实现的自动求导工具。.zip
02-22
自动求导分为两种模式：前向模式（Forward Mode）和反向模式（Backward Mode）。在深度学习中，我们通常使用反向模式，因为它更适合处理具有大量输入和少量输出的计算图，这正是神经网络的情况。反向模式通过链式...
pytorch学习与相关训练总结
03-05
- **自动求梯度**：PyTorch的autograd模块实现了自动求梯度，用于反向传播计算。通过`.requires_grad_()`方法标记Tensor，就可以记录其操作历史，之后通过`.backward()`求梯度。 - **Gradient积累**：在训练过程中...
pytorch入门以及Tensor的使用讲解，如何使用Autograd进行计算
03-02
Autograd是PyTorch的自动求导系统，它是训练神经网络的关键。当你对一个Tensor执行操作时，如果将其`.requires_grad`属性设置为`True`，PyTorch就会记录所有涉及的操作，以便于计算梯度。 例如： ```python x = ...
深度学习求解微分方程系列四：一种基于自适应激活函数的PINN求解方法—burger方程逆问题
山里娃的博客
11-10 5098
下面我将介绍内嵌物理知识神经网络（PINN）求解微分方程。首先介绍PINN基本方法，并基于Pytorch的PINN求解框架实现求解含时间项的一维burger方程逆问题。
pytorch求导总结（torch.autograd)
qq_43855428的博客
11-05 3436
详细介绍了pytorch中的求导原理和求导方法
详解Pytorch求导
weixin_43178406的博客
04-26 2634
本文主要详解Pytorch求导，希望能对学习Pytorch的同学有所帮助。 文章目录 1. pytorch求导问题 2. pytorch三大类求导代码示例 2.1 标量求导 2.2 向量求导&矩阵求导
（pytorch-深度学习系列）pytorch中backwards()函数对梯度的操作
我亦是行人
10-13 3004
backwards()函数对梯度的操作 对于一个新的tensor来说，梯度是空的；但当对这个tensor进行运算操作后，他就会拥有一个梯度： x = torch.ones(2, 2, requires_grad=True) print(x) print(x.grad_fn) y = x + 2 print(y) print(y.grad_fn) 输出结果： tensor([[1., 1.], [1., 1.]], requires_grad=True) None tensor([[3.
动手学深度学习笔记第四章（多层感知器）
qq_46144849的博客
01-13 960
深度学习知识
Pytorch的反向传播backward()详解
知识搬运者
04-05 2124
我们的回传某个网络的loss时，是不能有其他网络输出的可求导数据的，也就是我们在将其他网络的输出传入需要回传的网络进行结果的损失计算时，需要将其他网络的输出加上detach()才不会报错。这时候，我们就需要用上分步回传了，结果是不变的。，当我们的对相同的loss回传多次，只有最后一次不加retain_graph参数外，其余都得加，否则报错。在Pytorch中，我们有时候会进行多个loss的回传，然而回传中，会发生一些错误。3、当然，以上回传我们还可以加在一起，一并回传，那么梯度也会叠加，同上面的结果等价。
Pytorch中backward(retain_graph=True)的 retain_graph参数解释
今晚打老虎
02-28 1万+
每次 backward() 时，默认会把整个计算图free掉。一般情况下是每次迭代，只需一次 forward() 和一次backward() ,前向运算forward() 和反向传播backward()是成对存在的，一般一次backward()也是够用的。 但是不排除，由于自定义loss等的复杂性，需要一次forward()，多个不同loss的backward()来累积同一个网络的gra...
【深度学习】pytorch自动求导
第三季度的博客
05-02 263
上述计算中，当x通过pytorch内置的一些运算得到y的时候，其实计算图就已经被构建起来了。接下来，计算x在另一个函数中的梯度。
pytorch求导
qq_38156104的博客
07-31 2011
pytorch求导 主要记录一下backward()函数以及torch.autograd.grad()函数的使用，并重点探究一下对应的creat_graph以及retain_graph参数的使用。 首先定义函数 import torch from torch.autograd import Variable def f(x): y = x ** 3 return y 1. backward() 主要用于对loss的求导，并将求出的梯度存入叶子节点对应的buffer内。 其中，ret
PyTorch backward数学原理
最新发布
05-01
PyTorch是一个流行的深度学习框架，backward函数是PyTorch中用于计算梯度的关键函数之一。它实现了自动微分的功能，可以根据输入和输出之间的关系自动计算梯度。下面是PyTorch backward数学原理的简要介绍： 在深度学习中，我们通常使用反向传播算法来计算模型参数的梯度。反向传播算法通过链式法则来计算梯度，将输出对参数的梯度传递回输入层。PyTorch中的backward函数就是实现了这个过程。 具体来说，当我们调用backward函数时，它会从计算图的叶子节点（即输入）开始，沿着计算图的边缘向后传播梯度。在每个节点上，它会根据节点的操作和输入的梯度计算出输出的梯度，并将其累积到节点的梯度中。 在计算图中，每个节点都有一个grad_fn属性，它指向创建该节点的操作。当backward函数遍历计算图时，它会根据grad_fn属性找到对应的操作，并调用该操作的反向传播方法来计算梯度。 需要注意的是，只有具有requires_grad属性为True的张量才会被记录在计算图中，并且只有这些张量才能计算梯度。这样设计的目的是为了提高计算效率，避免不必要的计算。 总结一下，PyTorch的backward函数通过遍历计算图并调用每个操作的反向传播方法来计算梯度。它实现了自动微分的功能，使得深度学习模型的训练过程更加方便和高效。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

文火冰糖的硅基工坊

你的鼓励是我前进的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值