- 🍨 本文为🔗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)
算法一可能过度拟合了训练数据，导致虽然在测试集上的精度高，但损失却相对较高。这可能意味着模型对训练数据的特定特征过于敏感，这些特征可能并不具有普遍性。
算法二虽然精度较低，但损失也低，这可能表明算法二在测试数据上更为保守，泛化能力可能更强。算法二可能没有充分利用训练数据，或者模型的容量不足以捕捉数据的所有特征。
在实际应用中，通常需要在精度和损失之间找到一个平衡。如果对泛化能力的要求非常高，可能会倾向于选择损失更低的算法二，并尝试改进其精度。如果任务对准确度要求极高，可能会选择算法一，但同时采取措施减少其过拟合的风险。
![uni-app+vue3开发微信小程序使用本地图片渲染不出来报错[渲染层网络层错误]Failed to load local image resource](https://i-blog.csdnimg.cn/direct/356ce37ca6cf4afbabd205b1d0cfb70c.png)
