Python----神经网络（基于AlexNet的猫狗分类项目）

一、基于AlexNet的猫狗分类

1.1、项目背景

        猫和狗是我们生活中最常见的宠物，它们的图像数据大量存在于互联网上。对此进行分类不仅可以帮助开发自动化宠物识别应用，也可以应用于更广泛的计算机视觉领域。例如，训练良好的模型可以支持流浪动物的识别和归类、动物行为监测、虚拟宠物应用等方面。通过本项目，我们希望展现深度学习在实际应用中的有效性，以及其对社会的正面影响。

1.2、项目目的

        在本项目中，我们的目标是构建一个深度学习模型，能够有效地识别和分类猫和狗的图像。通过使用卷积神经网络（CNN），尤其是著名的AlexNet架构，我们希望实现高精度的图像分类。完成该项目后，用户能够方便地将图像上传至应用程序，并获得该图像是猫还是狗的预测结果。

1.3、网络描述

        AlexNet 是由Alex Krizhevsky、Ilya Sutskever 和 Geoffrey Hinton 在2012年提出的深度学习模型。它在ImageNet大规模视觉识别挑战赛中取得了显著的成功，显著提高了图像分类的准确率。该模型采用了多个卷积层、ReLU激活函数、全连接层和Dropout正则化方法，以有效防止过拟合。AlexNet的成功不仅证明了深度学习在计算机视觉领域的潜力，还推动了后续更多深度学习模型的研究和应用。

1.4、数据集

1.5、构建随机数种子

import os
from random import random
import numpy as np
import torchdef setup_seed(seed):np.random.seed(seed)  # 设置 Numpy 随机种子random.seed(seed)  # 设置 Python 内置随机种子os.environ['PYTHONHASHSEED'] = str(seed)  # 设置 Python 哈希种子torch.manual_seed(seed)  # 设置 PyTorch 随机种子if torch.cuda.is_available():torch.cuda.manual_seed(seed)  # 设置 CUDA 随机种子torch.cuda.manual_seed_all(seed)torch.backends.cudnn.benchmark = False  # 关闭 cudnn 加速torch.backends.cudnn.deterministic = True  # 设置 cudnn 为确定性算法

1.6、 CUDA检测

import torch
# 检查是否有可用的 GPU，如果有则使用 GPU，否则使用 CPU
if torch.cuda.is_available():device = torch.device("cuda")  # 使用 GPUprint("CUDA is available. Using GPU.")
else:device = torch.device("cpu")  # 使用 CPUprint("CUDA is not available. Using CPU.")

1.7、读取数据

from torch.utils.data import DataLoader
from torchvision import datasets, transforms
transform = {"train": transforms.Compose([transforms.RandomResizedCrop(224), transforms.ToTensor(),transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]),"test": transforms.Compose([transforms.Resize((224, 224)), transforms.ToTensor(),transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]),
}train_dataset = datasets.ImageFolder("./dataset/train", transform=transform["train"])
test_dataset = datasets.ImageFolder("./dataset/test", transform=transform["test"])train_dataloader = DataLoader(train_dataset, batch_size=32, shuffle=True)
test_dataloader = DataLoader(test_dataset, batch_size=32, shuffle=False)

1.8、显示图像

import matplotlib.pyplot as plt
import numpy as np
# 打印图片
examples = enumerate(test_dataloader)
batch_idx, (imgs, labels) = next(examples)
for i in range(4):mean = np.array([0.5, 0.5, 0.5])std = np.array([0.5, 0.5, 0.5])image = imgs[i].numpy() * std[:, None, None] + mean[:, None, None]# 将图片转成numpy数组，主要是转换通道和宽高位置image = np.transpose(image, (1, 2, 0))plt.subplot(2, 2, i+1)plt.imshow(image)plt.title(f"Truth: {labels[i]}")
plt.show()

1.9、构建网络

