基于PaddlePaddle实现图像分类经典模型

基于PaddlePaddle实现图像分类经典模型

在医疗影像诊断、工业质检甚至手机相册自动分类中，图像分类技术无处不在。它看似简单——给一张图打个标签，但背后却凝聚了几代深度学习架构的演进智慧。从最早的LeNet到如今广泛应用的ResNet，每一次突破都推动着AI视觉能力的边界。

而要真正掌握这些模型，光看论文远远不够。动手复现、调试、训练，才能理解为何ReLU比Sigmoid更适合深层网络，为什么1×1卷积能“四两拨千斤”，以及残差连接如何让上百层的网络依然稳定收敛。

本文就以百度飞桨（PaddlePaddle）为工具，带你从零实现五大经典图像分类模型：LeNet、AlexNet、VGG、GoogLeNet 和 ResNet。我们不只贴代码，更会穿插工程实践中的关键考量——比如数据加载器怎么写才高效，损失函数如何选择，训练过程怎样监控。所有代码均基于paddle >= 2.5动态图模式编写，兼容 AI Studio 平台，可直接运行验证。

数据预处理与加载：别小看这一步

很多初学者一上来就想搭模型，结果卡在数据上。其实，一个健壮的数据管道是训练成功的前提。本文使用iChallenge-PM 眼疾识别数据集，包含1200张眼底图像，任务是判断是否存在“病理性近视”（PM），属于典型的医学图像二分类问题。

这类任务的特点是样本少、类别敏感、图像质量差异大。因此我们的预处理策略如下：

• 统一缩放到 224×224（适配主流模型输入）
• 归一化至 [-1, 1] 区间，提升训练稳定性
• 使用 OpenCV 读取图像，避免 PIL 对某些格式支持不佳的问题

import cv2 import os import random import numpy as np import paddle def transform_img(img): """图像预处理：缩放 + 转置 + 归一化""" img = cv2.resize(img, (224, 224)) img = np.transpose(img, (2, 0, 1)) # HWC -> CHW img = img.astype('float32') / 255. img = img * 2.0 - 1.0 # [0,1] -> [-1,1] return img def data_loader(datadir, batch_size=10, mode='train'): filenames = os.listdir(datadir) def reader(): if mode == 'train': random.shuffle(filenames) batch_imgs, batch_labels = [], [] for name in filenames: filepath = os.path.join(datadir, name) img = cv2.imread(filepath) img = transform_img(img) label = 1 if name.startswith('P') else 0 # P: PM positive batch_imgs.append(img) batch_labels.append(label) if len(batch_imgs) == batch_size: yield np.array(batch_imgs), np.array(batch_labels).reshape(-1, 1) batch_imgs, batch_labels = [], [] if batch_imgs: yield np.array(batch_imgs), np.array(batch_labels).reshape(-1, 1) return reader # 测试数据读取器 DATADIR = './data/PALM-Training400' loader = data_loader(DATADIR, batch_size=4) data_iter = loader() img_batch, label_batch = next(data_iter) print("Batch shape:", img_batch.shape, label_batch.shape) # 输出: Batch shape: (4, 3, 224, 224) (4, 1)

这里我们没有用paddle.io.DataLoader，而是手写了一个生成器式reader，原因很简单：灵活且轻量。尤其在AI Studio等资源受限环境中，避免引入复杂封装带来的内存开销。当然，后期可以无缝替换为高层API。

值得一提的是，返回格式(N, C, H, W)是Paddle和PyTorch的标准，如果你习惯TensorFlow的(N, H, W, C)，记得及时转置，否则训练会静默失败。

训练流程定义：一套通用逻辑跑通所有模型

与其每个模型写一遍训练循环，不如封装一个通用的train函数。这样既能保证实验一致性，也便于后续对比分析。

