CV实验之GoogLeNet网络训练总结_googlenet logs

 一、GoogLeNet网络结构

GoogleNet模型的网络深度为22层（ 如果只计算有参数层，GoogleNet网络有22层深 ，算上池化层则共有27层），而且在网络架构中引入了Inception单元，从而进一步提升模型整体的性能。虽然深度达到了22层，但大小却比AlexNet和VGG小很多，GoogleNet参数为500万个（ 5M ），VGG16参数是138M，是GoogleNet的27倍多，而VGG16参数量则是AlexNet的两倍多。

二、GoogleNet 创新点：

1、Inception结构：利用不同大小的卷积核实现不同尺度的感知，最后进行融合，可以得到图像更好的表征。

2、使用了1*1卷积：GoogLeNet 在网络中使用了 1x1 的卷积核来进行降维操作，从而减少通道数。这样做既可以减少计算复杂性，又可以提高模型的表达能力。

3、全局平均池化： 在网络的最后，GoogLeNet 使用了全局平均池化操作，将最后一个卷积层的特征图的每个通道的空间维度进行平均，得到一个固定大小的特征向量。这种操作可以降低模型中的参数数量，减少过拟合的风险。

三、训练与测试

我们对原始的GoogLeNet网络做了一些改进：

1、使用了批标准化（Batch Normalization）：每个卷积层后面都添加了nn.BatchNorm2d层，这有助于加速网络的训练和提高模型的泛化能力。

2、增加了激活函数：在每个卷积层后面都使用了nn.ReLU(True)。

3、5x5卷积分支的改进：在原始的GoogLeNet中，5x5卷积分支只使用了一个5x5的卷积核。改进后的Inception模块5x5卷积分支使用了两个连续的3x3卷积核来替代，这有助于减少参数量并增加非线性能力。

学习率初始值为0.01，使用的是余弦退火学习率调节器，优化器使用的是SGD随机梯度下降优化器。

原始GoogLeNet模型具体结构：

微调GoogLeNet模型1具体结构：

微调GoogLeNet模型2具体结构：

具体代码如下所示：

main.py

import torch
import torchvision
import torchvision.transforms as transforms
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
import numpy as np
import matplotlib.pyplot as plt
from torch.nn import init
from torch.optim import Adam
from torch.optim.lr_scheduler import StepLR
from torch.utils.tensorboard import SummaryWriter
from models import *
 
 
transform_train = transforms.Compose(
    [
        transforms.RandomCrop(32, padding=4),
        transforms.RandomHorizontalFlip(),
        transforms.ToTensor(),
        transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
     ])
 
transform_test = transforms.Compose(
    [
        transforms.ToTensor(),
        transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))]
)
 
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
 
trainset = torchvision.datasets.CIFAR10(root='D:\CV\pytorch\dataset\cifar-10-batches-py',
                                        train=True, download=True, transform=transform_train)
trainLoader = torch.utils.data.DataLoader(trainset, batch_size=32, shuffle=True)
 
testset = torchvision.datasets.CIFAR10(root='D:\CV\pytorch\dataset\cifar-10-batches-py',
                                       train=False, download=True, transform=transform_test)
testLoader = torch.utils.data.DataLoader(testset, batch_size=32, shuffle=False)
 
writer = SummaryWriter('D:\CV\pytorch\pytorch-cifar-master\logs_googlenet_100ep')
 
# net = VGG('VGG16')
# net = ResNet50()
net = GoogLeNet()
# net = ResNet18()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.01, momentum=0.9, weight_decay=5e-4)  # 0.1，0.01
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=200)
 
total_times = 100
total = 0
accuracy_rate = []
 
 
for epoch in range(total_times):
    net .train()
    net .to(device)
    running_loss = 0.0
    total_train_correct = 0
    total_train_samples = 0
    total_correct = 0
    total_trainset = 0
 
    for i, (data, labels) in enumerate(trainLoader, 0):
        data = data.to(device)
        outputs = net(data).to(device)
        labels = labels.to(device)
        loss = criterion(outputs, labels).to(device)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
        _, pred = outputs.max(1)
        correct = (pred == labels).sum().item()
        total_correct += correct
        total_trainset += data.shape[0]
        running_loss += loss.item()
        total_train_correct += correct
        total_train_samples += data.shape[0]
 
    train_loss = running_loss / len(trainLoader)
    train_accuracy = total_train_correct / total_train_samples
 
    writer.add_scalar('Train/Loss', train_loss, epoch)
    writer.add_scalar('Train/Accuracy', train_accuracy, epoch)
    print('epoch[%d] train_loss: %.4f, train_acc: %.4f' % (epoch + 1, running_loss / len(trainLoader), train_accuracy))
 
    net.eval()
    correct = 0  # 预测正确的图片数
    total = 0  # 总共的图片数
    losses = []  # 用于记录每个批次的损失值
    with torch.no_grad():
        for data in testLoader:
            images, labels = data
            images = images.to(device)
            outputs = net(images).to(device)
            outputs = outputs.cpu()
            outputarr = outputs.numpy()  # 将output转换为numpy
            _, predicted = torch.max(outputs, 1)  # 获取每个样本在输出中的最大值以及对应索引，predicted 保存预测类别标签。
            total += labels.size(0)  # 这是为了计算整个测试集的准确率时，获得正确的总样本数
            correct += (predicted == labels).sum()  # (predicted == labels) 会生成一个布尔张量.sum() 对布尔张量进行求和，得到预测正确的样本数量。
            # 计算测试损失
            loss = criterion(outputs, labels)
            losses.append(loss.item())
 
    accuracy = 100 * correct / total
    accuracy_rate.append(accuracy)
    mean_loss = sum(losses) / len(losses)  # 平均损失值
 
    writer.add_scalar('Test/Loss', mean_loss, epoch)
    writer.add_scalar('Test/Accuracy', accuracy, epoch)
 
    print(f'epoch[{epoch + 1}]  test_lost: {mean_loss:.4f}  test_acc: {accuracy:.2f}%')
    # print(f'测试准确率:{accuracy}%'.format(accuracy))
    # test()
    scheduler.step()
