深度学习框架：PyTorch

PyTorch是一个开源的深度学习框架，由 Facebook 的人工智能研究团队开发，广泛应用于计算机视觉（CV）、自然语言处理（NLP）等领域。它以灵活性和易用性著称，特别适合研究人员和开发者进行快速原型设计和实验。

💡PyTorch 的模型训练通常包括以下步骤：

1. 数据加载：使用Dataset和DataLoader加载和预处理数据。

2. 模型定义：通过继承torch.nn.Module构建神经网络。

3. 损失函数与优化器：选择合适的损失函数（如交叉熵）和优化器（如 SGD 或 Adam）。

4. 训练与验证：通过循环迭代训练模型，并使用验证集评估性能。

5. 保存与加载模型：使用torch.save和torch.load保存和恢复模型。

深度学习模型：CNN

CNN（卷积神经网络），适合用在图像识别和分类中，通过一系列的卷积层、池化层和全连接层来处理数据

在卷积层中，CNN使用一组可学习的滤波器（卷积核）来扫描输入的图像或信号。每个滤波器都能够检测输入中的特定特征，如边缘或颜色斑点。通过这种方式，CNN能够捕捉到图像中的局部特征，并保持这些特征的空间关系。

池化层（也称为下采样层）则用于降低特征的空间尺寸，从而减少参数数量和计算复杂度，同时使特征检测更加鲁棒。全连接层则将学习到的高级特征用于分类或其他任务。

💡CNN的结构和工作原理

一个典型的CNN包含以下几个主要部分：

• 输入层：接收原始数据，如图像的像素值。

• 卷积层：使用多个卷积核提取输入的特征。

• 激活函数：如ReLU，用于引入非线性，使网络能够学习更复杂的特征。

• 池化层：降低特征的空间维度，减少计算量。

• 全连接层：将学习到的特征映射到最终的输出，如分类标签。

• 输出层：输出网络的最终结果，如分类的概率分布。

CNN通过这些层的堆叠，能够从简单到复杂逐渐提取图像的特征。在训练过程中，CNN通过反向传播算法调整卷积核中的权重，以最小化预测结果和真实标签之间的差异。

训练MNIST

❓什么是MNIST

全称：（Modified National Institute of Standards and Technology），是机器学习和深度学习领域最经典的入门数据集，被称为深度学习的“Hello World”。它包含手写数字（0-9）的灰度图像，广泛用于图像分类算法的训练与测试。

模型定义

首先定义模型的结构，这个结构在训练和推理过程中都是要保持一致的，其中包括模型组件的定义和模型流程定义，代码如下所示：

class Net(nn.Module): def __init__(self): super(Net, self).__init__() self.conv1 = nn.Conv2d(1, 32, 3, 1) self.conv2 = nn.Conv2d(32, 64, 3, 1) self.dropout1 = nn.Dropout2d(0.25) self.fc1 = nn.Linear(9216, 128) self.fc2 = nn.Linear(128, 10) def forward(self, x): x = self.conv1(x) x = F.relu(x) x = self.conv2(x) x = F.relu(x) x = F.max_pool2d(x, 2) x = self.dropout1(x) x = torch.flatten(x, 1) x = self.fc1(x) x = F.relu(x) x = self.dropout2(x) x = self.fc2(x) output = F.log_softmax(x, dim=1) return output

上面的代码中，首先定义了模型的组件结构，其次forward是模型的流程结构。这是一个经典的“特征提取+分类器”双阶段结构，分为两个阶段。

第一阶段：特征提取（卷积神经网络），负责把像素变成“语义特征”。

• 卷积层 1(Conv1)：初级特征提取（边缘、线条）

  • self.conv1 = nn.Conv2d(1, 32, 3, 1)
  • in_channels=1 : 输入是灰度图（1个通道）
  • out_channels=32: 派出32个不同的“侦探”（滤波器）
  • kernel_size=3 : 每个侦探拿3x3的放大镜
  • stride=1 : 每次移动1个像素
  • 输出尺寸计算：(28 - 3 + 1) = 26 -> 输出 (32, 26, 26)

• 卷积层 2：高级特征提取（部件、纹理）

  • self.conv2 = nn.Conv2d(32, 64, 3, 1)
  • in_channels=32: 接收上一层的32个特征图
  • out_channels=64: 增加到64个侦探，组合更复杂的模式
  • 输出尺寸计算：(26 - 3 + 1) = 24 -> 输出 (64, 24, 24)