def train(model, train_loader, valid_loader, epochs=5, lr=0.001, save_path='checkpoint/model'): print('开始训练...') optim = paddle.optimizer.Momentum( learning_rate=lr, momentum=0.9, parameters=model.parameters() ) loss_fn = paddle.nn.BCEWithLogitsLoss() # 二分类专用 for epoch in range(epochs): model.train() for batch_id, (x, y) in enumerate(train_loader()): x_tensor = paddle.to_tensor(x) y_tensor = paddle.to_tensor(y, dtype='float32') logits = model(x_tensor) loss = loss_fn(logits, y_tensor) if batch_id % 10 == 0: print(f"Epoch[{epoch}], Step[{batch_id}], Loss: {loss.numpy().item():.4f}") loss.backward() optim.step() optim.clear_grad() # 验证阶段 model.eval() accs, losses = [], [] with paddle.no_grad(): for val_x, val_y in valid_loader(): x_tensor = paddle.to_tensor(val_x) y_tensor = paddle.to_tensor(val_y, dtype='float32') logits = model(x_tensor) pred = paddle.nn.functional.sigmoid(logits) acc = ((pred > 0.5) == y_tensor).numpy().mean() loss = loss_fn(logits, y_tensor).numpy().item() accs.append(acc) losses.append(loss) print(f"[验证] Epoch {epoch} | 准确率: {np.mean(accs):.4f} | 损失: {np.mean(losses):.4f}") # 保存模型权重 paddle.save(model.state_dict(), f"{save_path}.pdparams") paddle.save(optim.state_dict(), f"{save_path}.pdopt") print("模型已保存。")

几个细节值得强调：

• 使用BCEWithLogitsLoss而非先sigmoid再BCELoss，数值更稳定；
• 验证阶段关闭梯度计算（paddle.no_grad()），节省显存；
• 模型状态在train()和eval()之间切换，确保Dropout、BatchNorm行为正确；
• 优化器选用带动量的SGD，对于小型数据集反而比Adam更鲁棒。

这套流程我们将反复用于后续所有模型，真正做到“一次定义，多次复用”。

模型评估方法：不只是准确率

训练完不评估等于白干。除了整体准确率，我们还需要知道模型在每一类上的表现，尤其是医学场景下，假阴性代价极高。

def evaluate(model, params_path): print("开始评估...") state_dict = paddle.load(params_path) model.set_state_dict(state_dict) model.eval() eval_loader = data_loader('./data/PALM-Validation400', batch_size=8, mode='eval') preds, labels = [], [] with paddle.no_grad(): for x, y in eval_loader(): x_tensor = paddle.to_tensor(x) logits = model(x_tensor) prob = paddle.nn.functional.sigmoid(logits) pred_label = (prob > 0.5).numpy().astype(int) preds.extend(pred_label.flatten().tolist()) labels.extend(y.flatten().tolist()) from sklearn.metrics import accuracy_score, classification_report acc = accuracy_score(labels, preds) print(f"测试集准确率: {acc:.4f}") print("\n详细分类报告:\n", classification_report(labels, preds))

通过classification_report可以看到精确率（precision）、召回率（recall）和F1-score，帮助判断模型是否偏向某一类。例如，若“病理性近视”的召回率很低，说明漏诊风险高，即便总体准确率尚可也不宜上线。

LeNet：从历史中汲取设计智慧

提到CNN，很多人第一反应是ResNet或Vision Transformer，但真正奠定基础的是1998年的LeNet。虽然原始版本用于MNIST手写数字识别（32×32灰度图），但它确立了“卷积→池化→全连接”的基本范式。

我们将它适配到当前任务：RGB三通道、224×224输入。

import paddle.nn as nn class LeNet(nn.Layer): def __init__(self, num_classes=1): super().__init__() self.features = nn.Sequential( nn.Conv2D(3, 6, 5, padding=2), nn.Sigmoid(), nn.MaxPool2D(2), nn.Conv2D(6, 16, 5), nn.Sigmoid(), nn.MaxPool2D(2), nn.Conv2D(16, 120, 4), nn.Sigmoid() ) self.classifier = nn.Sequential( nn.Linear(120 * 5 * 5, 64), nn.Sigmoid(), nn.Linear(64, num_classes) ) def forward(self, x): x = self.features(x) x = paddle.flatten(x, start_axis=1) x = self.classifier(x) return x

注意：
- 第三层卷积后不再池化，导致特征图尺寸为 5×5；
- 全连接层输入维度需根据实际输出计算，此处为120 * 5 * 5 = 30000；
- 使用Sigmoid激活，虽已被ReLU取代，但有助于理解早期设计局限。

📌 实验结果显示，LeNet 在本任务上验证准确率约82%~85%，收敛慢且易陷入局部最优。这并不意外——浅层网络难以捕捉医学图像的复杂纹理和细微病变。

