当前位置: 首页 > article >正文

PyTorch 中使用自动求导计算梯度

使用 PyTorch 进行自动求导和梯度计算

在 PyTorch 中,张量的 requires_grad 属性决定了是否需要计算该张量的梯度。设置为 True 的张量会在计算过程中记录操作,以便在调用 .backward() 方法时自动计算梯度。通过构建计算图,PyTorch 能够有效地追踪和计算梯度。

1、梯度的定义

在数学中,梯度是一个向量,表示函数在某一点的变化率。在深度学习中,我们通常关心的是损失函数相对于模型参数的梯度。具体来说,假设我们有一个输出 out,我们计算的是损失函数对模型参数(如权重和偏置)的梯度,而不是直接对输出的梯度。

2、 简单例子

在我们接下来的例子中,我们将计算 out 相对于输入变量 x x x y y y的梯度,通常表示为 ( d out d x ) ( \frac{d \text{out}}{dx}) (dxdout) ( d out d y ) ( \frac{d \text{out}}{dy}) (dydout)

import torch

# 1. 创建张量并设置 requires_grad=True
x = torch.tensor(2.0, requires_grad=True)  # 输入变量 x
y = torch.tensor(3.0, requires_grad=True)  # 输入变量 y

# 2. 定义第一个函数 f(z) = z^2
def f(z):
    return z**2

# 3. 定义第二个函数 g(x, y) = f(z) + y^3
def g(x, y):
    z = x + y  # 中间变量 z
    z_no_grad = z.detach()  # 创建不需要梯度的副本
    return f(z_no_grad) + y**3  # 输出 out = f(z_no_grad) + y^3

# 4. 计算输出
out = g(x, y)  # 计算输出

# 5. 反向传播以计算梯度
out.backward()  # 计算梯度

# 6. 打印梯度
print(f"dz/dx: {x.grad}")  # 输出 x 的梯度
print(f"dz/dy: {y.grad}")  # 输出 y 的梯度
dout/dx: None
dout/dy: 27.0
import torch

# 1. 创建张量并设置 requires_grad=True
x = torch.tensor(2.0, requires_grad=True)  # 输入变量 x
y = torch.tensor(3.0, requires_grad=True)  # 输入变量 y


# 2. 定义第一个函数 f(z) = z^2
def f(z):
    return z ** 2


# 3. 定义第二个函数 g(x, y) = f(z) + y^3
def g(x, y):
    z = x + y  # 中间变量 z
    return f(z) + y ** 3  # 输出 out = f(z_no_grad) + y^3


# 4. 计算输出
out = g(x, y)  # 计算输出

# 5. 反向传播以计算梯度
out.backward()  # 计算梯度

# 6. 打印梯度
print(f"dout/dx: {x.grad}")  # 输出 x 的梯度
print(f"dout/dy: {y.grad}")  # 输出 y 的梯度
dout/dx: 10.0
dout/dy: 37.0

在这两个代码示例中,dout/dxdout/dy 的值存在显著差异,主要原因在于如何处理中间变量 ( z ) 以及其对最终输出 out 的影响。

结果分析

  1. 第一部分代码

    • g(x, y) 函数中,使用了 z . detach ( ) z.\text{detach}() z.detach() 创建了一个不需要梯度的副本 z no_grad z_{\text{no\_grad}} zno_grad。这意味着在计算 f ( z no_grad ) f(z_{\text{no\_grad}}) f(zno_grad) 时,PyTorch 不会将 z z z 的变化记录进计算图中。

    • 因此, z z z out \text{out} out 的影响被切断,导致
      d out d x = None \frac{d \text{out}}{d x} = \text{None} dxdout=None
      因为 x x x 的变化不会影响到 out \text{out} out 的计算。

    • 对于 y y y,计算得到的梯度为
      d out d y = 27.0 \frac{d \text{out}}{d y} = 27.0 dydout=27.0
      这是通过以下步骤得到的:

    • 输出为
      out = f ( z no_grad ) + y 3 \text{out} = f(z_{\text{no\_grad}}) + y^3 out=f(zno_grad)+y3

    • 使用链式法则:
      d out d y = 0 + 3 y 2 = 3 ( 3 2 ) = 27 \frac{d \text{out}}{d y} = 0 + 3y^2 = 3(3^2) = 27 dydout=0+3y2=3(32)=27

  2. 第二部分代码

    • g(x, y) 函数中,直接使用了 z z z 而没有使用 z . detach ( ) z.\text{detach}() z.detach()。这使得 z z z 的变化会被记录在计算图中。
    • 计算
      d out d x \frac{d \text{out}}{d x} dxdout
      时, z = x + y z = x + y z=x+y 的变化会影响到 out \text{out} out,因此计算得到的梯度为
      d out d x = 10.0 \frac{d \text{out}}{d x} = 10.0 dxdout=10.0
      这是因为:
    • f ( z ) = z 2 f(z) = z^2 f(z)=z2 的导数为
      d f ( z ) d z = 2 z \frac{d f(z)}{d z} = 2z dzdf(z)=2z
      z = 5 z = 5 z=5(当 x = 2 , y = 3 x=2, y=3 x=2,y=3 时),所以
      2 z = 10 2z = 10 2z=10
    • 对于 y y y,计算得到的梯度为
      d out d y = 37.0 \frac{d \text{out}}{d y} = 37.0 dydout=37.0
      这是因为
      d out d y = d ( f ( z ) + y 3 ) d y = 2 z ⋅ d z d y + 3 y 2 = 2 ( 5 ) ( 1 ) + 3 ( 3 2 ) = 10 + 27 = 37 \frac{d \text{out}}{d y} = \frac{d (f(z) + y^3)}{d y} = 2z \cdot \frac{d z}{d y} + 3y^2 = 2(5)(1) + 3(3^2) = 10 + 27 = 37 dydout=dyd(f(z)+y3)=2zdydz+3y2=2(5)(1)+3(32)=10+27=37

