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

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

1、梯度的定义

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

2、 简单例子

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

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/dx 和 dout/dy 的值存在显著差异，主要原因在于如何处理中间变量 ( z ) 以及其对最终输出 out 的影响。

结果分析

1. 第一部分代码：

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

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

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

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

   • 使用链式法则：
     $$\frac{d\text{out}}{dy}=0+3y^2=3(3^2)=27$$

2. 第二部分代码：

   • 在 g(x, y) 函数中，直接使用了 $z$ 而没有使用 $z.\text{detach}()$。这使得 $z$ 的变化会被记录在计算图中。
   • 计算
     $$\frac{d\text{out}}{dx}$$
     时，$z=x+y$ 的变化会影响到 $\text{out}$，因此计算得到的梯度为
     $$\frac{d\text{out}}{dx}=10.0$$
     这是因为：
   • $f(z)=z^2$ 的导数为
     $$\frac{df(z)}{dz}=2z$$
     当 $z=5$（当 $x=2,y=3$ 时），所以
     $$2z=10$$
   • 对于 $y$，计算得到的梯度为
     $$\frac{d\text{out}}{dy}=37.0$$
     这是因为
     $$\frac{d\text{out}}{dy}=\frac{d(f(z)+y^3)}{dy}=2z\cdot \frac{dz}{dy}+3y^2=2(5)(1)+3(3^2)=10+27=37$$

3、线性拟合及梯度计算

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

• $a$：斜率，表示输入 $x$ 对输出 $y$ 的影响。
• $b$：另一个斜率，表示输入 $x$ 对输出 $y$ 的影响，但在训练过程中不更新。
• $c$：截距，表示当 $x=0$ 时的输出值。
• $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$ 和 $c$ 是需要更新的参数，因此它们的 requires_grad 属性默认为 True。
   • $b$ 和 $d$ 是不需要更新的参数，设置了 requires_grad=False，因此它们的梯度不会被计算。

2. 损失计算：

   • 在每个训练周期中，我们计算模型的预测值 $y_{\text{pred}}$，并与真实值 $y_{\text{data}}$ 计算均方误差损失：
     $$\text{loss}=\frac{1}{n}\sum _{i=1}^n(y_{\text{pred},i}-y_i{)}^2$$

3. 反向传播：

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

4. 参数更新：

   • 使用优化器 optimizer.step() 更新参数。只有 $a$ 和 $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