### 使用卷积神经网络进行猫狗分类的 Python 实现 以下是基于 PyTorch 的 VGG-16 架构实现猫狗分类的任务代码，并附带训练过程中的损失函数和准确率变化的可视化部分。 #### 安装依赖库 在运行以下代码之前，请确保安装必要的库： ```bash pip install torch torchvision matplotlib numpy pandas scikit-learn ``` #### 数据准备 假设已下载并解压了猫狗分类数据集[^4]，并将文件夹路径设置为 `data_path`。 #### 代码实现 以下是一个完整的猫狗分类模型构建、训练以及可视化的流程： ```python import os import torch from torch import nn, optim from torch.utils.data import DataLoader from torchvision import datasets, transforms, models import matplotlib.pyplot as plt import numpy as np # 设置设备 device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') # 数据预处理 transform = { 'train': transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]), 'val': transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) } # 加载数据集 data_dir = './data/dogs_vs_cats' image_datasets = {x: datasets.ImageFolder(os.path.join(data_dir, x), transform[x]) for x in ['train', 'val']} dataloaders = {x: DataLoader(image_datasets[x], batch_size=32, shuffle=True) for x in ['train', 'val']} # 获取类别名称 class_names = image_datasets['train'].classes # 初始化模型 model = models.vgg16(pretrained=True) for param in model.parameters(): param.requires_grad = False num_ftrs = model.classifier[6].in_features model.classifier[6] = nn.Linear(num_ftrs, 2) model.to(device) # 定义损失函数和优化器 criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.classifier.parameters(), lr=0.001) # 训练模型 def train_model(dataloaders, model, criterion, optimizer, num_epochs=10): losses = {'train': [], 'val': []} accuracies = {'train': [], 'val': []} best_acc = 0.0 for epoch in range(num_epochs): print(f'Epoch {epoch}/{num_epochs - 1}') print('-' * 10) for phase in ['train', 'val']: if phase == 'train': model.train() else: model.eval() running_loss = 0.0 corrects = 0 for inputs, labels in dataloaders[phase]: inputs, labels = inputs.to(device), labels.to(device) optimizer.zero_grad() with torch.set_grad_enabled(phase == 'train'): outputs = model(inputs) _, preds = torch.max(outputs, 1) loss = criterion(outputs, labels) if phase == 'train': loss.backward() optimizer.step() running_loss += loss.item() * inputs.size(0) corrects += torch.sum(preds == labels.data) epoch_loss = running_loss / len(dataloaders[phase].dataset) epoch_acc = corrects.double() / len(dataloaders[phase].dataset) print(f'{phase} Loss: {epoch_loss:.4f}, Acc: {epoch_acc:.4f}') losses[phase].append(epoch_loss) accuracies[phase].append(epoch_acc.item()) if phase == 'val' and epoch_acc > best_acc: best_acc = epoch_acc best_model_wts = model.state_dict() model.load_state_dict(best_model_wts) return model, losses, accuracies # 开始训练 model_trained, losses, accuracies = train_model(dataloaders, model, criterion, optimizer, num_epochs=10) # 可视化结果 plt.figure(figsize=(12, 5)) # 绘制损失曲线 plt.subplot(1, 2, 1) plt.plot(losses['train'], label='Train') plt.plot(losses['val'], label='Validation') plt.title('Training & Validation Loss') plt.xlabel('Epochs') plt.ylabel('Loss') plt.legend() # 绘制准确率曲线 plt.subplot(1, 2, 2) plt.plot(accuracies['train'], label='Train') plt.plot(accuracies['val'], label='Validation') plt.title('Training & Validation Accuracy') plt.xlabel('Epochs') plt.ylabel('Accuracy') plt.legend() plt.show() ``` 以上代码实现了以下几个功能： 1. **数据加载与增强**：通过 `transforms` 对图像进行了随机裁剪、水平翻转等操作以增加样本多样性[^4]。 2. **模型初始化**：使用预训练的 VGG-16 模型作为基础架构，并修改最后一层适配二分类任务[^4]。 3. **训练循环**：定义了一个通用的训练函数，记录每轮次的损失值和准确率。 4. **可视化**：绘制了训练过程中损失值和准确率的变化趋势图[^4]。 --- ###