• Dropout 层 1：针对卷积特征的正则化

  • self.dropout1 = nn.Dropout2d(0.25)
  • 作用：随机“掐断”25%的通道（整张特征图）,强迫模型不要把赌注押在某几个特定的特征组合上
  • 为什么用 Dropout2d：防止特征图之间产生共适应（Co-adaptation）

• Dropout 层 2：针对全连接层的正则化

  • self.dropout2 = nn.Dropout2d(0.5)
  • 作用：随机“掐断”50%的神经元，因为全连接层参数最多，最容易过拟合

第二阶段：分类器（全连接网络），负责把特征变成具体的数字类别

• 全连接层 1：特征映射与降维

  • self.fc1 = nn.Linear(9216, 128)
  • 输入维度 9216 的由来（关键计算）
  • 经过 Conv2(64, 24, 24) -> MaxPool(2, 2)
  • 输出尺寸：64个通道 * 12 * 12 = 9216
  • 输出维度 128：将高维特征压缩成128维的“数字指纹”

• 全连接层 2：最终输出层

  • self.fc2 = nn.Linear(128, 10)
  • 输入 128：接收上层的指纹
  • 输出 10：对应 0-9 十个数字类别

而这些阶段落实到的流程执行中，需要用到一些额外的手段，如下所示：

• relu，激活函数：引入非线性，筛选有效特征
• max_pool2d，最大池化，模型不再关心像素的精确位置，只关心“有没有”
• flatten，展平：把三维特征图拉直成一维向量，为了对接全连接层（只能吃一维数据）
• log_softmax，转换为对数概率

forward函数清晰地展示了数据流(Flow)：像素 → 边缘 → 部件 → 抽象特征 → 概率。

❓ 我当时真实的困惑

1. 为什么卷积核数量是32和64？不能是30吗？
2. 9216这个数字是怎么来的？
3. forward 里，数据尺寸到底是怎么一步步变化的？

这几个是非常典型、也非常值得认真回答的问题。

🔑首先回答第一个问题，可以是 30，但几乎没人这么做。

原因有三个，都是工程现实，不是玄学：

1️⃣ 最重要的是GPU 硬件对齐，因为现代 GPU 的运算单元（CUDA Core / Tensor Core）是按 2 的幂次并行工作的，能刚好对齐显存带宽和线程块（block），如果用30会出现padding / waste，计算效率下降，训练变慢。

2️⃣ 经验性容量设计，在第一层提取简单特征（边、角、点），32个通道足够覆盖常见低级模式；第二层组合成复杂结构（弧线、圈、部件），需要更多表示能力，64是实践中验证过的稳定选择

3️⃣ 历史惯性（LeNet 传统），很多教程只是继承这种翻倍增长​ 的设计，而不是重新发明

🔑其次是第二个问题，9216 不是玄学，是尺寸推导，是算出来的

✅ 已知前提

• 输入图片：28 × 28
• 卷积核：3 × 3
• padding：0
• stride：1

✅ 每一层尺寸变化

⚠️ 注意：不同实现可能略有差异，但常见版本最后会再接一个卷积或 padding，使最终特征图为64 × 12 × 12。

那么最终，9216 的来源就是

64 个通道 × 12 × 12 每个通道的特征图 = 9216

模型训练

整体来说，训练过程就是把一个 batch 的数据送进模型 → 算损失 → 反向传播 → 更新参数 → 记录日志，这是深度学习里“学习”发生的唯一地方

📌PyTorch 的数据是“流式”的，不是一次性全塞进去

def train(model, device, train_loader, optimizer, epoch, losses): model.train() for batch_idx, (data, target) in enumerate(train_loader): data, target = data.to(device), target.to(device) optimizer.zero_grad() output = model(data) loss = F.nll_loss(output, target) loss.backward() optimizer.step() losses.append(loss.item()) if batch_idx % 100 == 0: print( f'Epoch {epoch} ' f'[{batch_idx * len(data)}/{len(train_loader.dataset)} ' f'({100. * batch_idx / len(train_loader):.0f}%)]\t' f'Loss: {loss.item():.6f}' )

函数参数表含义如下所示：

