使用 PyTorch 实现简化版 GoogLeNet 进行 MNIST 图像分类

介绍

        本文将介绍如何使用 PyTorch 实现一个简化版的 GoogLeNet 网络来进行 MNIST 图像分类。GoogLeNet 是 Google 提出的深度卷积神经网络(CNN),其通过 Inception 模块大大提高了计算效率并提升了分类性能。我们将实现一个简化版的 GoogLeNet,用于处理 MNIST 数据集,该数据集由手写数字图片组成,适合用于小规模的图像分类任务。

项目结构

        我们将代码分为两个部分:

  • 训练脚本 train.py:包括数据加载、模型构建、训练过程等。
  • 测试脚本 test.py:用于加载训练好的模型并在测试集上评估性能。

项目依赖

        在开始之前,我们需要安装以下 Python 库:

  • torch:PyTorch 深度学习框架
  • torchvision:提供数据加载和图像变换功能
  • matplotlib:用于可视化

        可以通过以下命令安装所有依赖:

pip install -r requirements.txt

  requirements.txt 文件内容如下:

torch==2.0.1
torchvision==0.15.0
matplotlib==3.6.3

数据预处理与加载

1. 数据加载和预处理

        在训练模型之前,我们需要对 MNIST 数据集进行预处理。以下是数据加载和预处理的代码:

import torch
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

def get_data_loader(batch_size=64, train=True):
    transform = transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.5,), (0.5,))  # 正规化到 [-1, 1] 范围
    ])

    dataset = datasets.MNIST(root='./data', train=train, download=True, transform=transform)
    return DataLoader(dataset, batch_size=batch_size, shuffle=True, pin_memory=True, num_workers=4)

        这里,我们使用了 transforms.Compose 来进行数据预处理,包括将图像转换为 Tensor 格式,并进行归一化处理。


以下是使用PyTorch实现GoogleNet图像分类的代码示例: ```python import torch import torch.nn as nn import torch.optim as optim import torchvision.transforms as transforms import torchvision.datasets as datasets from torch.utils.data import DataLoader class Inception(nn.Module): def __init__(self, in_channels, n1x1, n3x3_reduce, n3x3, n5x5_reduce, n5x5, pool_proj): super(Inception, self).__init__() # 1x1 convolution branch self.conv1x1 = nn.Sequential( nn.Conv2d(in_channels, n1x1, kernel_size=1), nn.ReLU(inplace=True) ) # 3x3 convolution branch self.conv3x3 = nn.Sequential( nn.Conv2d(in_channels, n3x3_reduce, kernel_size=1), nn.ReLU(inplace=True), nn.Conv2d(n3x3_reduce, n3x3, kernel_size=3, padding=1), nn.ReLU(inplace=True) ) # 5x5 convolution branch self.conv5x5 = nn.Sequential( nn.Conv2d(in_channels, n5x5_reduce, kernel_size=1), nn.ReLU(inplace=True), nn.Conv2d(n5x5_reduce, n5x5, kernel_size=5, padding=2), nn.ReLU(inplace=True) ) # Max pooling branch self.max_pool = nn.Sequential( nn.MaxPool2d(kernel_size=3, stride=1, padding=1), nn.Conv2d(in_channels, pool_proj, kernel_size=1), nn.ReLU(inplace=True) ) def forward(self, x): x1 = self.conv1x1(x) x2 = self.conv3x3(x) x3 = self.conv5x5(x) x4 = self.max_pool(x) return torch.cat([x1, x2, x3, x4], 1) class GoogleNet(nn.Module): def __init__(self, num_classes=1000): super(GoogleNet, self).__init__() self.conv1 = nn.Sequential( nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=3, stride=2, padding=1) ) self.conv2 = nn.Sequential( nn.Conv2d(64, 64, kernel_size=1), nn.ReLU(inplace=True), nn.Conv2d(64, 192, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=3, stride=2, padding=1) ) self.inception3a = Inception(192, 64, 96, 128, 16, 32, 32) self.inception3b = Inception(256, 128, 128, 192, 32, 96, 64) self.max_pool1 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1) self.inception4a = Inception(480, 192, 96, 208, 16, 48, 64) self.inception4b = Inception(512, 160, 112, 224, 24, 64, 64) self.inception4c = Inception(512, 128, 128, 256, 24, 64, 64) self.inception4d = Inception(512, 112, 144, 288, 32, 64, 64) self.inception4e = Inception(528, 256, 160, 320, 32, 128, 128) self.max_pool2 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1) self.inception5a = Inception(832, 256, 160, 320, 32, 128, 128) self.inception5b = Inception(832, 384, 192, 384, 48, 128, 128) self.avg_pool = nn.AdaptiveAvgPool2d((1,1)) self.dropout = nn.Dropout(p=0.4) self.fc = nn.Linear(1024, num_classes) def forward(self, x): x = self.conv1(x) x = self.conv2(x) x = self.inception3a(x) x = self.inception3b(x) x = self.max_pool1(x) x = self.inception4a(x) x = self.inception4b(x) x = self.inception4c(x) x = self.inception4d(x) x = self.inception4e(x) x = self.max_pool2(x) x = self.inception5a(x) x = self.inception5b(x) x = self.avg_pool(x) x = torch.flatten(x, 1) x = self.dropout(x) x = self.fc(x) return x # Load the data data_path = 'path/to/data/' train_dataset = datasets.ImageFolder( root=data_path + 'train/', transform=transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) ) train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True) test_dataset = datasets.ImageFolder( root=data_path + 'test/', transform=transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) ) test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False) # Define the model, loss function, and optimizer model = GoogleNet(num_classes=10) criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9) # Train the model for epoch in range(10): for i, (images, labels) in enumerate(train_loader): optimizer.zero_grad() outputs = model(images) loss = criterion(outputs, labels) loss.backward() optimizer.step() if (i+1) % 100 == 0: print('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'.format(epoch+1, 10, i+1, len(train_loader), loss.item())) # Test the model model.eval() with torch.no_grad(): correct = 0 total = 0 for images, labels in test_loader: outputs = model(images) _, predicted = torch.max(outputs.data, 1) total += labels.size(0) correct += (predicted == labels).sum().item() print('Test Accuracy of the model on the test images: {} %'.format(100 * correct / total)) ``` 在这个示例中,我们使用了ImageNet数据集的一部分来进行训练和测试。您需要将`data_path`变量设置为包含`train`和`test`文件夹的根目录。此外,我们使用PyTorch的内置数据增强方法来对图像进行预处理,并使用了交叉熵损失和随机梯度下降(SGD)优化器来训练模型。最后,我们使用测试集来评估模型的准确性。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值