VGGNet与GoogleNet架构解析：如何选择适合图像识别的CNN经典模型

1次阅读

没有评论

共计 2414 个字符，预计需要花费 7 分钟才能阅读完成。

在深度学习图像识别领域，选择合适的 CNN 架构往往能决定项目的成败。今天我们就来聊聊两大经典网络 VGGNet 和 GoogleNet，看看它们各自的特点和适用场景。

在实际项目中，我们常常面临这样的困境：

计算资源有限，但需要较高的识别精度
模型太大导致部署困难
训练数据量不足，容易过拟合

这就是为什么理解不同网络架构的特性如此重要。

VGGNet 的最大特点就是它的均匀性：

使用连续的 3×3 卷积核堆叠
每经过几个卷积层就接一个最大池化
最后使用全连接层进行分类

这种设计带来了几个优势：

通过堆叠小卷积核可以获得与大卷积核相同的感受野，但参数更少
结构简单，易于理解和实现
在 ImageNet 等大型数据集上表现优异

不过它的缺点也很明显：

参数量大（特别是后面的全连接层）
计算复杂度高
对小数据集容易过拟合

GoogleNet 的最大创新在于它的 Inception 模块：

并行使用不同大小的卷积核（1×1,3×3,5×5）
加入 1×1 卷积进行降维
使用全局平均池化取代全连接层

这种设计带来了几个好处：

多尺度特征融合能力更强
计算效率更高（通过 1×1 卷积降维）
参数量大幅减少

主要缺点：

结构复杂，实现难度较大
容易出现梯度消失问题（特别是深层网络）

指标	VGG16	GoogleNet
参数量	138M	6.8M
FLOPs	15.5B	1.5B
Top- 1 准确率	71.3%	69.8%
Top- 5 准确率	90.1%	89.5%

import torch.nn as nn

class VGGBlock(nn.Module):
    def __init__(self, in_channels, out_channels, num_convs):
        super().__init__()
        layers = []
        for _ in range(num_convs):
            layers += [nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1),
                nn.ReLU(inplace=True)
            ]
            in_channels = out_channels
        layers.append(nn.MaxPool2d(kernel_size=2, stride=2))
        self.block = nn.Sequential(*layers)

    def forward(self, x):
        return self.block(x)

class Inception(nn.Module):
    def __init__(self, in_channels, ch1x1, ch3x3red, ch3x3, ch5x5red, ch5x5, pool_proj):
        super().__init__()
        # 1x1 卷积分支
        self.branch1 = nn.Sequential(nn.Conv2d(in_channels, ch1x1, kernel_size=1),
            nn.ReLU(inplace=True)
        )
        # 1x1 -> 3x3 分支
        self.branch2 = nn.Sequential(nn.Conv2d(in_channels, ch3x3red, kernel_size=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(ch3x3red, ch3x3, kernel_size=3, padding=1),
            nn.ReLU(inplace=True)
        )
        # 1x1 -> 5x5 分支
        self.branch3 = nn.Sequential(nn.Conv2d(in_channels, ch5x5red, kernel_size=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(ch5x5red, ch5x5, kernel_size=5, padding=2),
            nn.ReLU(inplace=True)
        )
        # 3x3 池化 -> 1x1 分支
        self.branch4 = nn.Sequential(nn.MaxPool2d(kernel_size=3, stride=1, padding=1),
            nn.Conv2d(in_channels, pool_proj, kernel_size=1),
            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)