进击J8：Inception v1算法实战与解析

最新推荐文章于 2024-10-05 19:19:55 发布

Doctor老王

最新推荐文章于 2024-10-05 19:19:55 发布

阅读量722

点赞数 25

分类专栏：麻醉医生的深度学习之旅文章标签：深度学习 pytorch

本文链接：https://blog.csdn.net/u012249506/article/details/142528284

版权

麻醉医生的深度学习之旅专栏收录该内容

19 篇文章 0 订阅

订阅专栏

🍨 本文为🔗365天深度学习训练营中的学习记录博客
🍖 原作者：K同学啊

一、实验目的：

了解并学习图2中的卷积层运算量的计算过程
了解并学习卷积层的并行结构与1x1卷积核部分内容（重点）
尝试根据模型框架图写出相应的pytorch代码，并使用Inception v1完成猴痘病识别

二、实验环境：

语言环境：python 3.8
编译器：Jupyter notebook
深度学习环境：Pytorch
torch==2.4.0+cu124
torchvision==0.19.0+cu124

三、Inception v1

1. 简介

Inception v1论文：Going deeper with convolutions
Inception v1是一种深度卷积神经网络，它在ILSVRC14比赛中表现出最佳的分类和检测性能。
Inception V1有22层深，参数量为5M。同一时期的VGGNet性能和Inception V1差不多，但是参数量远大于Inception V1。

Inception Module是Inception V1的核心组成单元，提出了卷积层的并行结构，实现了在同一层就可以提取不同的特征，如下图
在这里插入图片描述

按照这样的结构来增加网络的深度，虽然可以提升性能，但是还面临计算量大（参数多）的问题。为改善这种现象，Inception Module借鉴Network-in-Network的思想，使用1x1的卷积核实现降维操作(也间接增加了网络的深度)，以此来减小网络的参数量与计算量。

在这里插入图片描述

1x1卷积核的作用：1x1卷积核的最大作用是降低输入特征图的通道数，减小网络的参数量与计算量。

最后Inception Module基本由11卷积，33卷积，55卷积，33最大池化四个基本单元组成，对四个基本单元运算结果进行通道上组合，不同大小的卷积核赋予不同大小的感受野，从而提取到图像不同尺度的信息，进行融合，得到图像更好的表征，就是Inception Module的核心思想。

2. 算法结构

在这里插入图片描述

注：另外增加了两个辅助分支，作用有两点，一是为了避免梯度消失，用于向前传导梯度。反向传播时如果有一层求导为0，链式求导结果则为0。二是将中间某一层输出用作分类，起到模型融合作用，实际测试时，这两个辅助softmax分支会被去掉，在后续模型的发展中，该方法被采用较少，可以直接绕过，重点学习卷积层的并行结构与1x1卷积核部分的内容即可。

四、Pytorch复现

设置GPU、导入数据、划分数据集等步骤同前。

1. 构建模型

这里去掉了两个辅助分支，直接复现主支。

定义一个名为 Inception 的类，继承自 nn.Module。inception_block 类包含了 Inception v1 模型的所有层和参数。

class inception_block(nn.Module):
    def __init__(self, in_channels, ch1x1, ch3x3red, ch3x3, ch5x5red, ch5x5, pool_proj):
        super().__init__()
        # 1x1 conv branch
        self.branch1 = nn.Sequential(
            nn.Conv2d(in_channels, ch1x1, kernel_size=1),
            nn.BatchNorm2d(ch1x1),
            nn.ReLU(inplace=True)
        )
        # 1x1 conv -> 3x3 conv branch
        self.branch2 = nn.Sequential(
            nn.Conv2d(in_channels, ch3x3red, kernel_size=1),
            nn.BatchNorm2d(ch3x3red),
            nn.ReLU(inplace=True),
            nn.Conv2d(ch3x3red, ch3x3, kernel_size=3, padding=1),
            nn.BatchNorm2d(ch3x3),
            nn.ReLU(inplace=True)
        )
        # 1x1 conv -> 5x5 conv branch
        self.branch3 = nn.Sequential(
            nn.Conv2d(in_channels, ch5x5red, kernel_size=1),
            nn.BatchNorm2d(ch5x5red),
            nn.ReLU(inplace=True),
            nn.Conv2d(ch5x5red, ch5x5, kernel_size=3, padding=1),
            nn.BatchNorm2d(ch5x5),
            nn.ReLU(inplace=True)
        )
        self.branch4 = nn.Sequential(
            nn.MaxPool2d(kernel_size=3, stride=1, padding=1),
            nn.Conv2d(in_channels, pool_proj, kernel_size=1),
            nn.BatchNorm2d(pool_proj),
            nn.ReLU(inplace=True)
        )
 
    def forward(self, x):
        branch1_output = self.branch1(x)
        branch2_output = self.branch2(x)
        branch3_output = self.branch3(x)
        branch4_output = self.branch4(x)
 
        outputs = [branch1_output, branch2_output, branch3_output, branch4_output]
        return torch.cat(outputs, 1)