import torch
from torch import nnclass AlexNet(nn.Module):def __init__(self, num_classes=1000):super(AlexNet, self).__init__()self.features = nn.Sequential(nn.Conv2d(3, 96, 11, 4, 2),nn.ReLU(inplace=True),nn.MaxPool2d(3, 2),nn.Conv2d(96, 256, 5, 1, 2),nn.ReLU(inplace=True),nn.MaxPool2d(3, 2),nn.Conv2d(256, 384, 3, 1, 1),nn.ReLU(inplace=True),nn.Conv2d(384, 384, 3, 1, 1),nn.ReLU(inplace=True),nn.Conv2d(384, 256, 3, 1, 1),nn.ReLU(inplace=True),nn.MaxPool2d(3, 2),)self.classifier = nn.Sequential(nn.Dropout(p=0.5),nn.Linear(256 * 6 * 6, 4096),nn.ReLU(inplace=True),nn.Dropout(p=0.5),nn.Linear(4096, 4096),nn.ReLU(inplace=True),nn.Linear(4096, num_classes),)def forward(self, x):x = self.features(x)x = torch.flatten(x, 1)x = self.classifier(x)return x

1.10、损失函数和优化器

cri = torch.nn.CrossEntropyLoss()
optomizer = torch.optim.Adam(model.parameters(), lr=0.0001)

1.11、训练模型

epoches = 100
for epoch in range(epoches):model.train()total_loss = 0for i, (images, labels) in enumerate(train_dataloader):# 数据放在设备上images = images.to(device)labels = labels.to(device)# 前向传播outputs = model(images)loss = cri(outputs, labels)# 反向传播optomizer.zero_grad()loss.backward()optomizer.step()total_loss += lossprint(f"Epoch [{epoch + 1}/{epoches}], Iter [{i}/{len(train_dataloader)}], Loss {loss:.4f}")avg_loss = total_loss / len(train_dataloader)print(f"Epoch [{epoch + 1}/{epoches}], Loss {avg_loss:.4f}")if (epoch+1) % 10 == 0:torch.save(model.state_dict(), f"./model/model_{epoch}.pth")

1.12、 验证模型

print("开始验证/评估模型：")
model.load_state_dict(torch.load("./model_best.pth",weights_only=True))
model.eval()
total = 0
correct = 0
predicted_labels = []
true_labels = []
with torch.no_grad():for images, labels in test_dataloader: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()predicted_labels.extend(predicted.cpu().numpy())true_labels.extend(labels.cpu().numpy())print(f"ACC {correct / total * 100}%")# 生成混淆矩阵
conf = confusion_matrix(true_labels, predicted_labels)
# 可视化
sns.heatmap(conf, annot=True, fmt="d", cmap="Blues")
plt.xlabel("predict")
plt.ylabel("true")
plt.show()

 1.13、完整代码

