VGG16是由牛津大学视觉几何组（Visual Geometry Group）提出的一种深度卷积神经网络模型。

        VGGNet 探索了卷积神经网络的深度与其性能之间的关系，成功地构筑了 16~19 层深的卷积神经网络，同时拓展性又很强，迁移到其它图片数据上的泛化性也非常好。到目前为止，VGG 仍然被用来提取图像特征。

        对VGGNet的介绍，这篇文章很优秀：大话CNN经典模型：VGGNet - OSCHINA - 中文开源技术交流社区

        部分摘抄：

        VGGNet的网络结构：
        下图是来自论文《Very Deep Convolutional Networks for Large-Scale Image Recognition》（基于甚深层卷积网络的大规模图像识别）的 VGG 网络结构，正是在这篇论文中提出了 VGG，如下图：

        在这篇论文中分别使用了 A、A-LRN、B、C、D、E 这 6 种网络结构进行测试，这 6 种网络结构相似，都是由 5 层卷积层、3 层全连接层组成，其中区别在于每个卷积层的子层数量不同，从 A 至 E 依次增加（子层数量从 1 到 4），总的网络深度从 11 层到 19 层（添加的层以粗体显示），表格中的卷积层参数表示为 “conv〈感受野大小〉- 通道数〉”，例如 con3-128，表示使用 3x3 的卷积核，通道数为 128。为了简洁起见，在表格中不显示 ReLU 激活功能。
其中，网络结构 D 就是著名的 VGG16，网络结构 E 就是著名的 VGG19。

        以网络结构 D（VGG16）为例，介绍其处理过程如下，请对比上面的表格和下方这张图，留意图中的数字变化，有助于理解 VGG16 的处理过程：

1 、输入 224x224x3 的图片，经 64 个 3x3 的卷积核作两次卷积 + ReLU，卷积后的尺寸变为 224x224x64
2、作 max pooling（最大化池化），池化单元尺寸为 2x2（效果为图像尺寸减半），池化后的尺寸变为 112x112x64
3、经 128 个 3x3 的卷积核作两次卷积 + ReLU，尺寸变为 112x112x128
4、作 2x2 的 max pooling 池化，尺寸变为 56x56x128
5、经 256 个 3x3 的卷积核作三次卷积 + ReLU，尺寸变为 56x56x256
6、作 2x2 的 max pooling 池化，尺寸变为 28x28x256
7、经 512 个 3x3 的卷积核作三次卷积 + ReLU，尺寸变为 28x28x512
8、作 2x2 的 max pooling 池化，尺寸变为 14x14x512
9、经 512 个 3x3 的卷积核作三次卷积 + ReLU，尺寸变为 14x14x512
10、作 2x2 的 max pooling 池化，尺寸变为 7x7x512
11、与两层 1x1x4096，一层 1x1x1000 进行全连接 + ReLU（共三层）
12、通过 softmax 输出 1000 个预测结果

其简化图如下（以 VGG16 为例）： 

代码实现：新建vggNet.py

import torch
import torch.nn as nn
import torch.nn.functional as F


class VGGbase(nn.Module):
    def __init__(self, num_classes=10):
        super(VGGbase, self).__init__()
        self.conv1 = nn.Sequential(  # 定义第1个卷积层
            # Sequential 是一个容器，它可以包含一系列的神经网络层（layers），并按顺序执行它们。具体来说，
            # nn.Sequential( 允许您将多个层定义为一个整体，这个整体可以被视为一个单独的层。
            # 当您向神经网络传递数据时，数据会依次通过 Sequential 中定义的每一层。
            # 这种方式简化了网络结构的定义和理解，尤其是在构建较为复杂的网络时。
            nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1),  # 输入通道为3，输出通道为64，卷积核大小为3x3，步长为1，填充为1
            nn.BatchNorm2d(64),  # 批量归一化
            # nn.BatchNorm2d 表示对二维输入进行批量归一化，参数 64 通常代表输入特征的通道数。批量归一化的作用是在神经网络训练过程中，对每一批次的数据进行归一化处理，
            # 使得数据的分布更加稳定，有助于加速训练过程、提高模型的泛化能力。
            nn.ReLU()  # 激活函数
        )
        self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)  # 最大池化，池化核大小为2x2，步长为2
        # 经过第一层卷积后，图像的尺寸为 16x16，通道数为64

        self.conv2_1 = nn.Sequential(  # 定义第2个卷积层的第一次卷积
            nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),  # 输入通道为64，输出通道为128，卷积核大小为3x3，步长为1，填充为1
            nn.BatchNorm2d(128),  # 批量归一化
            nn.ReLU()  # 激活函数
        )

        self.conv2_2 = nn.Sequential(  # 定义第2个卷积层的第二次卷积
            nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1),  # 输入通道为64，输出通道为128，卷积核大小为3x3，步长为1，填充为1
            nn.BatchNorm2d(128),  # 批量归一化
            nn.ReLU()  # 激活函数
        )
        self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)  # 最大池化，池化核大小为2x2，步长为2
        # 经过第二层卷积后，图像的尺寸为 8x8，通道数为128

        self.conv3_1 = nn.Sequential(  # 定义第3个卷积层的第一次卷积
            nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1),  # 输入通道为64，输出通道为128，卷积核大小为3x3，步长为1，填充为1
            nn.BatchNorm2d(256),  # 批量归一化
            nn.ReLU()  # 激活函数
        )

        self.conv3_2 = nn.Sequential(  # 定义第3个卷积层的第二次卷积
            nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(256),  # 批量归一化
            nn.ReLU()  # 激活函数
        )
        self.pool3 = nn.MaxPool2d(kernel_size=2, stride=2)
        # 经过第三层卷积后，图像的尺寸为 4x4，通道数为256

        self.conv4_1 = nn.Sequential(  # 定义第4个卷积层的第一次卷积
            nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(512),  # 批量归一化
            nn.ReLU()  # 激活函数
        )

        self.conv4_2 = nn.Sequential(  # 定义第4个卷积层的第二次卷积
            nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(512),  # 批量归一化
            nn.ReLU()  # 激活函数
        )
        self.pool4 = nn.MaxPool2d(kernel_size=2, stride=2)  # 最大池化，池化核大小为2x2，步长为2
        # 经过第四层卷积后，图像的尺寸为 2x2，通道数为512

        self.fc = nn.Linear(512 * 4, num_classes)  # 全连接层，输入为512*4，输出为10

    def forward(self, x):   # 定义前向传播过程
        batch_size = x.size(0)  # 获取输入的batch_size
        x = self.conv1(x)  # 第1个卷积层
        x = self.pool1(x)  # 第1个池化层

        x = self.conv2_1(x)  # 第2个卷积层
        x = self.conv2_2(x)  # 第2个卷积层
        x = self.pool2(x)  # 第2个池化层

        x = self.conv3_1(x)  # 第3个卷积层
        x = self.conv3_2(x)  # 第3个卷积层
        x = self.pool3(x)  # 第3个池化层

        x = self.conv4_1(x)  # 第4个卷积层
        x = self.conv4_2(x)  # 第4个卷积层
        x = self.pool4(x)  # 第4个池化层

        x = x.view(batch_size, -1)  # 将图片展开成一行，-1表示自动计算这一维的大小

        x = self.fc(x)   # 全连接层
        output = F.log_softmax(x, dim=1)  # 对输出进行log_softmax处理

        return output


def VGGNet():  # 定义网络结构的应用函数
    return VGGbase()