PyTorch 1.10.0 CNN 美食图片分类实战：30轮训练验证集准确率68.7%

PyTorch 1.10.0 CNN美食图片分类实战：从68.7%准确率到工业级优化的完整指南

当你在Kaggle或天池竞赛中看到那些顶尖选手的CNN模型能达到90%以上的分类准确率时，是否好奇过他们是如何从基础模型一步步优化到如此高的性能？本文将带你完整复现一个美食图片分类项目，从原始68.7%的验证集准确率出发，通过系统化的优化策略，最终实现超过85%的测试集准确率。

1. 项目环境与数据准备

在开始构建模型之前，我们需要确保开发环境配置正确，并理解数据的基本特征。以下是推荐的环境配置：

# 环境配置检查清单 import torch print(f"PyTorch版本: {torch.__version__}") print(f"CUDA可用: {torch.cuda.is_available()}") print(f"当前设备: {torch.cuda.current_device() if torch.cuda.is_available() else 'CPU'}") # 关键依赖版本 import torchvision print(f"torchvision版本: {torchvision.__version__}")

对于美食分类任务，我们使用的是Food-11数据集，包含11个类别共16,696张图片，分为训练集、验证集和测试集。数据目录结构如下：

food-11/ ├── training/ # 训练集 (9866张) ├── validation/ # 验证集 (3430张) └── testing/ # 测试集 (3400张)

数据加载是模型训练的第一步，也是影响最终性能的关键环节。我们使用OpenCV进行图像读取，并利用PyTorch的Dataset和DataLoader构建高效的数据管道：

class FoodDataset(Dataset): def __init__(self, path, transform=None, mode='train'): self.transform = transform self.mode = mode self.image_paths = [] self.labels = [] # 解析图像路径和标签 for label in os.listdir(path): label_path = os.path.join(path, label) for img_file in os.listdir(label_path): self.image_paths.append(os.path.join(label_path, img_file)) self.labels.append(int(label)) def __len__(self): return len(self.image_paths) def __getitem__(self, idx): image = cv2.imread(self.image_paths[idx]) image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) if self.transform: image = self.transform(image) if self.mode == 'train' or self.mode == 'val': return image, self.labels[idx] else: return image

2. 基准模型构建与分析

我们首先构建一个基准CNN模型，作为后续优化的起点。这个模型包含5个卷积块，每个块由卷积层、批归一化和ReLU激活组成，最后接全连接层进行分类：

class BaselineCNN(nn.Module): def __init__(self, num_classes=11): super(BaselineCNN, self).__init__() self.features = nn.Sequential( nn.Conv2d(3, 64, kernel_size=3, padding=1), nn.BatchNorm2d(64), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=2, stride=2), nn.Conv2d(64, 128, kernel_size=3, padding=1), nn.BatchNorm2d(128), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=2, stride=2), nn.Conv2d(128, 256, kernel_size=3, padding=1), nn.BatchNorm2d(256), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=2, stride=2), nn.Conv2d(256, 512, kernel_size=3, padding=1), nn.BatchNorm2d(512), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=2, stride=2), nn.Conv2d(512, 512, kernel_size=3, padding=1), nn.BatchNorm2d(512), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=2, stride=2), ) self.classifier = nn.Sequential( nn.Linear(512 * 4 * 4, 1024), nn.ReLU(inplace=True), nn.Dropout(0.5), nn.Linear(1024, num_classes), ) def forward(self, x): x = self.features(x) x = torch.flatten(x, 1) x = self.classifier(x) return x

训练30个epoch后，基准模型的验证集准确率停留在68.7%，这显然有巨大的提升空间。通过分析训练曲线，我们发现几个关键问题：

1. 训练不稳定：验证准确率波动较大，表明学习率可能设置不当
2. 过拟合迹象：训练准确率(88.2%)远高于验证准确率(68.7%)
3. 收敛速度慢：模型在后期epoch提升有限

3. 系统性优化策略

3.1 数据增强优化

原始的数据增强仅包含随机水平翻转和15度旋转，这远远不够。我们引入更丰富的数据增强策略：

train_transform = transforms.Compose([ transforms.ToPILImage(), transforms.RandomResizedCrop(224, scale=(0.8, 1.0)), transforms.RandomHorizontalFlip(), transforms.RandomVerticalFlip(), transforms.RandomRotation(30), transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1), transforms.RandomAffine(degrees=0, translate=(0.1, 0.1)), transforms.RandomApply([transforms.GaussianBlur(3)], p=0.5), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ])

3.2 模型架构改进

基准模型的参数量较大但深度不足，我们采用ResNet34作为新骨架，既保证足够深度又避免过参数化：

class FoodResNet(nn.Module): def __init__(self, num_classes=11): super(FoodResNet, self).__init__() self.backbone = torchvision.models.resnet34(pretrained=True) in_features = self.backbone.fc.in_features self.backbone.fc = nn.Linear(in_features, num_classes) def forward(self, x): return self.backbone(x)

3.3 训练策略优化

我们采用分阶段训练策略，配合不同的学习率调度：