3、线性拟合及梯度计算

在深度学习中,线性回归是最基本的模型之一。通过线性回归,我们可以找到输入特征与输出之间的线性关系。在本文中,我们将使用 PyTorch 实现一个简单的线性拟合模型,定义模型为 y = a x + b x + c + d y = ax + bx + c + d y=ax+bx+c+d,并展示如何计算梯度,同时控制某些参数(如 b b b d d d)不更新梯度。
在这个模型中,我们将定义以下参数:

  • a a a:斜率,表示输入 x x x 对输出 y y y 的影响。
  • b b b:另一个斜率,表示输入 x x x 对输出 y y y 的影响,但在训练过程中不更新。
  • c c c:截距,表示当 x = 0 x=0 x=0 时的输出值。
  • d d d:一个常数项,在训练过程中不更新。

3.1、完整代码

下面是实现线性拟合的完整代码:

import torch
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt

# 1. 创建数据
# 假设我们有一些样本数据
x_data = torch.tensor([1.0, 2.0, 3.0, 4.0, 5.0])
y_data = torch.tensor([3.0, 5.0, 7.0, 9.0, 11.0])  # 目标值

# 2. 定义线性模型
class LinearModel(nn.Module):
    def __init__(self):
        super(LinearModel, self).__init__()
        self.a = nn.Parameter(torch.tensor(1.0))  # 需要更新的参数
        self.b = nn.Parameter(torch.tensor(0.5), requires_grad=False)  # 不需要更新的参数
        self.c = nn.Parameter(torch.tensor(0.0))  # 需要更新的参数
        self.d = nn.Parameter(torch.tensor(0.5), requires_grad=False)  # 不需要更新的参数

    def forward(self, x):
        return self.a * x + self.b * x + self.c + self.d

# 3. 实例化模型
model = LinearModel()

# 4. 定义损失函数和优化器
criterion = nn.MSELoss()  # 均方误差损失
optimizer = optim.SGD(model.parameters(), lr=0.005)  # 随机梯度下降优化器

# 5. 训练模型
for epoch in range(5000):
    model.train()  # 设置模型为训练模式

    # 计算模型输出
    y_pred = model(x_data)

    # 计算损失
    loss = criterion(y_pred, y_data)

    # 反向传播
    optimizer.zero_grad()  # 清零梯度
    loss.backward()  # 计算梯度
    optimizer.step()  # 更新参数

    # 每10个epoch打印一次loss和参数值
    if (epoch + 1) % 500 == 0:
        print(f'Epoch [{epoch + 1}/100], Loss: {loss.item():.4f}, a: {model.a.item():.4f}, b: {model.b.item():.4f}, c: {model.c.item():.4f}, d: {model.d.item():.4f}')

# 6. 打印最终参数
print(f'Final parameters: a = {model.a.item()}, b = {model.b.item()}, c = {model.c.item()}, d = {model.d.item()}')

# 7. 绘制拟合结果
with torch.no_grad():
    # 生成用于绘图的 x 值
    x_fit = torch.linspace(0, 6, 100)  # 从 0 到 6 生成 100 个点
    y_fit = model(x_fit)  # 计算对应的 y 值