import os
import random
import numpy as np
import torch
from torch import nn  # 导入神经网络模块
from torch.utils.data import DataLoader
from torchvision import datasets, transforms# 设置随机种子以保证结果的可重复性
def setup_seed(seed):np.random.seed(seed)  # 设置 Numpy 随机种子，用于控制 Numpy 相关的随机操作random.seed(seed)  # 设置 Python 内置随机种子，用于控制 Python 内置的随机操作os.environ['PYTHONHASHSEED'] = str(seed)  # 设置 Python 哈希种子，用于控制哈希操作的随机性，保证实验的可复现性torch.manual_seed(seed)  # 设置 PyTorch 的 CPU 随机种子，用于控制 PyTorch 中 CPU 相关的随机操作if torch.cuda.is_available():  # 检查是否有可用的 CUDA (GPU)torch.cuda.manual_seed(seed)  # 设置当前 GPU 的随机种子torch.cuda.manual_seed_all(seed)  # 设置所有 GPU 的随机种子（如果有多个 GPU）torch.backends.cudnn.benchmark = False  # 关闭 cuDNN 的 benchmark 模式。benchmark 模式会自动寻找适合当前配置的高效算法，但可能牺牲可重复性torch.backends.cudnn.deterministic = True  # 设置 cuDNN 使用确定性算法，保证在相同的输入和权重下，输出是相同的，进一步提高可重复性# 设置随机种子
setup_seed(0)
# 检查是否有可用的 GPU，如果有则使用 GPU，否则使用 CPU
if torch.cuda.is_available():device = torch.device("cuda")  # 将设备设置为 CUDA (GPU)print("CUDA is available. Using GPU.")
else:device = torch.device("cpu")  # 将设备设置为 CPUprint("CUDA is not available. Using CPU.")# 定义数据预处理的转换
transform = {"train": transforms.Compose([  # 训练集的数据预处理transforms.RandomResizedCrop(224),  # 随机裁剪图片到 224x224 的大小，并进行缩放transforms.ToTensor(),  # 将 PIL 图像或 NumPy 数组转换为 PyTorch 张量，并将像素值缩放到 [0, 1]transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))  # 对图像的每个通道进行标准化，使其均值为 0.5，标准差为 0.5]),"test": transforms.Compose([  # 测试集的数据预处理transforms.Resize((224, 224)),  # 将图片缩放至 224x224 的大小transforms.ToTensor(),  # 将 PIL 图像或 NumPy 数组转换为 PyTorch 张量，并将像素值缩放到 [0, 1]transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))  # 对图像的每个通道进行标准化，使其均值为 0.5，标准差为 0.5]),
}# 加载训练数据集，"./dataset/train" 是训练集图片所在的文件夹，transform 指定了数据预处理方式
train_dataset = datasets.ImageFolder("./dataset/train", transform=transform["train"])
# 加载测试数据集，"./dataset/test" 是测试集图片所在的文件夹，transform 指定了数据预处理方式
test_dataset = datasets.ImageFolder("./dataset/test", transform=transform["test"])# 创建训练数据的数据加载器，batch_size 定义了每个批次的大小，shuffle=True 表示在每个 epoch 开始时打乱数据
train_dataloader = DataLoader(train_dataset, batch_size=32, shuffle=True)
# 创建测试数据的数据加载器，batch_size 定义了每个批次的大小，shuffle=False 表示不打乱数据
test_dataloader = DataLoader(test_dataset, batch_size=32, shuffle=False)# 定义 AlexNet 模型结构
class AlexNet(nn.Module):def __init__(self, num_classes=1000):super(AlexNet, self).__init__()# 特征提取层self.features = nn.Sequential(nn.Conv2d(3, 96, kernel_size=11, stride=4, padding=2),  # 卷积层1：输入通道3，输出通道96，卷积核11x11，步长4，填充2nn.ReLU(inplace=True),  # ReLU 激活函数，inplace=True 表示直接修改输入nn.MaxPool2d(kernel_size=3, stride=2),  # 最大池化层1：池化窗口3x3，步长2nn.Conv2d(96, 256, kernel_size=5, padding=2),  # 卷积层2：输入通道96，输出通道256，卷积核5x5，填充2nn.ReLU(inplace=True),nn.MaxPool2d(kernel_size=3, stride=2),  # 最大池化层2：池化窗口3x3，步长2nn.Conv2d(256, 384, kernel_size=3, padding=1),  # 卷积层3：输入通道256，输出通道384，卷积核3x3，填充1nn.ReLU(inplace=True),nn.Conv2d(384, 384, kernel_size=3, padding=1),  # 卷积层4：输入通道384，输出通道384，卷积核3x3，填充1nn.ReLU(inplace=True),nn.Conv2d(384, 256, kernel_size=3, padding=1),  # 卷积层5：输入通道384，输出通道256，卷积核3x3，填充1nn.ReLU(inplace=True),nn.MaxPool2d(kernel_size=3, stride=2),  # 最大池化层3：池化窗口3x3，步长2)# 分类器self.classifier = nn.Sequential(nn.Dropout(p=0.5),  # Dropout 层1：以 50% 的概率随机将一部分神经元的输出置为 0，防止过拟合nn.Linear(256 * 6 * 6, 4096),  # 全连接层1：输入特征数 256 * 6 * 6，输出特征数 4096nn.ReLU(inplace=True),nn.Dropout(p=0.5),  # Dropout 层2nn.Linear(4096, 4096),  # 全连接层2：输入特征数 4096，输出特征数 4096nn.ReLU(inplace=True),nn.Linear(4096, num_classes),  # 全连接层3：输出层，输出特征数等于类别数)def forward(self, x):x = self.features(x)  # 通过特征提取层x = torch.flatten(x, 1)  # 将多维特征图展平成一维向量，方便输入到全连接层x = self.classifier(x)  # 通过分类器return x# 实例化 AlexNet 模型，num_classes=2 表示分类的类别数为 2，并将模型移动到指定的设备 (GPU 或 CPU) 上
model = AlexNet(num_classes=2).to(device)
# 定义损失函数为交叉熵损失，常用于多分类任务
cri = torch.nn.CrossEntropyLoss()
# 定义优化器为 Adam 优化器，model.parameters() 指定了需要优化的模型参数，lr=0.0001 是学习率
optomizer = torch.optim.Adam(model.parameters(), lr=0.0001)# 定义训练的 epoch 数
epoches = 100
# 开始训练循环
for epoch in range(epoches):most_acc = 0  # 初始化最佳的测试集准确率model.train()  # 将模型设置为训练模式，启用 dropout 和 batch normalizationtotal_loss = 0  # 初始化每个 epoch 的总损失# 遍历训练数据加载器中的每个批次for i, (images, labels) in enumerate(train_dataloader):# 将图像和标签移动到指定的设备 (GPU 或 CPU) 上images = images.to(device)labels = labels.to(device)# 前向传播：将图像输入模型，得到模型的输出outputs = model(images)# 计算损失：将模型的输出和真实的标签输入损失函数，得到损失值loss = cri(outputs, labels)# 反向传播之前将优化器的梯度清零optomizer.zero_grad()# 反向传播：计算损失相对于模型参数的梯度loss.backward()# 更新模型参数：根据计算得到的梯度和优化器的规则更新模型参数optomizer.step()# 累加每个批次的损失值total_loss += loss# 打印训练过程中的信息，包括当前的 epoch、迭代次数和当前的损失值print(f"Epoch [{epoch + 1}/{epoches}], Iter [{i}/{len(train_dataloader)}], Loss {loss:.4f}")# 计算一个 epoch 的平均训练损失avg_loss = total_loss / len(train_dataloader)# 打印每个 epoch 的平均训练损失print(f"Train Data: Epoch [{epoch + 1}/{epoches}], Loss {avg_loss:.4f}")# 进入模型评估模式，禁用 dropout 和 batch normalizationmodel.eval()total, correct, test_loss, total_loss = 0, 0, 0, 0  # 初始化测试过程中的总样本数、正确样本数、批次损失和总损失# 在评估模式下，不计算梯度with torch.no_grad():# 遍历测试数据加载器中的每个批次for images, labels in test_dataloader:# 将图像和标签移动到指定的设备 (GPU 或 CPU) 上images = images.to(device)labels = labels.to(device)# 前向传播：将图像输入模型，得到模型的输出outputs = model(images)# 计算测试集的损失test_loss = cri(outputs, labels)# 累加每个批次的测试损失total_loss += test_loss# 获取模型输出中每个样本的最大值和对应的索引（即预测的类别）_, predicted = torch.max(outputs.data, 1)# 累加测试集的总样本数total += labels.size(0)# 累加预测正确的样本数correct += (predicted == labels).sum().item()# 计算平均测试损失avg_test_loss = total_loss / len(test_dataloader)# 计算测试集的准确率acc = correct / total# 打印每个 epoch 的测试损失和准确率print(f"Test Data: Epoch [{epoch+1}/{epoches}], Loss {avg_test_loss:.4f}, Accuracy {acc * 100}%")# 如果当前的测试准确率是最高的，则保存当前模型的权重if acc > most_acc:torch.save(model.state_dict(), f"./model/model_best.pth")most_acc = acc# 每隔 10 个 epoch 保存一次模型的权重if (epoch+1) % 10 == 0:torch.save(model.state_dict(), f"./model/model_{epoch+1}.pth")