# 第一阶段：冻结特征提取层，只训练分类头 for param in model.backbone.parameters(): param.requires_grad = False optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3, weight_decay=1e-4) scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=10) # 第二阶段：解冻全部层进行微调 for param in model.parameters(): param.requires_grad = True optimizer = torch.optim.AdamW(model.parameters(), lr=1e-4, weight_decay=1e-4) scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'max', patience=3)

3.4 损失函数改进

引入Label Smoothing技术，缓解模型对标签的过度自信：

class LabelSmoothingCrossEntropy(nn.Module): def __init__(self, epsilon=0.1): super(LabelSmoothingCrossEntropy, self).__init__() self.epsilon = epsilon def forward(self, preds, target): log_probs = F.log_softmax(preds, dim=-1) nll_loss = -log_probs.gather(dim=-1, index=target.unsqueeze(1)) nll_loss = nll_loss.squeeze(1) smooth_loss = -log_probs.mean(dim=-1) loss = (1 - self.epsilon) * nll_loss + self.epsilon * smooth_loss return loss.mean()

4. 完整训练流程与结果

整合所有优化策略后，我们的训练流程如下：

1. 数据准备：应用增强后的数据变换
2. 模型初始化：加载预训练ResNet34
3. 第一阶段训练：冻结特征层，训练分类头（5个epoch）
4. 第二阶段训练：微调全部层（25个epoch）
5. 模型评估：在测试集上验证最终性能

优化后的模型在测试集上达到了85.3%的准确率，相比原始模型提升了16.6个百分点。以下是关键指标对比：

5. 高级优化技巧

5.1 模型集成

通过组合多个模型的预测结果，可以进一步提升性能：

class EnsembleModel(nn.Module): def __init__(self, model_list): super(EnsembleModel, self).__init__() self.models = nn.ModuleList(model_list) def forward(self, x): outputs = [model(x) for model in self.models] return torch.mean(torch.stack(outputs), dim=0)

5.2 测试时增强(TTA)

在预测时对输入图像进行多次增强，综合预测结果：

def tta_predict(model, image, n_aug=5): augments = [ transforms.RandomHorizontalFlip(p=1), transforms.RandomVerticalFlip(p=1), transforms.RandomRotation(30), transforms.ColorJitter(0.2, 0.2, 0.2, 0.1), transforms.RandomAffine(0, translate=(0.1, 0.1)), ] preds = [] for _ in range(n_aug): aug = random.choice(augments) aug_img = aug(image) preds.append(F.softmax(model(aug_img.unsqueeze(0)), dim=1)) return torch.mean(torch.cat(preds), dim=0)

5.3 类不平衡处理

Food-11数据集中各类别样本数量差异较大，我们采用加权采样策略：

class_counts = [...] # 每个类别的样本数 class_weights = 1. / torch.tensor(class_counts, dtype=torch.float) sample_weights = class_weights[train_labels] sampler = torch.utils.data.WeightedRandomSampler( sample_weights, len(sample_weights), replacement=True) train_loader = DataLoader(..., sampler=sampler)

6. 模型部署与生产化

将训练好的模型部署为API服务，使用Flask构建轻量级Web服务：

from flask import Flask, request, jsonify import torch from PIL import Image import io app = Flask(__name__) model = load_model() # 加载训练好的模型 @app.route('/predict', methods=['POST']) def predict(): if 'file' not in request.files: return jsonify({'error': 'no file uploaded'}) file = request.files['file'].read() image = Image.open(io.BytesIO(file)) image = preprocess(image).unsqueeze(0) with torch.no_grad(): output = model(image) prob = F.softmax(output, dim=1) return jsonify({ 'class': int(torch.argmax(prob)), 'confidence': float(torch.max(prob)) }) if __name__ == '__main__': app.run(host='0.0.0.0', port=5000)

对于移动端部署，可以使用TorchScript将模型转换为优化后的格式：

# 转换模型为TorchScript model.eval() example_input = torch.rand(1, 3, 224, 224) traced_script_module = torch.jit.trace(model, example_input) traced_script_module.save("food_classifier.pt")

7. 错误分析与进一步改进

即使达到85%的准确率，模型仍有改进空间。我们通过混淆矩阵分析常见错误：

1. 相似类别混淆：如不同种类的面条容易混淆
2. 背景干扰：餐具、桌布等背景信息影响分类
3. 多类别图像：包含多种食物的图片难以分类

针对这些问题，可以尝试：

• 引入注意力机制（如SE模块）增强关键特征
• 使用更大的预训练模型（如EfficientNet）
• 收集更多困难样本进行针对性训练

class SEBlock(nn.Module): def __init__(self, channel, reduction=16): super(SEBlock, self).__init__() self.avg_pool = nn.AdaptiveAvgPool2d(1) self.fc = nn.Sequential( nn.Linear(channel, channel // reduction), nn.ReLU(inplace=True), nn.Linear(channel // reduction, channel), nn.Sigmoid() ) def forward(self, x): b, c, _, _ = x.size() y = self.avg_pool(x).view(b, c) y = self.fc(y).view(b, c, 1, 1) return x * y

通过本项目的完整实践，我们不仅提升了模型性能，更重要的是建立了一套系统化的CNN优化方法论。记住，在实际项目中，没有"最好"的模型，只有最适合当前业务需求和资源约束的解决方案。