首先要做的就是让模型切换到训练模式，使用model.train()，它告诉模型Dropout层开启随机失活，BatchNorm层使用当前batch 的均值/方差

如果有GPU，那么data, target = data.to(device), target.to(device)就是把数据搬到GPU

因为PyTorch默认梯度是累加的，所以使用optimizer.zero_grad()清空梯度，来给新的学习腾地方

而模型在这里的作用就是做前向传播，就是前面所将的流程：

Conv1 → ReLU → Conv2 → ReLU → Pool → Dropout → FC → Softmax

模型的输出output的形状是(batch_size, 10)

计算损失使用loss = F.nll_loss(output, target)，它衡量的是模型猜的有多离谱，其中nll_loss是负对数似然，target是真实标签（0~9），我们肯定是想要最小化损失函数的

反向传播（Backward Pass）是深度学习最核心的一行代码，可以自动计算∂Loss∂w，然后把
梯度存到每个参数的.grad属性里，核心是把“总错误”按责任比例分摊回去，对比正向传播，过程如下：

Loss ↓ ∂Loss/∂FC ↓ ∂FC/∂Pool ↓ ∂Pool/∂Conv2 ↓ ∂Conv2/∂Conv1 ↓ ∂Conv1/∂W

🔑有反向传播就可以自动学习，而不用手动调参

梯度告诉了方向，然后是优化器（Optimizer Step）optimizer.step()负责迈步子，读取.grad，根据优化规则更新参数，其中Adam 做的是：θ=θ−η⋅m√v+ϵ，这是“真正动手改模型”的地方

大致的训练流程就是这样，那么现在开始实际的训练吧。

def main(): # ========================================== # 1. 设备选择与配置 # ========================================== # 自动检测是否有可用的 GPU（CUDA） # 如果有则用 GPU 加速训练，否则回退到 CPU device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # ========================================== # 2. 模型与优化器初始化 # ========================================== # 实例化我们定义的 CNN 模型 # .to(device) 将模型的所有参数和缓冲区移动到指定设备（GPU/CPU） model = Net().to(device) # 使用 Adam 优化器 # model.parameters() 告诉优化器：需要更新哪些参数 # lr=0.001 是学习率，控制每次参数更新的步长 optimizer = optim.Adam(model.parameters(), lr=0.001) # ========================================== # 3. 数据预处理管道 # ========================================== # transforms.Compose 将多个变换组合成一个流水线 transform = transforms.Compose([ # 将 PIL 图像或 numpy.ndarray 转换为 PyTorch Tensor # 同时将像素值从 [0, 255] 缩放到 [0.0, 1.0] transforms.ToTensor(), # 标准化处理（Normalization） # 使用 MNIST 数据集的官方均值和标准差 # 公式: output = (input - mean) / std # 作用: 使数据分布均值为0，方差为1，加速模型收敛 transforms.Normalize((0.1307,), (0.3081,)) ]) # ========================================== # 4. 数据集与数据加载器 # ========================================== # 加载 MNIST 训练数据集 dataset = datasets.MNIST( './data', # 数据存储路径 train=True, # 使用训练集（而非测试集） download=True, # 如果数据不存在，自动从网上下载 transform=transform # 应用上面定义的数据预处理 ) # DataLoader 负责批量加载数据，并提供打乱、并行读取等功能 train_loader = DataLoader( dataset, # 要加载的数据集 batch_size=64, # 每个批次包含 64 个样本 shuffle=True # 每个 epoch 都打乱数据顺序（防止模型记忆顺序） ) # ========================================== # 5. 训练循环 # ========================================== # 用于记录每个 batch 的损失值，以便后续可视化 losses = [] # 训练 10 个 epoch（完整遍历数据集 10 次） for epoch in range(1, 11): # 调用我们定义的 train 函数 # 将模型、设备、数据加载器、优化器、当前轮次和损失列表传入 train(model, device, train_loader, optimizer, epoch, losses) # ========================================== # 6. 保存训练好的模型 # ========================================== # 保存模型的参数（state_dict） # 只保存参数而不保存整个模型是推荐做法，节省空间且灵活 torch.save(model.state_dict(), "mnist_cnn.pt") # ========================================== # 7. 可视化训练过程 # ========================================== # 创建一个 8x5 英寸大小的画布 plt.figure(figsize=(8, 5)) # 绘制损失曲线 # losses 列表记录了每个 batch 的损失值 plt.plot(losses, label="Training Loss") # 设置坐标轴标签 plt.xlabel("Batch") # X轴：批次索引 plt.ylabel("Loss") # Y轴：损失值 # 设置图表标题 plt.title("MNIST CNN Training Loss") # 显示网格线，便于观察数值 plt.grid(True) # 显示图例（对应 label="Training Loss"） plt.legend() # 自动调整子图参数，使之填充整个画布 plt.tight_layout() # 显示图形窗口 plt.show()

