深度学习基础：自动梯度、线性回归与逻辑回归的 PyTorch 实践

🕗 发布于 2025-01-20 15:44 深度学习 线性回归逻辑回归

一、引言

深度学习作为人工智能领域的核心技术，在图像识别、自然语言处理等众多领域取得了巨大成功。理解深度学习中的基本概念和算法，如自动梯度、线性回归和逻辑回归，是深入掌握深度学习技术的关键。本文基于 PyTorch 框架，结合理论与实践，详细介绍这些基础内容。

二、自动梯度：深度学习的计算基石

2.1 编程方式概览

在深度学习领域，主要存在函数式编程和图的编程两种方式。

函数式编程方式：这种编程风格具有 “所见即所得” 的特点。在编写代码时，需要定义类、方法、函数以及相应参数。代码编写完成后，首先会进行语法错误检查，确保代码的语法结构正确。随后进入编译与链接阶段，将代码转换为可执行的机器码，最终生成可执行文件。函数式编程方式支持各种参数的输入与输出，以及界面的交互操作，为开发者提供了灵活的编程体验12。
图的编程方式（深度学习）：图的编程方式在深度学习中占据重要地位。其核心是构建计算图，早期采用先定义再执行的模式，而现在更多地使用即时编译（JIT）方式。计算图存在静态图和动态图之分。输入的数据以张量（Tensor）的形式存在，计算图中的每个节点代表一个操作（OP）。当计算图构建完成后，即可执行相应的计算任务45。

2.2 张量：深度学习的数据载体

张量是深度学习中的关键数据结构，不同维度的张量对应着不同类型的数据：

1D 张量（Vectors）：通常用于表示特征，例如一个样本的多个特征值可以存储在一个 1D 张量中8。
2D 张量（Sequences）：常用于表示具有时间步长和特征的数据，如时间序列数据，其中每一行为一个时间步，每列代表不同的特征9。
3D 张量（Images）：在图像数据中，3D 张量通常按照 (height, width, channels) 的维度顺序存储图像信息，其中 height 和 width 表示图像的高度和宽度，channels 表示图像的通道数，如 RGB 图像的通道数为 310。
4D 张量（Videos）：对于视频数据，4D 张量按照 (frames, height, width, channels) 的维度存储，frames 表示视频的帧数，其余维度与图像张量类似11。

2.3 计算图构建与自动梯度计算

计算图的构建过程包括定义数据（张量）和操作（OP）。以一个简单的计算为例，首先定义输入张量，整个计算过程的定义构成了计算图的构建。在计算图中，可以通过链式法则进行自动梯度计算。例如，对于，设，则有：

下面通过 PyTorch 代码演示自动梯度的计算过程：

import torch

# 定义需要计算梯度的张量
x = torch.tensor(2.0, requires_grad=True)
y = torch.tensor(3.0, requires_grad=True)
z = torch.tensor(4.0, requires_grad=True)

# 构建计算图
f = x * y * z

# 自动计算梯度
f.backward()

# 输出梯度
print(x.grad)  
print(y.grad)  
print(z.grad)

上述代码首先创建了需要计算梯度的张量x、y、z，并构建了计算图f = x * y * z。然后通过f.backward()进行自动梯度计算，最后输出各个张量的梯度值。

三、线性回归：基础的数值预测模型

3.1 线性回归的原理

线性回归的目标是根据输入的数据拟合一条直线，其数学表达式为，其中为斜率，为截距。给定一组输入数据和对应的输出数据，线性回归模型试图找到最佳的和值，使得模型预测值与真实值之间的误差最小。例如，给定数据点等，线性回归模型将尝试拟合出一条直线，尽可能准确地描述与之间的关系。

3.2 线性回归模型的构建与训练

模型构建：在 PyTorch 中，可以使用torch.nn.Linear模块构建线性回归模型。该模块接受输入特征的维度和输出特征的维度作为参数。

import torch
import torch.nn as nn

class LinearRegressionModel(nn.Module):
    def __init__(self):
        super(LinearRegressionModel, self).__init__()
        self.linear = nn.Linear(1, 1)  # 输入维度为1，输出维度为1

    def forward(self, x):
        return self.linear(x)