但它仍有教学价值：结构清晰、参数极少，适合初学者理解前向传播与反向传播机制。

AlexNet：ReLU开启深度学习新时代

如果说LeNet是启蒙者，那2012年的AlexNet就是引爆点。它在ImageNet竞赛中以超过第二名10个百分点的成绩夺冠，彻底改变了计算机视觉格局。

其成功并非偶然，而是多项关键技术的组合拳：

• ReLU激活函数：相比Sigmoid，缓解梯度消失，加速收敛；
• Dropout：随机屏蔽神经元，有效抑制过拟合；
• GPU并行训练：首次大规模使用CUDA进行模型训练；
• 数据增强：随机裁剪、翻转、色彩抖动，扩充有效样本。

class AlexNet(nn.Layer): def __init__(self, num_classes=1): super().__init__() self.features = nn.Sequential( nn.Conv2D(3, 96, 11, stride=4, padding=2), nn.ReLU(), nn.MaxPool2D(3, stride=2), nn.Conv2D(96, 256, 5, padding=2), nn.ReLU(), nn.MaxPool2D(3, stride=2), nn.Conv2D(256, 384, 3, padding=1), nn.ReLU(), nn.Conv2D(384, 384, 3, padding=1), nn.ReLU(), nn.Conv2D(384, 256, 3, padding=1), nn.ReLU(), nn.MaxPool2D(3, stride=2), ) self.avgpool = nn.AdaptiveAvgPool2D((6, 6)) self.classifier = nn.Sequential( nn.Dropout(0.5), nn.Linear(256 * 6 * 6, 4096), nn.ReLU(), nn.Dropout(0.5), nn.Linear(4096, 4096), nn.ReLU(), nn.Linear(4096, num_classes) ) def forward(self, x): x = self.features(x) x = self.avgpool(x) x = paddle.flatten(x, 1) x = self.classifier(x) return x

关键改动：
- 使用AdaptiveAvgPool2D自动匹配全连接层输入，避免手动计算；
- 分类器中加入两个Dropout层，防止过拟合；
- 所有激活函数统一为ReLU。

✅ 经5轮训练后，验证准确率可达93%以上，显著优于LeNet。这也印证了：非线性激活的选择对深层网络至关重要。

VGG：用深度换取表达能力

2014年，牛津大学提出的VGG系列模型证明了一个朴素但有效的理念：只要足够深，小卷积核也能赢。

VGG的核心思想是：
- 全部使用 3×3 卷积，堆叠多层模拟大感受野；
- 结构规整，易于实现和迁移；
- 深度增加带来更强的特征抽象能力。

def make_vgg_block(num_convs, in_channels, out_channels): layers = [] for _ in range(num_convs): layers.append(nn.Conv2D(in_channels, out_channels, 3, padding=1)) layers.append(nn.ReLU()) in_channels = out_channels layers.append(nn.MaxPool2D(2, 2)) return nn.Sequential(*layers) class VGG(nn.Layer): def __init__(self, conv_arch=((2, 64), (2, 128), (3, 256), (3, 512), (3, 512))): super().__init__() self.features = nn.Sequential() in_channels = 3 for i, (num_conv, out_channels) in enumerate(conv_arch): block = make_vgg_block(num_conv, in_channels, out_channels) self.features.add_sublayer(f'block_{i}', block) in_channels = out_channels self.classifier = nn.Sequential( nn.Linear(512 * 7 * 7, 4096), nn.ReLU(), nn.Dropout(0.5), nn.Linear(4096, 4096), nn.ReLU(), nn.Dropout(0.5), nn.Linear(4096, 1) ) def forward(self, x): x = self.features(x) x = paddle.flatten(x, 1) x = self.classifier(x) return x

尽管VGG参数量巨大（VGG16约1.38亿），但在本任务中仍表现出色，验证准确率稳定在94%左右。这说明：对于有一定复杂度的图像（如眼底图），模型容量必须足够大才能充分学习判别性特征。

不过也要警惕：VGG训练耗时长、显存占用高，在资源有限时应优先考虑更高效的架构。

GoogLeNet：宽度胜于深度？

就在大家拼命堆深度时，Google提出了GoogLeNet（Inception v1），走了一条不同路线：多路径并行 + 1×1降维。

