365打卡第J8周：Inception v1算法实战与解析

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

🏡 我的环境：

语言环境：Python3.10
编译器：Jupyter Lab
深度学习环境：torch==2.5.1    torchvision==0.20.1
------------------------------分割线---------------------------------

import torch
import torch.nn as nn
import torchvision.transforms as transforms
import torchvision
from torchvision import transforms, datasetsimport os,PIL,pathlibdevice = torch.device("cuda" if torch.cuda.is_available() else "cpu")device

import os,PIL,random,pathlibdata_dir = 'weekj8/data/'
data_dir = pathlib.Path(data_dir)data_paths = list(data_dir.glob('*'))
classeNames = [str(path).split("\\")[2] for path in data_paths]
classeNames

total_datadir = 'weekj8/data'train_transforms = transforms.Compose([transforms.Resize([224, 224]),  # 将输入图片resize成统一尺寸transforms.ToTensor(),          # 将PIL Image或numpy.ndarray转换为tensor，并归一化到[0,1]之间transforms.Normalize(           # 标准化处理-->转换为标准正太分布（高斯分布），使模型更容易收敛mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])  # 其中 mean=[0.485,0.456,0.406]与std=[0.229,0.224,0.225] 从数据集中随机抽样计算得到的。
])total_data = datasets.ImageFolder(total_datadir,transform=train_transforms)
total_datatrain_size = int(0.8 * len(total_data))
test_size  = len(total_data) - train_size
train_dataset, test_dataset = torch.utils.data.random_split(total_data, [train_size, test_size])
train_dataset, test_datasettrain_size,test_sizebatch_size = 32train_dl = torch.utils.data.DataLoader(train_dataset,batch_size=batch_size,shuffle=True,num_workers=1)
test_dl = torch.utils.data.DataLoader(test_dataset,batch_size=batch_size,shuffle=True,num_workers=1)for X, y in test_dl:print("Shape of X [N, C, H, W]: ", X.shape)print("Shape of y: ", y.shape, y.dtype)break

