个人独创-CV领域快速测试缝合模型实战框架讲解-基础篇-Pytorch必学知识

深度学习-Pytorch必学入门知识

💻本系列笔记分为三篇：
🔰 基础篇：聚焦 Python 与 PyTorch 基础语法，可以基本看懂代码，适合零基础或需要回顾的同学。
🧱 框架篇：深入剖析 CV 模型的核心组件与缝合模块，讲解项目结构设计，配套开源代码。
🚀 训练篇：从实战出发，完整跑通一个深度学习模型的训练流程。涵盖数据预处理、模型训练技巧（如学习率策略、多卡训练、最优模型保存加载策略等）

（只学必要的）

一、深度学习框架 PyTorch

1.1 Tensor 与自动求导

在 PyTorch 中，Tensor 是用于存储和计算的核心数据结构。它类似于 NumPy 的多维数组，但提供 GPU 加速支持和自动求导功能。通过 requires_grad=True，我们可以开启该张量的自动梯度追踪，使其能参与构建计算图，从而进行梯度反向传播计算。

import torch# 创建一个二维张量，并启用自动求导
x = torch.tensor([[2.0, 3.0]], requires_grad=True)# 构建一个函数 y = x^2 + 2x，PyTorch 会自动记录计算图
y = x ** 2 + 2 * x# 将 y 中所有元素求和（必须为标量才能反向传播）
loss = y.sum()# 执行反向传播，计算 loss 对 x 的梯度
loss.backward()# 输出梯度值，表示每个元素对最终 loss 的影响
print("x 的梯度：", x.grad)

这段代码体现了 PyTorch 的自动微分能力。只需构建计算图并调用 .backward()，就可以自动求出所有参与计算的 Tensor 的梯度值，非常适用于神经网络训练。

---

1.2 网络结构定义

在 PyTorch 中，我们通过继承 nn.Module 来定义模型结构。在 __init__() 方法中定义各层组件，在 forward() 方法中编写前向传播逻辑。PyTorch 会自动管理所有子模块和参数。

import torch.nn as nn# 定义一个包含两层全连接层的简单神经网络
class SimpleNet(nn.Module):def __init__(self, input_dim, hidden_dim, output_dim):super(SimpleNet, self).__init__()self.fc1 = nn.Linear(input_dim, hidden_dim)  # 第一层线性变换self.relu = nn.ReLU()                        # 激活函数self.fc2 = nn.Linear(hidden_dim, output_dim) # 第二层线性变换def forward(self, x):out = self.fc1(x)       # 输入通过第一层out = self.relu(out)    # 非线性激活out = self.fc2(out)     # 输出层return out

在这个模型中，self.fc1 和 self.fc2 是两层线性层（全连接层），中间通过 ReLU 激活函数连接，结构简单但足以完成基础分类或回归任务。

---

1.3 优化器与损失函数

损失函数用于衡量模型预测和真实标签之间的误差，优化器根据损失计算出的梯度来更新模型参数。PyTorch 提供了丰富的内置损失函数和优化器。

import torch.optim as optimmodel = SimpleNet(10, 20, 2)                    # 实例化模型
criterion = nn.MSELoss()                        # 使用均方误差损失函数
optimizer = optim.Adam(model.parameters(), lr=0.001)  # 使用 Adam 优化器# 构造输入数据和目标标签
x = torch.randn(5, 10)  # 批量大小为 5，特征维度为 10
y = torch.randn(5, 2)   # 对应标签output = model(x)           # 前向传播计算预测值
loss = criterion(output, y) # 计算损失optimizer.zero_grad()  # 清空上一轮的梯度
loss.backward()        # 反向传播计算梯度
optimizer.step()       # 更新参数

每次迭代都必须先清空梯度，再调用 .backward() 计算当前 batch 的梯度，最后通过 .step() 执行更新。否则梯度会被累加，导致训练异常。

---

1.4 数据加载机制

PyTorch 使用 Dataset 和 DataLoader 构建高效的数据加载机制。自定义 Dataset 类可以灵活加载任意格式的数据，而 DataLoader 负责批处理、打乱顺序和并行读取。

from torch.utils.data import Dataset, DataLoader# 定义一个自定义数据集类
class MyDataset(Dataset):def __init__(self):self.data = torch.randn(100, 10)             # 共100个样本，每个10维self.labels = torch.randint(0, 2, (100,))     # 二分类标签（0或1）def __getitem__(self, index):return self.data[index], self.labels[index]  # 返回第 index 个样本和标签def __len__(self):return len(self.data)  # 数据集大小# 创建数据集和加载器
dataset = MyDataset()
dataloader = DataLoader(dataset, batch_size=16, shuffle=True)# 遍历数据
for batch_data, batch_labels in dataloader:print(batch_data.shape, batch_labels.shape)

自定义 Dataset 类是处理图像、文本、CSV 等非标准格式数据的关键步骤。使用 DataLoader 时设置 batch_size 控制每轮训练的样本数量，shuffle=True 可以打乱顺序提高泛化能力。

---

1.5 模式切换与 GPU 加速

PyTorch 支持将模型和数据移到 GPU 上加速训练与推理，通过 model.to(device) 和 tensor.to(device) 实现。训练与推理模式下，部分层（如 Dropout 和 BatchNorm）行为不同，需要使用 model.train() 与 model.eval() 切换。

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")  # 自动选择设备model = SimpleNet(10, 20, 2).to(device)  # 模型移动到 GPU
x = torch.randn(8, 10).to(device)        # 数据也要移动到 GPUmodel.train()  # 设置为训练模式
output = model(x)model.eval()   # 切换为推理模式，适用于测试或验证
output_eval = model(x)

