VGG（使用块的网络）

一、概述

在 AlexNet 证明深层神经网络能有效解决图像分类问题之后，研究人员开始思考怎么让网络设计更模块化、更容易复用。牛津大学的视觉几何组（VGG）提出了一个很重要的思路：把重复的层打包成 “块”，就像搭积木一样用这些块来构建整个网络。

之前的网络设计是一层一层堆起来的，而 VGG 把重复的卷积层和池化层做成一个 “积木块”，然后用这些块来搭建整个网络，这样网络结构更清晰，也给后来的网络设计提供了通用的模板，让后续的网络设计变得更简单。

二、VGG 块：网络的 “积木块”

VGG 块是 VGG 网络的核心，每个块就像一个标准化的 “积木”，里面是重复的卷积层，最后跟着一个最大池化层，用来缩小图像的尺寸。

VGG 块的结构

1. VGG 块的结构

每个 VGG 块的组成很简单：

1. 卷积层：用 3×3 的卷积核，填充为 1（这样卷积之后图像的高度和宽度不会变，因为 3x3 卷积 + 填充 1，步幅 1 的话，输出尺寸和输入一样），每个卷积层后面跟着 ReLU 激活函数，让模型能学习非线性的特征。

2. 最大池化层：用 2×2 的窗口，步幅为 2，这样池化之后图像的高度和宽度都会减半，相当于把图像缩小一半，减少计算量。

2. 代码实现（PyTorch 版）

我们可以用 PyTorch 实现一个 VGG 块的函数：

import torch
from torch import nn

def vgg_block(num_convs, in_channels, out_channels):
    layers = []
    for _ in range(num_convs):
        # 3x3卷积，填充1，保持输入输出尺寸一致
        layers.append(nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1))
        layers.append(nn.ReLU())
        in_channels = out_channels
    # 2x2最大池化，步幅2，让尺寸减半
    layers.append(nn.MaxPool2d(kernel_size=2, stride=2))
    return nn.Sequential(*layers)

这个函数的参数：

• num_convs：这个块里有几个卷积层

• in_channels：输入的通道数

• out_channels：输出的通道数

三、VGG 网络：用积木块搭起来的大网络

VGG 网络就像用上面的 “积木块” 搭起来的大楼，分为两部分：

1. 卷积层部分：用 5 个 VGG 块堆起来，每个块的卷积层数量和输出通道数不同

2. 全连接层部分：和 AlexNet 的全连接层一样，用来把卷积层的输出转换成分类结果

1. VGG-11 的结构

我们最常用的是 VGG-11，它有 8 个卷积层和 3 个全连接层，所以叫 VGG-11，它的结构是：

• 第 1 个块：1 个卷积层，输出通道 64
• 第 2 个块：1 个卷积层，输出通道 128
• 第 3 个块：2 个卷积层，输出通道 256
• 第 4 个块：2 个卷积层，输出通道 512
• 第 5 个块：2 个卷积层，输出通道 512
• 全连接层：3 个全连接层，前两个是 4096 维，最后是 10 维（对应 10 分类任务）

2. 代码实现（PyTorch 版）

我们可以用上面的 VGG 块函数来搭建 VGG-11：

def vgg(conv_arch):
    conv_blks = []
    in_channels = 1  # 输入是单通道的灰度图（Fashion-MNIST是灰度图）
    # 构建卷积层部分
    for (num_convs, out_channels) in conv_arch:
        conv_blks.append(vgg_block(num_convs, in_channels, out_channels))
        in_channels = out_channels
    # 构建整个网络
    return nn.Sequential(
        *conv_blks, nn.Flatten(),
        # 全连接层部分
        nn.Linear(out_channels * 7 * 7, 4096), nn.ReLU(), nn.Dropout(0.5),
        nn.Linear(4096, 4096), nn.ReLU(), nn.Dropout(0.5),
        nn.Linear(4096, 10)
    )

# VGG-11的卷积块配置：(卷积层数量, 输出通道数)
conv_arch = ((1, 64), (1, 128), (2, 256), (2, 512), (2, 512))
net = vgg(conv_arch)

3. 查看网络的输出形状

我们可以用一个随机的输入来看看每个层的输出形状：

# 输入是1张224x224的单通道灰度图
X = torch.randn(size=(1, 1, 224, 224))
for blk in net:
    X = blk(X)
    print(blk.__class__.__name__,'output shape:\t',X.shape)

运行结果是：

Sequential output shape:     torch.Size([1, 64, 112, 112])
Sequential output shape:     torch.Size([1, 128, 56, 56])
Sequential output shape:     torch.Size([1, 256, 28, 28])
Sequential output shape:     torch.Size([1, 512, 14, 14])
Sequential output shape:     torch.Size([1, 512, 7, 7])
Flatten output shape:        torch.Size([1, 25088])
Linear output shape:         torch.Size([1, 4096])
ReLU output shape:   torch.Size([1, 4096])
Dropout output shape:        torch.Size([1, 4096])
Linear output shape:         torch.Size([1, 4096])
ReLU output shape:   torch.Size([1, 4096])
Dropout output shape:        torch.Size([1, 4096])
Linear output shape:         torch.Size([1, 10])

可以看到，每个 VGG 块之后，图像的尺寸都会减半，最后变成 7x7 的特征图，然后展平成 25088 维（51277），再进入全连接层。

四、训练 VGG 模型

VGG-11 的计算量很大，因为通道数多，所以我们用一个 “缩小版” 的 VGG 来训练 Fashion-MNIST，把通道数除以 4，这样计算量变小，适合演示。

1. 构建小版本的 VGG

# 把通道数除以4，构建小版本的VGG
ratio = 4
small_conv_arch = [(pair[0], pair[1] // ratio) for pair in conv_arch]
net = vgg(small_conv_arch)

2. 训练模型

我们用 Fashion-MNIST 数据集来训练，训练参数：

• 学习率 0.05
• 训练 10 轮
• 批量大小 128
• 输入图像 resize 成 224x224（因为 VGG 的输入是 224x224）

import d2l

lr, num_epochs, batch_size = 0.05, 10, 128
# 加载数据集，把图像resize成224x224
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=224)
# 训练模型
d2l.train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())

3. 训练结果

训练完成后，结果大概是：

• 训练准确率 0.935 左右
• 测试准确率 0.92 左右
• 速度是每秒 2400 多个样本（用 GPU 的话）

五、小结

1. VGG 的核心思路是用 “块” 来构建网络，把重复的层打包成块，让网络设计更模块化，更容易复用和修改。

2. VGG-11 是 8 个卷积层 + 3 个全连接层，通道数从 64 翻倍到 512，用 3x3 的窄卷积，比浅层的宽卷积效果更好。

3. VGG 的块结构给后来的网络设计提供了模板，比如 ResNet 也是用块的思路构建的。

4. 深层的窄卷积（3x3）比浅层的宽卷积（比如 5x5）效果更好，因为多个 3x3 卷积可以组合出更大的感受野，而且参数更少，还能增加非线性。

（注：文档部分内容可能由 AI 生成） 源地址