基于102数据集的神经网络花朵分类实战：从数据预处理到模型部署全流程解析

1次阅读

共计 4963 个字符，预计需要花费 13 分钟才能阅读完成。

102 数据集（Oxford 102 Flowers Dataset）是一个专门用于花朵分类任务的经典数据集，包含 102 种英国常见花卉的图片，每种花卉有 40 到 258 张不等的高质量图像。这些图像在尺度、光照和姿态上存在较大差异，非常适合用于训练具有鲁棒性的分类模型。花朵分类在植物学研究、园艺应用和自动化识别系统中有着广泛的应用场景。

数据预处理是机器学习项目中至关重要的一环，对于图像分类任务尤其如此。我们需要确保输入数据格式统一且适合模型训练。以下是完整的预处理流程：

数据加载和检查

from torchvision.datasets import Flowers102
import matplotlib.pyplot as plt

# 加载数据集
train_dataset = Flowers102(root='./data', split='train', download=True)
val_dataset = Flowers102(root='./data', split='val', download=True)
test_dataset = Flowers102(root='./data', split='test', download=True)

# 检查数据样本
img, label = train_dataset[0]
plt.imshow(img)
plt.title(f'Label: {label}')
plt.show()

数据增强和标准化

from torchvision import transforms

# 定义训练集转换
train_transform = transforms.Compose([transforms.RandomResizedCrop(224),  # 随机裁剪并调整大小
    transforms.RandomHorizontalFlip(),  # 随机水平翻转
    transforms.RandomRotation(30),      # 随机旋转
    transforms.ToTensor(),              # 转为 Tensor
    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])  # 标准化
])

# 验证和测试集转换（不包含数据增强）val_transform = transforms.Compose([transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])

# 重新加载数据集并应用转换
train_dataset.transform = train_transform
val_dataset.transform = val_transform
test_dataset.transform = val_transform

创建数据加载器

from torch.utils.data import DataLoader

batch_size = 32

train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)

对于 102 花朵分类任务，我们可以选择多种神经网络架构。以下是几种常见模型的对比：

ResNet：深度残差网络，通过跳跃连接解决梯度消失问题，适合中等规模数据集
EfficientNet：通过复合缩放实现高效计算，在资源有限时表现优异
MobileNet：专为移动设备设计，轻量但效果不错
VGG：结构简单但参数量大，适合作为基准模型

我们选择 ResNet18 作为基础模型：

import torch.nn as nn
from torchvision import models

# 加载预训练模型
model = models.resnet18(pretrained=True)

# 修改最后一层全连接层
num_features = model.fc.in_features
model.fc = nn.Linear(num_features, 102)  # 102 分类任务

# 将模型转移到 GPU（如果可用）device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = model.to(device)

训练神经网络需要仔细配置超参数和监控训练过程：

损失函数和优化器

import torch.optim as optim

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

训练循环

num_epochs = 20

train_losses = []
val_accuracies = []

for epoch in range(num_epochs):
    # 训练阶段
    model.train()
    running_loss = 0.0

    for images, labels in train_loader:
        images = images.to(device)
        labels = labels.to(device)

        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()

    epoch_loss = running_loss / len(train_loader)
    train_losses.append(epoch_loss)

    # 验证阶段
    model.eval()
    correct = 0
    total = 0

    with torch.no_grad():
        for images, labels in val_loader:
            images = images.to(device)
            labels = labels.to(device)

            outputs = model(images)
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()

    val_accuracy = 100 * correct / total
    val_accuracies.append(val_accuracy)

    print(f'Epoch {epoch+1}/{num_epochs}, Loss: {epoch_loss:.4f}, Val Acc: {val_accuracy:.2f}%')

可视化训练过程

plt.figure(figsize=(12, 4))

# 训练损失
plt.subplot(1, 2, 1)
plt.plot(train_losses, label='Training Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('Training Loss Over Epochs')
plt.legend()

# 验证准确率
plt.subplot(1, 2, 2)
plt.plot(val_accuracies, label='Validation Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy (%)')
plt.title('Validation Accuracy Over Epochs')
plt.legend()

plt.tight_layout()
plt.show()

模型训练完成后，我们需要在测试集上评估其性能：

计算测试集准确率

model.eval()
correct = 0
total = 0

with torch.no_grad():
    for images, labels in test_loader:
        images = images.to(device)
        labels = labels.to(device)

        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f'Test Accuracy: {100 * correct / total:.2f}%')

绘制混淆矩阵

from sklearn.metrics import confusion_matrix
import seaborn as sns
import numpy as np

# 收集所有预测和真实标签
all_preds = []
all_labels = []

with torch.no_grad():
    for images, labels in test_loader:
        images = images.to(device)
        labels = labels.to(device)

        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)

        all_preds.extend(predicted.cpu().numpy())
        all_labels.extend(labels.cpu().numpy())

# 计算混淆矩阵
cm = confusion_matrix(all_labels, all_preds)

# 可视化
plt.figure(figsize=(20, 20))
sns.heatmap(cm, annot=False, fmt='d', cmap='Blues')
plt.xlabel('Predicted')
plt.ylabel('True')
plt.title('Confusion Matrix')
plt.show()

在花朵分类任务中，我们可能会遇到以下常见问题：

过拟合
解决方案：增加数据增强、添加 Dropout 层、使用权重衰减（L2 正则化）、早停法
数据不平衡
解决方案：类别加权损失函数、过采样少数类或欠采样多数类
训练不稳定
解决方案：调整学习率、使用学习率调度器、梯度裁剪
模型性能不佳
解决方案：尝试更复杂的模型架构、调整超参数、检查数据预处理流程

将训练好的模型部署到实际应用中需要考虑以下几点：

模型量化：减小模型大小，提高推理速度

quantized_model = torch.quantization.quantize_dynamic(model, {torch.nn.Linear}, dtype=torch.qint8
)

创建预测接口

from PIL import Image

def predict_flower(image_path, model, transform):
    img = Image.open(image_path)
    img = transform(img).unsqueeze(0).to(device)

    model.eval()
    with torch.no_grad():
        output = model(img)
        _, predicted = torch.max(output, 1)

    return predicted.item()