在**init**方法中，定义了四个分支，分别是：

branch1，一个 1x1 卷积层；
branch2，一个 1x1 卷积层接一个 3x3 卷积层；
branch3，一个 1x1 卷积层接一个 5x5 卷积层；
branch4，一个 3x3 最大池化层接一个 1x1 卷积层。

每个分支都包含了一些卷积层、批归一化层和激活函数。这些层都是 PyTorch 中的标准层，我们可以使用 nn.Conv2d、nn.BatchNorm2d 和 nn.ReLU 分别定义卷积层、批归一化层和 ReLU 激活函数。

在 forward 方法中，我们计算从输入到所有分支的前向传递，并将所有分支的输出特征图拼接在一起。最后，我们返回拼接后的特征图。

接下来，我们定义 Inception v1 模型，使用 nn.ModuleList 和 nn.Sequential 组合多个 Inception 模块和其他层。

class InceptionV1(nn.Module):
   def __init__(self, num_classes=1000):
       super(InceptionV1, self).__init__()
       self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3)
       self.maxpool1 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
       self.conv2 = nn.Conv2d(64, 64, kernel_size=1, stride=1, padding=1)
       self.conv3 = nn.Conv2d(64, 192, kernel_size=3, stride=1, padding=1)
       self.maxpool2 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
       self.inception3a = inception_block(192, 64, 96, 128, 16, 32, 32)
       self.inception3b = inception_block(256, 128, 128, 192, 32, 96, 64)
       self.maxpool3 = nn.MaxPool2d(3, stride=2)
       self.inception4a = inception_block(480, 192, 96, 208, 16, 48, 64)
       self.inception4b = inception_block(512, 160, 112, 224, 24, 64, 64)
       self.inception4c = inception_block(512, 128, 128, 256, 24, 64, 64)
       self.inception4d = inception_block(512, 112, 144, 288, 32, 64, 64)
       self.inception4e = inception_block(528, 256, 160, 320, 32, 128, 128)
       self.maxpool4 = nn.MaxPool2d(2, stride=2)
       self.inception5a = inception_block(832, 256, 160, 320, 32, 128, 128)

       self.inception5b=nn.Sequential(
       inception_block(832, 384, 192, 384, 48, 128, 128),
       nn.AvgPool2d(kernel_size=7,stride=1,padding=0),
       nn.Dropout(0.4)
       )
       # 全连接网络层，用于分类
       self.classifier = nn.Sequential(
       nn.Linear(in_features=1024, out_features=1024),
       nn.ReLU(),
       nn.Linear(in_features=1024, out_features=num_classes),
       nn.Softmax(dim=1)
       )
   def forward(self, x):
       x = self.conv1(x)
       x = F.relu(x)
       x = self.maxpool1(x)
       x = self.conv2(x)
       x = F.relu(x)
       x = self.conv3(x)
       x = F.relu(x)
       x = self.maxpool2(x)
       x = self.inception3a(x)
       x = self.inception3b(x)
       x = self.maxpool3(x)

       x = self.inception4a(x)
       x = self.inception4b(x)
       x = self.inception4c(x)
       x = self.inception4d(x)
       x = self.inception4e(x)
       x = self.maxpool4(x)
       x = self.inception5a(x)
       x = self.inception5b(x)
       x = torch.flatten(x, start_dim=1)
       x = self.classifier(x)
       return x;