经过训练循环过程后，模型的犯错程度在不断的下降，如下图所示：

到这里，基本的训练过程就讲差不多了，那么一个epoch 里到底发生了什么？

Epoch 1 ├─ Batch 1: 猜 → 算错 → 改参数 ├─ Batch 2: 猜 → 算错 → 改参数 ├─ ... └─ Batch N: 猜 → 算错 → 改参数 Epoch 2 ├─ 猜得更准一点 ├─ Loss 更小 └─ ... Epoch 10 └─ 基本稳定

💡训练函数的本质，就是用损失函数告诉模型“你错在哪，再用反向传播告诉它“该怎么改”

模型测试

我使用了Forward Hook（前向钩子）方法，来达到可视化推理的中间过程，如下所示：

features = {} def hook(name): def fn(_, __, out): features[name] = out.detach() return fn # 注册钩子 model.conv1.register_forward_hook(get_features('conv1')) model.conv2.register_forward_hook(get_features('conv2')) model.dropout1.register_forward_hook(get_features('dropout1'))

进行测试时，加载之前训练好的模型权重，并开启model.eval()，同时需要注意模型定义要和训练时保持一致

device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model = Net().to(device) model.load_state_dict(torch.load("mnist_cnn.pt", map_location=device)) model.eval()

模型接受的输入需要先预处理一下，因为MNIST的图片有一定规范，比如尺寸、颜色等

# ============ 图片预处理 =============== img_path = "my_digit.png" img = Image.open(img_path).convert("L") # ✅ 白底黑字 → 黑底白字（MNIST 风格） img = ImageOps.invert(img) # resize 到 28×28 img = img.resize((28, 28), Image.LANCZOS) # 输入预处理 transform = T.Compose([ T.ToTensor(), T.Normalize((0.1307,), (0.3081,)) ]) # 获得模型输入 input_tensor = transform(img).unsqueeze(0).to(device)

最后就是模型推理代码了

# ========================================== # 推理模式（禁用梯度计算） # 作用：节省显存、加快计算、关闭 Dropout # ========================================== with torch.no_grad(): # ========================================== # 前向传播：让模型看这张图片 # output 形状: (1, 10) # 注意：这是 log_softmax 输出（对数概率） # ========================================== output = model(input_tensor) # ========================================== # 将对数概率转换回普通概率 # 公式: prob = exp(log_prob) # 作用：让人类能直观理解（0~1 之间） # ========================================== prob = torch.exp(output) # ========================================== # 找出概率最大的类别（预测结果） # argmax(dim=1): 在类别维度上找最大值索引 # item(): 把 Tensor 转成 Python 整数 # 结果: 0~9 的数字 # ========================================== pred = prob.argmax(dim=1).item() # ========================================== # 取出该类别的预测置信度 # prob[0, pred]: 第 0 个样本、预测类别上的概率值 # item(): 转成 Python 浮点数 # 结果: 0.0~1.0 之间的置信度 # ========================================== conf = prob[0, pred].item()

使用上面提到的钩子函数获取过程特征图，以Conv1举例：

conv1_feat = features['conv1'].squeeze().cpu() plt.figure(figsize=(12, 6)) for i in range(32): plt.subplot(4, 8, i+1) plt.imshow(conv1_feat[i], cmap='gray') plt.axis('off') plt.suptitle("Conv1: Edge Detectors") plt.show()

下面就是推理的中间过程图片，有4个，分别是conv1,conv2,dropout1以及全连接层的输出，如下所示：

1. Conv1 输出

32 张特征图，有的对竖边敏感，有的对横边敏感，有的对角点敏感

1. Conv2 输出

不再是简单边缘，开始出现：圈、弧线、局部形状

1. Pooling + Dropout输出

池化在“做减法”（精简信息），Dropout 在“做干扰”（增强韧性）