.train() 和 .eval() 的切换影响模型行为，如 Dropout 是否生效、BatchNorm 是否更新统计量，因此在训练和验证时必须正确设置。

二、神经网络基本结构

2.1 基础结构

在神经网络中，最基本的结构是“感知机”与“多层感知机”（MLP）。感知机是最简单的神经元模型，由输入层直接连接到输出层，进行线性变换。多层感知机由多个全连接层和激活函数堆叠组成，是经典的前馈神经网络结构，具备更强的非线性表达能力，能够拟合复杂函数。激活函数中，ReLU 是最常用的，能够有效缓解梯度消失问题，提高训练速度和效果。Sigmoid 和 Tanh 激活函数常用于浅层网络或特定场景，但在深层网络中不如 ReLU 表现优异。

除了全连接层，卷积层（nn.Conv2d）是处理图像等空间数据的关键组件。卷积层通过卷积核（滤波器）在输入数据上滑动，提取局部空间特征，同时利用权值共享显著减少参数量。它能够捕捉图像的边缘、纹理等空间结构信息，常与池化层、激活函数等组合，构建强大的卷积神经网络（CNN）。

下面是一个简单的 MLP 结构示例，输入是10维特征，经过一个隐藏层和输出层：

import torch
import torch.nn as nnclass MLP(nn.Module):def __init__(self):super(MLP, self).__init__()self.layer1 = nn.Linear(10, 20)   # 全连接层，将10维映射到20维self.act1 = nn.ReLU()             # ReLU激活函数，引入非线性self.layer2 = nn.Linear(20, 2)    # 输出层，映射到2维，用于分类或回归def forward(self, x):x = self.layer1(x)    # 线性变换x = self.act1(x)      # 非线性激活x = self.layer2(x)    # 线性输出return xx = torch.randn(4, 10)       # 构造一个batch，4个样本，每个10维
model = MLP()
output = model(x)
print(output.shape)          # 输出形状为 [4, 2]

卷积层的基本用法示例如下，适用于处理彩色图像（3个通道）：

import torch.nn as nnconv_layer = nn.Sequential(nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, padding=1),  # 卷积核大小3x3，填充1保持尺寸nn.ReLU()  # 激活函数，增强非线性表达能力
)

该卷积层会对输入图像的每个3x3局部区域进行加权求和，输出16个特征通道，利用权重共享机制有效减少参数数量，提取空间特征，是构建图像识别、分割等任务的基础。

---

2.2 损失函数

损失函数用于衡量预测结果与真实标签的差异。不同任务使用不同的损失函数：

• 回归任务使用均方误差（MSE）；
• 分类任务使用交叉熵损失（Cross Entropy）。

# 回归任务
y_true = torch.tensor([[2.5], [0.5]])         # 真实标签
y_pred = torch.tensor([[2.0], [0.0]])         # 模型输出
mse_loss = nn.MSELoss()
loss = mse_loss(y_pred, y_true)
print("MSE Loss:", loss.item())# 分类任务（假设有3类）
y_pred_logits = torch.tensor([[2.0, 0.5, 0.3]])   # 模型输出的原始分数（未Softmax）
y_true_class = torch.tensor([0])                 # 正确类别是类别0
ce_loss = nn.CrossEntropyLoss()
loss = ce_loss(y_pred_logits, y_true_class)
print("Cross Entropy Loss:", loss.item())

交叉熵损失要求输入是“未归一化的分数（logits）”，目标标签为整数索引。PyTorch 的 nn.CrossEntropyLoss 内部会自动执行 Softmax 和 Log 运算。

---

2.3 传播机制

神经网络训练过程分为“正向传播”和“反向传播”两个阶段：

• 正向传播：将输入数据经过网络逐层处理，得到预测输出。

• 反向传播：通过 .backward() 自动计算损失函数关于每个参数的梯度。

# 定义模型、损失函数和优化器
model = MLP()
criterion = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)# 构造输入和标签
x = torch.randn(8, 10)            # 输入特征
y_true = torch.randn(8, 2)        # 真实标签# 正向传播：计算预测值
y_pred = model(x)# 计算损失
loss = criterion(y_pred, y_true)# 反向传播：计算梯度
optimizer.zero_grad()    # 清除上一轮的梯度信息
loss.backward()          # 自动计算所有可学习参数的梯度# 参数更新
optimizer.step()         # 使用优化器执行一步参数更新

.zero_grad() 是必须的步骤，否则梯度会被累计，影响结果。loss.backward() 会自动构建反向图进行求导，无需手动指定。

---

2.4 正则化

为了防止过拟合，常用的正则化方式包括 Dropout 和 Batch Normalization。

Dropout 会在训练时随机将一部分神经元“关闭”，从而增强模型的泛化能力。BatchNorm 则可以规范化中间激活值的分布，使模型更稳定、更快收敛。

class RegularizedMLP(nn.Module):def __init__(self):super(RegularizedMLP, self).__init__()self.fc1 = nn.Linear(10, 32)self.bn1 = nn.BatchNorm1d(32)   # 批归一化self.drop = nn.Dropout(p=0.5)   # Dropout，50% 的概率随机失活self.fc2 = nn.Linear(32, 2)def forward(self, x):x = self.fc1(x)x = self.bn1(x)     # 应用 BatchNormx = torch.relu(x)x = self.drop(x)    # 应用 Dropoutx = self.fc2(x)return xx = torch.randn(16, 10)
model = RegularizedMLP()
model.train()        # Dropout 生效
out = model(x)model.eval()         # Dropout 失效，使用全部神经元
out_eval = model(x)

Dropout 在训练时具有随机性，因此要在验证时使用 model.eval() 关闭 Dropout 和固定 BatchNorm 的均值方差。