# 定义完成，测试一下
model = InceptionV1(4)
model.to(device)
 
# 统计模型参数量以及其他指标
import torchsummary as summary
summary.summary(model, (3, 224, 224))

代码输出部分截图：
在这里插入图片描述

2. 编写训练与测试函数

# 编写训练函数
def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)
    num_batches = len(dataloader)

    train_acc, train_loss = 0, 0

    for X, y in dataloader:
        X, y = X.to(device), y.to(device)

        pred = model(X)
        loss = loss_fn(pred, y)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        train_loss += loss.item()
        train_acc += (pred.argmax(1) == y).type(torch.float).sum().item()

    train_loss /= num_batches
    train_acc /= size

    return train_acc, train_loss

# 编写测试函数
def test(dataloader, model, loss_fn):
    size = len(dataloader.dataset)  # 测试集的大小
    num_batches = len(dataloader)  # 批次数目, (size/batch_size，向上取整)
    test_loss, test_acc = 0, 0

    # 当不进行训练时，停止梯度更新，节省计算内存消耗
    with torch.no_grad():
        for imgs, target in dataloader:
            imgs, target = imgs.to(device), target.to(device)

            # 计算loss
            target_pred = model(imgs)
            loss = loss_fn(target_pred, target)

            test_loss += loss.item()
            test_acc += (target_pred.argmax(1) == target).type(torch.float).sum().item()

    test_acc /= size
    test_loss /= num_batches

    return test_acc, test_loss

3. 设置损失函数和学习率

import copy

loss_fn = nn.CrossEntropyLoss()
learn_rate = 1e-4
opt = torch.optim.Adam(model.parameters(), lr=learn_rate)

scheduler = torch.optim.lr_scheduler.StepLR(opt, step_size=1, gamma=0.9)  # 定义学习率高度器

epochs = 100  # 设置训练模型的最大轮数为100，但可能到不了100
patience = 10  # 早停的耐心值，即如果模型连续10个周期没有准确率提升，则跳出训练

train_loss = []
train_acc = []
test_loss = []
test_acc = []
best_acc = 0  # 设置一个最佳的准确率，作为最佳模型的判别指标
no_improve_epoch = 0  # 用于跟踪准确率是否提升的计数器
epoch = 0  # 用于统计最终的训练模型的轮数，这里设置初始值为0；为绘图作准备，这里的绘图范围不是epochs = 100

4. 正式训练

# 开始训练
for epoch in range(epochs):

    model.train()
    epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, opt)

    model.eval()
    epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)

    if epoch_test_acc > best_acc:
        best_acc = epoch_test_acc
        best_model = copy.deepcopy(model)
        no_improve_epoch = 0  # 重置计数器
        # 保存最佳模型的检查点
        PATH = 'J8_best_model.pth'
        torch.save({
            'epoch': epoch,
            'model_state_dict': best_model.state_dict(),
            'optimizer_state_dict': opt.state_dict(),
            'loss': epoch_test_loss,
        }, PATH)
    else:
        no_improve_epoch += 1

    if no_improve_epoch >= patience:
        print(f"Early stop triggered at epoch {epoch + 1}")
        break  # 早停

    train_acc.append(epoch_train_acc)
    train_loss.append(epoch_train_loss)
    test_acc.append(epoch_test_acc)
    test_loss.append(epoch_test_loss)

    scheduler.step()  # 更新学习率
    lr = opt.state_dict()['param_groups'][0]['lr']

    template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%, Test_loss:{:.3f}, Lr:{:.2E}')
    print(
        template.format(epoch + 1, epoch_train_acc * 100, epoch_train_loss, epoch_test_acc * 100, epoch_test_loss, lr))

代码输出部分截图：
在这里插入图片描述

5. 结果可视化

# 结果可视化
# Loss与Accuracy图

import matplotlib.pyplot as plt
# 隐藏警告
import warnings
warnings.filterwarnings("ignore")  # 忽略警告信息
plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号
plt.rcParams['figure.dpi'] = 100  # 分辨率