其核心模块 Inception 的设计非常巧妙：
- 同时使用 1×1、3×3、5×5 卷积提取多尺度特征；
- 引入最大池化分支补充上下文信息；
- 关键是用 1×1 卷积先降维，大幅减少计算量。

class Inception(nn.Layer): def __init__(self, c1, c2, c3, c4): super().__init__() self.p1 = nn.Conv2D(192, c1, 1, act='relu') self.p2 = nn.Sequential( nn.Conv2D(192, c2[0], 1, act='relu'), nn.Conv2D(c2[0], c2[1], 3, padding=1, act='relu') ) self.p3 = nn.Sequential( nn.Conv2D(192, c3[0], 1, act='relu'), nn.Conv2D(c3[0], c3[1], 5, padding=2, act='relu') ) self.p4 = nn.Sequential( nn.MaxPool2D(3, stride=1, padding=1), nn.Conv2D(192, c4, 1, act='relu') ) def forward(self, x): return paddle.concat([self.p1(x), self.p2(x), self.p3(x), self.p4(x)], axis=1)

整个GoogLeNet由多个Inception模块串联而成。由于完整结构较复杂，我们实现一个简化版主干即可体验其优势。

🎯 实验表明，GoogLeNet在参数更少的情况下达到约95%准确率，推理速度也更快，非常适合移动端部署。

ResNet：残差连接破解“退化难题”

当网络加深到几十层后，一个新的问题出现了：更深 ≠ 更好。训练误差反而上升，这就是所谓的“网络退化”问题。

何恺明提出的ResNet给出优雅解法：残差学习。通过跳跃连接（skip connection），让网络学会“增量更新”，即使新增层什么都不学，也能保持原样输出。

class ResidualBlock(nn.Layer): def __init__(self, in_channels, out_channels, stride=1, shortcut=False): super().__init__() self.conv1 = nn.Conv2D(in_channels, out_channels, 3, stride, padding=1) self.bn1 = nn.BatchNorm2D(out_channels) self.conv2 = nn.Conv2D(out_channels, out_channels, 3, padding=1) self.bn2 = nn.BatchNorm2D(out_channels) if not shortcut: self.shortcut = nn.Sequential( nn.Conv2D(in_channels, out_channels, 1, stride), nn.BatchNorm2D(out_channels) ) else: self.shortcut = None def forward(self, x): residual = x out = self.conv1(x) out = self.bn1(out) out = nn.functional.relu(out) out = self.conv2(out) out = self.bn2(out) if self.shortcut is not None: residual = self.shortcut(x) out += residual out = nn.functional.relu(out) return out

残差块的设计看似简单，实则精妙：
- 主路径负责学习变换；
- 短接路径保留原始信息；
- 两者相加实现“恒等映射优先”。

最终的ResNetSmall模型由多个残差块堆叠而成，在相同训练条件下达到最高准确率 ~96%，展现出极强的泛化能力和训练稳定性。

技术演进背后的启示

回顾这五个模型的发展脉络，我们能看到一条清晰的技术主线：

它们不仅是学术成果，更是工程智慧的结晶。今天我们在PaddlePaddle中几行代码就能调用resnet50(pretrained=True)，但理解其背后的设计哲学，才能在面对新问题时做出合理决策。

下一步你可以做什么？

1. 尝试预训练模型：
   python from paddle.vision.models import resnet50 model = resnet50(pretrained=True)
   加载ImageNet预训练权重，再微调（fine-tune），小样本任务性能将大幅提升。

2. 使用高层API简化流程：
   替换自定义训练循环为paddle.Model，代码更简洁，功能更强大：
   python model = paddle.Model(ResNetSmall()) model.prepare(optimizer=..., loss=..., metrics=...) model.fit(train_loader, epochs=5)

3. 模型压缩与部署：
   利用PaddleSlim进行剪枝、量化，降低模型体积；结合Paddle Lite部署到移动端或嵌入式设备。

4. 可视化分析：
   接入VisualDL查看训练曲线、梯度分布、特征图热力图，深入理解模型行为。

🔧推荐实践平台：AI Studio —— 提供免费GPU资源和完整PaddlePaddle环境，无需配置即可上手项目。

本文源于PaddlePaddle官方实践教程，旨在帮助开发者掌握经典模型实现技巧。欢迎访问飞桨GitHub仓库 github.com/PaddlePaddle/Paddle 获取最新动态，共同推进国产深度学习生态发展。