# 绘制真实数据点
plt.scatter(x_data.numpy(), y_data.numpy(), color='red', label='True Data')
# 绘制拟合曲线
plt.plot(x_fit.numpy(), y_fit.numpy(), color='blue', label='Fitted Curve')
plt.xlabel('X')
plt.ylabel('Y')
plt.title('Linear Fit Result')
plt.legend()
plt.grid()
plt.show()

3.2、梯度计算过程

在这个例子中,我们使用了 PyTorch 的自动求导功能来计算梯度。以下是对每个参数的梯度计算过程的解释:

  1. 参数定义

    • a a a c c c 是需要更新的参数,因此它们的 requires_grad 属性默认为 True
    • b b b d d d 是不需要更新的参数,设置了 requires_grad=False,因此它们的梯度不会被计算。
  2. 损失计算

    • 在每个训练周期中,我们计算模型的预测值 y pred y_{\text{pred}} ypred,并与真实值 y data y_{\text{data}} ydata 计算均方误差损失:
      loss = 1 n ∑ i = 1 n ( y pred , i − y i ) 2 \text{loss} = \frac{1}{n} \sum_{i=1}^{n} (y_{\text{pred},i} - y_{i})^2 loss=n1i=1n(ypred,iyi)2
  3. 反向传播

    • 调用 loss.backward() 计算所有参数的梯度。由于 b b b d d drequires_grad 被设置为 False,因此它们的梯度不会被计算和更新。
  4. 参数更新

    • 使用优化器 optimizer.step() 更新参数。只有 a a a c c c 会被更新。
Epoch [500/100], Loss: 0.0038, a: 1.5399, b: 0.5000, c: 0.3559, d: 0.5000
Epoch [1000/100], Loss: 0.0007, a: 1.5171, b: 0.5000, c: 0.4382, d: 0.5000
Epoch [1500/100], Loss: 0.0001, a: 1.5073, b: 0.5000, c: 0.4735, d: 0.5000
Epoch [2000/100], Loss: 0.0000, a: 1.5032, b: 0.5000, c: 0.4886, d: 0.5000
Epoch [2500/100], Loss: 0.0000, a: 1.5014, b: 0.5000, c: 0.4951, d: 0.5000
Epoch [3000/100], Loss: 0.0000, a: 1.5006, b: 0.5000, c: 0.4979, d: 0.5000
Epoch [3500/100], Loss: 0.0000, a: 1.5002, b: 0.5000, c: 0.4991, d: 0.5000
Epoch [4000/100], Loss: 0.0000, a: 1.5001, b: 0.5000, c: 0.4996, d: 0.5000
Epoch [4500/100], Loss: 0.0000, a: 1.5000, b: 0.5000, c: 0.4998, d: 0.5000
Epoch [5000/100], Loss: 0.0000, a: 1.5000, b: 0.5000, c: 0.4999, d: 0.5000
Final parameters: a = 1.5000202655792236, b = 0.5, c = 0.4999275505542755, d = 0.5

在这里插入图片描述


http://www.kler.cn/a/399783.html

相关文章:

  • oracle19c开机自启动
  • Redis-08 Redis集群
  • 经验笔记:Git 基础操作指南
  • 【3D Slicer】的小白入门使用指南九
  • Vue通过file控件上传文件到Node服务器
  • LabVIEW中的UDP与TCP比较
  • 【UGUI】背包的交互01(道具信息跟随鼠标+道具信息面板显示)
  • event_base
  • 腾讯云-COS
  • Python学习28天
  • 【Linux】指令 + 压缩与解压
  • GraphPad Prism与鹰谷电子实验记录本强强联合,数据兼容互通
  • 解决微信小程序自定义tabbar点击两次才能跳转
  • 华为ID机试 -- 分糖果 E100
  • VSCode解说
  • 28.<Spring博客系统⑤(部署的整个过程(CentOS))>
  • 基于微信小程序的助农商城+LW示例参考
  • 使用 Elastic 3 步实现基于 OTel 的原生 K8s 和应用可观测性
  • 【Android、IOS、Flutter、鸿蒙、ReactNative 】屏幕适配
  • 使用uniapp开发微信小程序使用uni_modules导致主包文件过大,无法发布的解决方法
  • 银河麒麟设置ip
  • Java retainAll() 详解
  • 滑动窗口入门(LeetCode——1456定长字符串中元音字母的最大数目)
  • 【在Linux世界中追寻伟大的One Piece】手写序列化与反序列化
  • 利用hive元数据统计数据量
  • 编程之路,从0开始:结构体详解