epochs_range = range(epoch)

plt.figure(figsize=(12, 3))
plt.subplot(1, 2, 1)

plt.plot(epochs_range, train_acc, label='Training Accuracy')
plt.plot(epochs_range, test_acc, label='Test Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')

plt.subplot(1, 2, 2)
plt.plot(epochs_range, train_loss, label='Training Loss')
plt.plot(epochs_range, test_loss, label='Test Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()

请添加图片描述

总结

如果逐层地详细解释Inception v1网络的架构，就像逐步了解一个工厂的生产线。

1. 输入层

作用：接收原始图片数据。
比喻：原材料（图片）进入工厂。

2. 初始卷积层（7x7卷积 + 2个池化层）

作用：提取图片的初步特征。
技术细节：使用7x7的卷积核和步长为2的卷积操作，减少图片的空间尺寸，同时提取特征。
比喻：大型机器对原材料进行初步加工。

3. 最大池化层（3x3池化）

作用：进一步降低特征的空间尺寸，保留重要信息。
技术细节：使用3x3的最大池化，步长为2。
比喻：筛选过程，去除不需要的部分，保留精华。

4. 1x1卷积层（1x1卷积）

作用：减少特征图的深度，实现降维。
技术细节：使用1x1卷积核，减少通道数。
比喻：质检员检查并调整每个零件（特征），确保质量。

5. Inception模块（A-E模块）

作用：网络的核心部分，通过不同尺度的卷积核提取特征。
技术细节：
- 1x1卷积：降维，减少计算量。
- 3x3卷积：捕获局部特征。
- 5x5卷积：捕获更复杂的局部特征。
- 3x3最大池化：保留重要信息。
比喻：核心生产车间，多个工序同时进行，对产品进行精细加工。

6. 辅助分类器

作用：在中间阶段提供额外的梯度信号，帮助训练网络。
技术细节：
- 平均池化（5x5池化）
- 1x1卷积降维
- 全连接层
- dropout层
- softmax分类器
比喻：质量控制实验室，在生产过程中的不同阶段对产品进行测试。

7. 最大池化层（3x3池化）

作用：降低特征的空间尺寸，为全连接层做准备。
技术细节：使用3x3的最大池化，步长为2。
比喻：最终的精加工，准备进行最终的分类。

8. dropout层

作用：随机丢弃一些特征，防止过拟合。
技术细节：随机将一些神经元的输出置为0。
比喻：质量控制，确保最终产品稳定可靠。

9. 全连接层

作用：将处理过的特征组合起来，进行最终的分类。
技术细节：将二维特征图展平，并通过全连接层进行分类。
比喻：装配线，将所有处理好的特征组合起来。

10. softmax层

作用：输出最终的分类概率。
技术细节：将全连接层的输出转换为概率分布。
比喻：包装车间，将产品（特征）打包，并输出最终的分类结果。

Inception v1网络通过多个阶段的处理，逐渐提取和精炼图片中的特征，最终实现对图片内容的分类。每个阶段都有其特定的功能，从初步处理到最终的分类，每一步都对提高模型的性能至关重要。

另外，本次实验（算法一）的epoch_test_acc、epoch_test_loss与J6（算法二）进行对比：

(0.9324009324009324, 0.8056590301649911)        
(0.8508158508158508, 0.39013327977487017)

算法一可能过度拟合了训练数据，导致虽然在测试集上的精度高，但损失却相对较高。这可能意味着模型对训练数据的特定特征过于敏感，这些特征可能并不具有普遍性。

算法二虽然精度较低，但损失也低，这可能表明算法二在测试数据上更为保守，泛化能力可能更强。算法二可能没有充分利用训练数据，或者模型的容量不足以捕捉数据的所有特征。

在实际应用中，通常需要在精度和损失之间找到一个平衡。如果对泛化能力的要求非常高，可能会倾向于选择损失更低的算法二，并尝试改进其精度。如果任务对准确度要求极高，可能会选择算法一，但同时采取措施减少其过拟合的风险。

Doctor老王

关注

25
点赞
踩
23

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录