writer.close()
 
torch.save(net.state_dict(), 'D:\CV\pytorch\pytorch-cifar-master/res/GoogleNet_100epoch.pth')
accuracy_rate = np.array(accuracy_rate)
times = np.linspace(1, total_times, total_times)
plt.xlabel('times')
plt.ylabel('accuracy rate')
plt.plot(times, accuracy_rate)
plt.show()
 
print(accuracy_rate)

model.py

'''GoogLeNet with PyTorch.'''
import torch
import torch.nn as nn
import torch.nn.functional as F
 
 
class Inception(nn.Module):
    def __init__(self, in_planes, n1x1, n3x3red, n3x3, n5x5red, n5x5, pool_planes):
        super(Inception, self).__init__()
        # 1x1 conv branch
        self.b1 = nn.Sequential(
            nn.Conv2d(in_planes, n1x1, kernel_size=1),
            nn.BatchNorm2d(n1x1),
            nn.ReLU(True),
        )
 
        # 1x1 conv -> 3x3 conv branch
        self.b2 = nn.Sequential(
            nn.Conv2d(in_planes, n3x3red, kernel_size=1),
            nn.BatchNorm2d(n3x3red),
            nn.ReLU(True),
            nn.Conv2d(n3x3red, n3x3, kernel_size=3, padding=1),
            nn.BatchNorm2d(n3x3),
            nn.ReLU(True),
        )
 
        # 1x1 conv -> 5x5 conv branch
        self.b3 = nn.Sequential(
            nn.Conv2d(in_planes, n5x5red, kernel_size=1),
            nn.BatchNorm2d(n5x5red),
            nn.ReLU(True),
            nn.Conv2d(n5x5red, n5x5, kernel_size=3, padding=1),
            nn.BatchNorm2d(n5x5),
            nn.ReLU(True),
            nn.Conv2d(n5x5, n5x5, kernel_size=3, padding=1),
            nn.BatchNorm2d(n5x5),
            nn.ReLU(True),
        )
 
        # 3x3 pool -> 1x1 conv branch
        self.b4 = nn.Sequential(
            nn.MaxPool2d(3, stride=1, padding=1),
            nn.Conv2d(in_planes, pool_planes, kernel_size=1),
            nn.BatchNorm2d(pool_planes),
            nn.ReLU(True),
        )
 
    def forward(self, x):
        y1 = self.b1(x)
        y2 = self.b2(x)
        y3 = self.b3(x)
        y4 = self.b4(x)
        return torch.cat([y1,y2,y3,y4], 1)
 
 
class GoogLeNet(nn.Module):
    def __init__(self):
        super(GoogLeNet, self).__init__()
        self.pre_layers = nn.Sequential(
            nn.Conv2d(3, 192, kernel_size=3, padding=1),
            nn.BatchNorm2d(192),
            nn.ReLU(True),
        )
 
        self.a3 = Inception(192,  64,  96, 128, 16, 32, 32)
        self.b3 = Inception(256, 128, 128, 192, 32, 96, 64)
 
        self.maxpool = nn.MaxPool2d(3, stride=2, padding=1)
 
        self.a4 = Inception(480, 192,  96, 208, 16,  48,  64)
        self.b4 = Inception(512, 160, 112, 224, 24,  64,  64)
        self.c4 = Inception(512, 128, 128, 256, 24,  64,  64)
        self.d4 = Inception(512, 112, 144, 288, 32,  64,  64)
        self.e4 = Inception(528, 256, 160, 320, 32, 128, 128)
 
        self.a5 = Inception(832, 256, 160, 320, 32, 128, 128)
        self.b5 = Inception(832, 384, 192, 384, 48, 128, 128)
 
        self.avgpool = nn.AvgPool2d(8, stride=1)
        self.linear = nn.Linear(1024, 10)
 
    def forward(self, x):
        out = self.pre_layers(x)
        out = self.a3(out)
        out = self.b3(out)
        out = self.maxpool(out)
        out = self.a4(out)
        out = self.b4(out)
        out = self.c4(out)
        out = self.d4(out)
        out = self.e4(out)
        out = self.maxpool(out)
        out = self.a5(out)
        out = self.b5(out)
        out = self.avgpool(out)
        out = out.view(out.size(0), -1)
        out = self.linear(out)
        return out
 
 
def test():
    net = GoogLeNet()
    x = torch.randn(1, 3, 32, 32)
    y = net(x)
    print(y.size())

训练和测试的一些参数可以根据自己电脑的算力进行微调。在训练了100个epoch后，在CIRAR10数据集上的最高准确率为92.68%。

 

 参考文献：

深入解读GoogLeNet网络结构（附代码实现）_雷恩Layne的博客-CSDN博客