Day 54 Inception 网络及其思考

haiyu_y2026-01-03 9:46

文章目录

  • [Day 54 · Inception 网络及其思考](#Day 54 · Inception 网络及其思考)
    • [一、Inception 网络介绍](#一、Inception 网络介绍)
      • [1.1 背景与动机](#1.1 背景与动机)
      • [1.2 核心设计理念](#1.2 核心设计理念)
      • [1.3 Inception 模块的组成](#1.3 Inception 模块的组成)
    • [二、Inception 网络架构](#二、Inception 网络架构)
      • [2.1 定义 Inception 模块](#2.1 定义 Inception 模块)
      • [2.2 特征融合方法](#2.2 特征融合方法)
      • [2.3 InceptionNet 网络定义](#2.3 InceptionNet 网络定义)
      • [2.4 Inception 网络的版本演进](#2.4 Inception 网络的版本演进)
    • 三、卷积核的变体
      • [3.1 感受野（Receptive Field）](#3.1 感受野（Receptive Field）)
      • [3.2 空洞卷积（Dilated Convolution）](#3.2 空洞卷积（Dilated Convolution）)
      • [3.3 空洞卷积示例](#3.3 空洞卷积示例)
    • 四、总结

Day 54 · Inception 网络及其思考

学习目标：

  • 理解 Inception 网络的核心设计理念
  • 掌握多尺度特征融合的实现方法
  • 了解特征融合的常见方式
  • 学习卷积核变体与感受野的概念

一、Inception 网络介绍

1.1 背景与动机

Inception 网络（也称为 GoogLeNet）是 Google 团队在 2014 年提出的经典卷积神经网络架构。

参考资料： 传统计算机视觉的发展史

从历史发展来看，Inception 网络实际上出现在 ResNet 之前。之所以在学习 ResNet 后再介绍它，是因为 Inception 引出了重要的特征融合 和特征并行处理思想。

1.2 核心设计理念

Inception 网络的核心设计理念是 "并行的多尺度融合"，具体表现为：

  • 在同一层网络中使用多个不同大小的卷积核（如 1x1、3x3、5x5）
  • 结合池化操作，从不同尺度提取图像特征
  • 将这些特征进行融合
  • 在不增加过多计算量的情况下，获得更丰富的特征表达

1.3 Inception 模块的组成

Inception 模块是 Inception 网络的基本组成单元。

关键洞察： 在同样的步长下：

  • 卷积核越小，下采样率越低，保留的图片像素越多
  • 卷积核越大，越能捕捉像素周围的信息

一个典型的 Inception 模块包含以下四个并行分支：

分支 描述 作用
1x1 卷积分支 用于降维 减少后续卷积的计算量，同时提取局部特征
3x3 卷积分支 中等尺度卷积 捕捉中等尺度的特征
5x5 卷积分支 较大尺度卷积 捕捉较大尺度的特征
池化分支 最大/平均池化 保留图像的全局信息

二、Inception 网络架构

2.1 定义 Inception 模块

python 复制代码 
import torch
import torch.nn as nn

class Inception(nn.Module):
    """
    Inception 模块：实现多尺度特征并行提取与融合
    
    该模块包含四个并行分支：
    - 1x1 卷积分支：降维并提取通道间特征关系
    - 3x3 卷积分支：捕捉中等尺度特征
    - 5x5 卷积分支：捕捉大尺度特征
    - 池化分支：保留全局信息
    
    参数:
        in_channels: 输入特征图的通道数
    """
    
    def __init__(self, in_channels):
        super(Inception, self).__init__()
        
        # ========== 分支1：1x1 卷积 ==========
        # 作用：降维并提取通道间特征关系
        self.branch1x1 = nn.Sequential(
            nn.Conv2d(in_channels, 64, kernel_size=1),
            nn.ReLU()
        )
        
        # ========== 分支2：3x3 卷积 ==========
        # 作用：先降维，再用 3x3 卷积捕捉中等尺度特征
        self.branch3x3 = nn.Sequential(
            nn.Conv2d(in_channels, 96, kernel_size=1),
            nn.ReLU(),
            nn.Conv2d(96, 128, kernel_size=3, padding=1),
            nn.ReLU()
        )
        
        # ========== 分支3：5x5 卷积 ==========
        # 作用：较大的感受野用于提取更全局的结构信息
        self.branch5x5 = nn.Sequential(
            nn.Conv2d(in_channels, 16, kernel_size=1),
            nn.ReLU(),
            nn.Conv2d(16, 32, kernel_size=5, padding=2),
            nn.ReLU()
        )
        
        # ========== 分支4：池化分支 ==========
        # 作用：通过池化操作保留全局信息并降维
        self.branch_pool = nn.Sequential(
            nn.MaxPool2d(kernel_size=3, stride=1, padding=1),
            nn.Conv2d(in_channels, 32, kernel_size=1),
            nn.ReLU()
        )

    def forward(self, x):
        """
        前向传播：并行计算四个分支并在通道维度拼接
        
        输出通道数 = 64 + 128 + 32 + 32 = 256
        """
        branch1x1 = self.branch1x1(x)      # [batch, 64, H, W]
        branch3x3 = self.branch3x3(x)      # [batch, 128, H, W]
        branch5x5 = self.branch5x5(x)      # [batch, 32, H, W]
        branch_pool = self.branch_pool(x)  # [batch, 32, H, W]
        
        outputs = [branch1x1, branch3x3, branch5x5, branch_pool]
        return torch.cat(outputs, dim=1)

维度变化： [B, C, H, W] 到 [B, 256, H, W]

无论输入通道数是多少，输出通道数固定为 256（64+128+32+32）。

python 复制代码 
# 测试 Inception 模块
model = Inception(in_channels=64)
input_tensor = torch.randn(32, 64, 28, 28)  # batch=32, channels=64, H=W=28
output = model(input_tensor)

print(f"输入形状: {input_tensor.shape}")
print(f"输出形状: {output.shape}")  # 预期: [32, 256, 28, 28]
复制代码 
输入形状: torch.Size([32, 64, 28, 28])
输出形状: torch.Size([32, 256, 28, 28])

设计要点：

Inception 模块中不同的卷积核和步长最后输出同样尺寸的特征图，这是经过精心设计的：

  • 必须保证空间尺寸对齐
  • 才能在通道维度正确拼接（concat）

2.2 特征融合方法

Inception 模块采用 Concat（拼接） 的方式将不同尺度的特征融合在一起。

Concat 拼接的特点：
  • 通道数增加
  • 空间尺寸（H, W）保持不变
  • 每个通道的数值保持独立，没有加法运算
深度学习中常见的特征融合方式：

1. 逐元素相加（残差连接）

python 复制代码 
output = x + self.residual_block(x)

2. 逐元素相乘（注意力机制）

python 复制代码 
attention = self.ChannelAttention(features)
weighted_features = features * attention

3. 通道拼接

python 复制代码 
output = torch.cat([f1, f2], dim=1)
方法 维度变化 计算量 典型场景
concat 通道数增加 中 Inception、U-Net
逐元素相加 维度不变 低 ResNet、DenseNet 过渡层
逐元素相乘 维度不变 中（需权重） 注意力机制、门控网络
跳跃连接（concat） 通道数增加 中 U-Net、FPN
加权融合（SE-Net） 维度不变 低 通道特征重标定
空间金字塔池化（SPP） 通道数增加 中 目标检测、尺寸自适应任务

2.3 InceptionNet 网络定义

python 复制代码 
class InceptionNet(nn.Module):
    """
    简化版 InceptionNet：用于图像分类
    
    网络结构：
    1. 卷积层（初始特征提取）
    2. Inception 模块 x 2（多尺度特征融合）
    3. 全局平均池化 + 全连接层（分类输出）
    """
    
    def __init__(self, num_classes=10):
        super(InceptionNet, self).__init__()
        
        # 初始卷积层
        self.conv1 = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        )
        
        # Inception 模块
        self.inception1 = Inception(64)
        self.inception2 = Inception(256)
        
        # 分类头
        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.fc = nn.Linear(256, num_classes)

    def forward(self, x):
        x = self.conv1(x)
        x = self.inception1(x)
        x = self.inception2(x)
        x = self.avgpool(x)
        x = torch.flatten(x, 1)
        x = self.fc(x)
        return x
python 复制代码 
# 测试 InceptionNet
model = InceptionNet(num_classes=10)
input_tensor = torch.randn(1, 3, 224, 224)
output = model(input_tensor)
print(f"输入形状: {input_tensor.shape}")
print(f"输出形状: {output.shape}")
复制代码 
输入形状: torch.Size([1, 3, 224, 224])
输出形状: torch.Size([1, 10])

2.4 Inception 网络的版本演进

版本 特点
Inception v1 (GoogLeNet) 最初版本，引入 Inception 模块
Inception v2 使用 Batch Normalization
Inception v3 进一步分解卷积核
Inception v4 更深的网络结构
Inception-ResNet 引入残差连接

三、卷积核的变体

3.1 感受野（Receptive Field）

感受野是指在 CNN 中，神经元在原始输入图像上所对应的区域大小。

感受野计算示例（3x3 卷积，步长 1）：

  • 第一层感受野 = 3x3
  • 第二层感受野 = 5x5（计算公式：3+3-1=5）

小卷积核的优势：

  1. 减少参数量
  2. 引入更多非线性（多次经过激活函数）

3.2 空洞卷积（Dilated Convolution）

空洞卷积在卷积核元素间插入空洞，用 dilation rate (d) 控制间隔大小。

类型 描述
标准卷积（d=1） 卷积核元素紧密排列
空洞卷积（d>1） 卷积核元素间插入 d-1 个空洞

优点：

  • 扩大感受野而不增加参数
  • 保持空间信息（相比池化下采样）

3.3 空洞卷积示例

使用空洞卷积只需添加 dilation 参数：

python 复制代码 
# 空洞卷积（dilation=2）
self.conv = nn.Conv2d(16, 32, kernel_size=3, padding=2, dilation=2)
python 复制代码 
import torch
import torch.nn as nn
import torchvision
import torchvision.transforms as transforms
from torch.utils.data import DataLoader

# 数据预处理
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

# 加载 CIFAR-10 数据集
trainset = torchvision.datasets.CIFAR10(
    root='./data', train=True, download=True, transform=transform
)
trainloader = DataLoader(trainset, batch_size=128, shuffle=True)

testset = torchvision.datasets.CIFAR10(
    root='./data', train=False, download=True, transform=transform
)
testloader = DataLoader(testset, batch_size=128, shuffle=False)


class SimpleCNNWithDilation(nn.Module):
    """包含空洞卷积的简单 CNN 模型"""
    
    def __init__(self):
        super(SimpleCNNWithDilation, self).__init__()
        self.conv1 = nn.Conv2d(3, 16, kernel_size=3, padding=1)
        # 空洞卷积，dilation=2
        self.conv2 = nn.Conv2d(16, 32, kernel_size=3, padding=2, dilation=2)
        self.conv3 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        
        self.pool = nn.MaxPool2d(2, 2)
        self.relu = nn.ReLU()
        
        self.fc1 = nn.Linear(64 * 8 * 8, 256)
        self.fc2 = nn.Linear(256, 10)

    def forward(self, x):
        x = self.pool(self.relu(self.conv1(x)))
        x = self.pool(self.relu(self.conv2(x)))
        x = self.relu(self.conv3(x))
        x = x.view(-1, 64 * 8 * 8)
        x = self.relu(self.fc1(x))
        x = self.fc2(x)
        return x


# 训练配置
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = SimpleCNNWithDilation().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)


def train(epoch):
    model.train()
    running_loss = 0.0
    for i, (inputs, labels) in enumerate(trainloader):
        inputs, labels = inputs.to(device), labels.to(device)
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
        if (i + 1) % 100 == 0:
            print(f'Epoch: {epoch + 1}, Batch: {i + 1}, Loss: {running_loss / 100:.3f}')
            running_loss = 0.0


def test():
    model.eval()
    correct = 0
    total = 0
    with torch.no_grad():
        for images, labels in testloader:
            images, labels = images.to(device), labels.to(device)
            outputs = model(images)
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    print(f'Accuracy on test set: {100 * correct / total:.2f}%')


# 训练 5 个 epoch
for epoch in range(5):
    train(epoch)
    test()
复制代码 
Epoch: 1, Batch: 100, Loss: 1.835
Epoch: 1, Batch: 200, Loss: 1.508
Epoch: 1, Batch: 300, Loss: 1.399
Accuracy on test set: 54.53%
Epoch: 2, Batch: 100, Loss: 1.222
Epoch: 2, Batch: 200, Loss: 1.184
Epoch: 2, Batch: 300, Loss: 1.115
Accuracy on test set: 62.45%
Epoch: 3, Batch: 100, Loss: 1.020
Epoch: 3, Batch: 200, Loss: 1.008
Epoch: 3, Batch: 300, Loss: 0.986
Accuracy on test set: 65.47%
Epoch: 4, Batch: 100, Loss: 0.895
Epoch: 4, Batch: 200, Loss: 0.899
Epoch: 4, Batch: 300, Loss: 0.873
Accuracy on test set: 66.70%
Epoch: 5, Batch: 100, Loss: 0.788
Epoch: 5, Batch: 200, Loss: 0.783
Epoch: 5, Batch: 300, Loss: 0.796
Accuracy on test set: 70.19%

四、总结

本节要点回顾：

  1. Inception 网络核心思想

    • 并行的多尺度特征融合
    • 使用不同大小的卷积核（1x1、3x3、5x5）+ 池化
    • 通过 1x1 卷积降维减少计算量

  2. 特征融合方式

    • Concat（通道拼接）
    • 逐元素相加（残差连接）
    • 逐元素相乘（注意力机制）

  3. 感受野与卷积变体

    • 感受野决定了网络能"看到"的范围
    • 空洞卷积可以在不增加参数的情况下扩大感受野

@浙大疏锦行

相关推荐
2501_9413331010 小时前
乒乓球比赛场景目标检测与行为分析研究
人工智能·目标检测·计算机视觉
岑梓铭10 小时前
YOLO深度学习(计算机视觉)一很有用！！(进一步加快训练速度的操作)
人工智能·深度学习·神经网络·yolo·计算机视觉
2401_8414956410 小时前
深度卷积生成对抗网络（DCGAN）
人工智能·python·深度学习·神经网络·机器学习·生成对抗网络·深度卷积生成对抗网络
byzh_rc10 小时前
[深度学习网络从入门到入土] 反向传播backprop
网络·人工智能·深度学习
BOLD-Rainbow10 小时前
DCRNN (Diffusion Convolutional Recurrent Neural Network)
人工智能·深度学习·机器学习
zhangfeng113310 小时前
如何用小内存电脑训练大数据的bpe，16g内存训练200g数据集默认是一次性读入内存训练
大数据·人工智能
Candice Can10 小时前
【机器学习】吴恩达机器学习Lecture1
人工智能·机器学习·吴恩达机器学习
老蒋每日coding10 小时前
AI Agent 设计模式系列（十五）—— A2A Agent 间通信模式
人工智能·设计模式
搞科研的小刘选手10 小时前
【智能检测专题】2026年智能检测与运动控制技术国际会议（IDMCT 2026）
人工智能·学术会议·智能计算·电子技术·智能检测·运动控制技术·南京工业大学
Elastic 中国社区官方博客10 小时前
Agent Builder 现已正式发布：在几分钟内发布上下文驱动的 agents
大数据·人工智能·elasticsearch·搜索引擎·ai·全文检索
热门推荐
01GitHub 镜像站点02OpenCode 入门教程：介绍 · 安装 · 配置第三方 API (如 Claude)03Claude Code Skills 实用使用手册04UV安装并设置国内源05Linux下V2Ray安装配置指南06BongoCat - 跨平台键盘猫动画工具07安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）08在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）09Open Code教程（四）| 高级配置与集成10MC.JS 网页版《我的世界》 免安装中文版