import torch
import torch.nn as nn
import torch.nn.functional as Fclass inception_block(nn.Module):def __init__(self, in_channels, ch1x1, ch3x3red, ch3x3, ch5x5red, ch5x5, pool_proj):super().__init__()# 1x1 conv branchself.branch1 = nn.Sequential(nn.Conv2d(in_channels, ch1x1, kernel_size=1),nn.BatchNorm2d(ch1x1),nn.ReLU(inplace=True))# 1x1 -> 3x3 conv branchself.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 -> 5x5 conv branchself.branch3 = nn.Sequential(nn.Conv2d(in_channels, ch5x5red, kernel_size=1),nn.BatchNorm2d(ch5x5red),nn.ReLU(inplace=True),nn.Conv2d(ch5x5red, ch5x5, kernel_size=5, padding=2),nn.BatchNorm2d(ch5x5),nn.ReLU(inplace=True))# 3x3 pool -> 1x1 conv branchself.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):return torch.cat([self.branch1(x),self.branch2(x),self.branch3(x),self.branch4(x)], dim=1)  # 沿通道维度拼接class InceptionV1(nn.Module):def __init__(self, num_classes=1000):super().__init__()# 初始卷积层self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3)self.maxpool1 = nn.MaxPool2d(3, stride=2, padding=1)self.conv2 = nn.Conv2d(64, 64, kernel_size=1)self.conv3 = nn.Conv2d(64, 192, kernel_size=3, padding=1)self.maxpool2 = nn.MaxPool2d(3, stride=2, padding=1)# Inception 模块self.inception3a = inception_block(192, 64, 96, 128, 16, 32, 32)  # 输出通道: 64+128+32+32=256self.inception3b = inception_block(256, 128, 128, 192, 32, 96, 64)  # 输出: 128+192+96+64=480self.maxpool3 = nn.MaxPool2d(3, stride=2, padding=1)self.inception4a = inception_block(480, 192, 96, 208, 16, 48, 64)  # 192+208+48+64=512self.inception4b = inception_block(512, 160, 112, 224, 24, 64, 64)  # 160+224+64+64=512self.inception4c = inception_block(512, 128, 128, 256, 24, 64, 64)  # 128+256+64+64=512self.inception4d = inception_block(512, 112, 144, 288, 32, 64, 64)  # 112+288+64+64=528self.inception4e = inception_block(528, 256, 160, 320, 32, 128, 128)  # 256+320+128+128=832self.maxpool4 = nn.MaxPool2d(3, stride=2, padding=1)self.inception5a = inception_block(832, 256, 160, 320, 32, 128, 128)  # 256+320+128+128=832self.inception5b = nn.Sequential(inception_block(832, 384, 192, 384, 48, 128, 128),  # 384+384+128+128=1024nn.AdaptiveAvgPool2d((1, 1)),  # 自适应池化到1x1nn.Dropout(0.4))# 分类器self.classifier = nn.Linear(1024, num_classes)  # 输入特征数必须匹配池化后的通道数def forward(self, x):# 输入形状: [32, 3, 224, 224]x = F.relu(self.conv1(x))      # -> [32, 64, 112, 112]x = self.maxpool1(x)           # -> [32, 64, 56, 56]x = F.relu(self.conv2(x))      # -> [32, 64, 56, 56]x = F.relu(self.conv3(x))      # -> [32, 192, 56, 56]x = self.maxpool2(x)           # -> [32, 192, 28, 28]x = self.inception3a(x)        # -> [32, 256, 28, 28]x = self.inception3b(x)        # -> [32, 480, 28, 28]x = self.maxpool3(x)           # -> [32, 480, 14, 14]x = self.inception4a(x)        # -> [32, 512, 14, 14]x = self.inception4b(x)        # -> [32, 512, 14, 14]x = self.inception4c(x)        # -> [32, 512, 14, 14]x = self.inception4d(x)        # -> [32, 528, 14, 14]x = self.inception4e(x)        # -> [32, 832, 14, 14]x = self.maxpool4(x)           # -> [32, 832, 7, 7]x = self.inception5a(x)        # -> [32, 832, 7, 7]x = self.inception5b(x)        # -> [32, 1024, 1, 1]x = torch.flatten(x, 1)        # -> [32, 1024]x = self.classifier(x)         # -> [32, num_classes]return x# 测试代码
if __name__ == "__main__":model = InceptionV1(num_classes=1000)dummy_input = torch.randn(32, 3, 224, 224)  # 匹配输入形状[N, C, H, W]=[32,3,224,224]output = model(dummy_input)print("Output shape:", output.shape)  # 应输出 torch.Size([32, 1000])
from torchsummary import summary
model=InceptionV1().to(device)
# 将模型移动到GPU（如果可用）summary(model, (3, 224, 224))
print(model)

...