上述代码定义了LinearRegressionModel类，继承自nn.Module。在__init__函数中，创建了一个线性层self.linear。forward函数定义了数据的前向传播过程，即输入数据通过线性层得到输出。
2. 损失函数与优化器：使用均方误差（MSE）作为损失函数，用于衡量模型预测值与真实值之间的差异，在 PyTorch 中可以使用torch.nn.MSELoss。同时，选择随机梯度下降（SGD）作为优化器来更新模型的参数，学习率设置为 0.01。

model = LinearRegressionModel()
criterion = nn.MSELoss()
learning_rate = 0.01
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

训练过程：通过迭代训练数据，计算损失，进行反向传播计算梯度，并使用优化器更新模型参数。

# 准备数据
x_train = torch.tensor([[1.0], [2.0], [0.5], [2.5], [2.6], [3.1]])
y_train = torch.tensor([[3.7], [4.6], [1.65], [5.68], [5.98], [6.95]])

num_epochs = 1000
for epoch in range(num_epochs):
    # 前向传播
    y_pred = model(x_train)
    loss = criterion(y_pred, y_train)

    # 反向传播与优化
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    if (epoch + 1) % 100 == 0:
        print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {loss.item()}')

上述代码首先准备了训练数据x_train和y_train，然后进行 1000 次迭代训练。在每次迭代中，首先进行前向传播得到预测值y_pred，计算损失loss。接着将优化器的梯度清零，通过loss.backward()进行反向传播计算梯度，最后使用optimizer.step()更新模型参数。每 100 次迭代打印一次损失值。

3.3 模型预测

训练好模型后，可以使用模型进行预测。

x_test = torch.tensor([[3.5]])
y_pred = model(x_test)
print(f'Predicted value for x = 3.5: {y_pred.item()}')

上述代码创建了一个测试数据x_test，将其输入到训练好的模型中，得到预测值y_pred并输出。

四、逻辑回归：适用于分类问题的模型

4.1 逻辑回归的原理

逻辑回归主要用于解决二分类问题，它在线性组合的基础上加上非线性变换。逻辑回归的核心是 sigmoid 函数，其表达式为。通过将线性组合输入到 sigmoid 函数中，得到的输出值在 0 到 1 之间，可以将其解释为样本属于某一类别的概率。例如，当输出值大于 0.5 时，可以认为样本属于正类，否则属于负类。

4.2 逻辑回归模型的构建与训练

模型构建：同样在 PyTorch 中使用torch.nn.Linear模块构建逻辑回归模型，并在最后添加 sigmoid 函数进行非线性变换。

import torch
import torch.nn as nn

class LogisticRegressionModel(nn.Module):
    def __init__(self):
        super(LogisticRegressionModel, self).__init__()
        self.linear = nn.Linear(1, 1)

    def forward(self, x):
        return torch.sigmoid(self.linear(x))

上述代码定义了LogisticRegressionModel类，在forward函数中，先通过线性层进行线性变换，再通过sigmoid函数进行非线性变换。
2. 损失函数与优化器：使用二元交叉熵（Binary Cross Entropy，BCE）作为损失函数，在 PyTorch 中可以使用torch.nn.BCELoss。优化器依然选择随机梯度下降（SGD）。

model = LogisticRegressionModel()
criterion = nn.BCELoss()
learning_rate = 0.01
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

训练过程：与线性回归的训练过程类似，通过迭代训练数据，计算损失，进行反向传播和参数更新。

# 准备数据
x_train = torch.tensor([[1.0], [2.0], [0.5], [2.5], [2.6], [3.1]])
y_train = torch.tensor([[1.0], [1.0], [0.0], [1.0], [1.0], [1.0]])  # 二分类标签

num_epochs = 1000
for epoch in range(num_epochs):
    y_pred = model(x_train)
    loss = criterion(y_pred, y_train)

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    if (epoch + 1) % 100 == 0:
        print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {loss.item()}')

上述代码准备了二分类的训练数据x_train和y_train，进行 1000 次迭代训练。在每次迭代中，计算预测值y_pred和损失loss，然后进行反向传播和参数更新，每 100 次迭代打印损失值。

4.3 模型预测