loss_fn    = nn.CrossEntropyLoss() # 创建损失函数
learn_rate = 1e-4 # 学习率
opt        = torch.optim.SGD(model.parameters(),lr=learn_rate)# 训练循环
def train(dataloader, model, loss_fn, optimizer):size = len(dataloader.dataset)  # 训练集的大小，一共60000张图片num_batches = len(dataloader)   # 批次数目，1875（60000/32）train_loss, train_acc = 0, 0  # 初始化训练损失和正确率for X, y in dataloader:  # 获取图片及其标签X, y = X.to(device), y.to(device)# 计算预测误差pred = model(X)          # 网络输出loss = loss_fn(pred, y)  # 计算网络输出和真实值之间的差距，targets为真实值，计算二者差值即为损失# 反向传播optimizer.zero_grad()  # grad属性归零loss.backward()        # 反向传播optimizer.step()       # 每一步自动更新# 记录acc与losstrain_acc  += (pred.argmax(1) == y).type(torch.float).sum().item()train_loss += loss.item()train_acc  /= sizetrain_loss /= num_batchesreturn train_acc, train_lossdef test (dataloader, model, loss_fn):size        = len(dataloader.dataset)  # 测试集的大小，一共10000张图片num_batches = len(dataloader)          # 批次数目，313（10000/32=312.5，向上取整）test_loss, test_acc = 0, 0# 当不进行训练时，停止梯度更新，节省计算内存消耗with torch.no_grad():for imgs, target in dataloader:imgs, target = imgs.to(device), target.to(device)# 计算losstarget_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  /= sizetest_loss /= num_batchesreturn test_acc, test_lossepochs     = 20
train_loss = []
train_acc  = []
test_loss  = []
test_acc   = []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)train_acc.append(epoch_train_acc)train_loss.append(epoch_train_loss)test_acc.append(epoch_test_acc)test_loss.append(epoch_test_loss)template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%，Test_loss:{:.3f}')print(template.format(epoch+1, epoch_train_acc*100, epoch_train_loss, epoch_test_acc*100, epoch_test_loss))
print('Done')

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        #分辨率from datetime import datetime
current_time = datetime.now() # 获取当前时间epochs_range = range(epochs)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.xlabel(current_time) # 打卡请带上时间戳，否则代码截图无效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()

from PIL import Image classes = list(total_data.class_to_idx)def predict_one_image(image_path, model, transform, classes):test_img = Image.open(image_path).convert('RGB')# plt.imshow(test_img)  # 展示预测的图片test_img = transform(test_img)img = test_img.to(device).unsqueeze(0)model.eval()output = model(img)_,pred = torch.max(output,1)pred_class = classes[pred]print(f'预测结果是：{pred_class}')# 预测训练集中的某张照片
predict_one_image(image_path='weekj8/data/Others/NM01_01_05.jpg', model=model, transform=train_transforms, classes=classes)

---------------------小结------------------------------

1. Inception架构设计​​：

   • 提出​​Inception模块​​，通过并行堆叠不同尺度的卷积核（1x1、3x3、5x5）和池化层，融合多尺度特征，提升网络表达能力。
   • 引入​​1x1卷积​​进行通道降维，减少计算复杂度，平衡网络的深度和宽度。

2. ​​训练与优化​​：

   • 使用​​辅助分类器​​（附加在中间层的分类器）缓解梯度消失问题，增强反向传播信号。
   • 采用多尺度图像裁剪（144种裁剪/图像）和模型集成（7个模型），显著提升分类准确率。

主要缺点​​：

1. ​​结构复杂性​​：

   • Inception模块的并行分支设计导致网络结构复杂，调参和实现难度较高。
   • 多分支结构可能引入冗余计算，例如不同分支的特征融合效率有待优化。

2. ​​训练稳定性问题​​：

   • 虽然辅助分类器缓解了梯度消失，但深层网络仍存在梯度传播不均衡问题。
   • 未采用​​Batch Normalization（BN）​​，训练过程对初始化和学习率敏感。

3. ​​信息压缩风险​​：

   • 1x1卷积过度降维可能导致关键特征信息丢失，尤其在浅层网络中影响特征提取效果。

4. ​​大卷积核计算代价​​：

   • 5x5卷积计算量较大，尽管通过1x1卷积降维，但仍存在优化空间（如分解为小卷积核）。

 ​​后续优化方向​​：

1. ​​结构简化与模块改进​​：

   • ​​Inception V2/V3​​：将5x5卷积分解为​​两个3x3卷积​​（减少参数量，增强非线性），并引入​​BN层​​提升训练稳定性。
   • ​​Inception V4​​：结合残差连接（ResNet思想），简化模块设计并加速梯度传播。

2. ​​高效特征提取​​：

   • ​​Xception​​：极端化Inception思想，采用​​深度可分离卷积​​（Depthwise Separable Conv），分离空间与通道特征计算，进一步提升效率。