现代神经网络(VGG)，并用VGG16进行实战CIFAR10分类_vgg16项目实战

专栏：神经网络复现目录

---

本章介绍的是现代神经网络的结构和复现，包括深度卷积神经网络（AlexNet），VGG，NiN，GoogleNet，残差网络（ResNet），稠密连接网络（DenseNet）。
文章部分文字和代码来自《动手学深度学习》

---

使用块的网络(VGG)

VGG是一种深度卷积神经网络，由牛津大学视觉几何组（Visual Geometry Group）在2014年提出。它是由多个卷积层和池化层组成的深度神经网络，具有很强的图像分类能力，特别是在图像识别领域，取得了很好的成果。

VGG的特点在于，它使用相对较小的卷积核（3x3），但是通过叠加多个卷积层和池化层，增加了网络的深度，从而达到更好的图像分类性能。VGG网络包含了多个版本，以卷积层数目为标志，如VGG16和VGG19等，其中VGG16和VGG19是最著名的两个版本。

VGG网络的设计非常简单和规整，容易理解和实现，因此也成为了很多深度学习新手的入门模型。

下图为VGG的六个版本，比较实用的是VGG16和VGG19，本文以VGG16为例子进行讲解

VGG块

定义

VGG块是VGG网络中的一个基本组成单元，由若干个卷积层和池化层组成，通常用于提取输入图像的特征。每个VGG块都由连续的1或2个卷积层，和一个最大池化层组成。其中，卷积层的卷积核大小都是3x3，而池化层的窗口大小通常是2x2。在每个VGG块中，卷积层的输出通道数都相同，可以通过超参数进行控制。

具体来说，假设一个VGG块由k个卷积层和一个池化层组成，输入为$x$，则该块的输出可以表示为：

$$\text{VGG}(x)=\text{Pool}(\text{conv}k(\text{conv}k-1(\cdots {\text{conv}}_1(x)))).$$

其中，${\text{conv}}_i(\cdot )$表示第$i$个卷积层，$\text{Pool}(\cdot )$表示池化层。在VGG块中，每个卷积层都会使用ReLU激活函数进行非线性变换，而最大池化层则用于下采样和特征压缩。

在VGG网络中，通常通过叠加多个VGG块来构建网络结构。通过增加VGG块的数量，可以增加网络的深度和宽度，从而提高网络的表达能力和泛化性能。

实现

self.conv1=nn.Sequential(
            nn.Conv2d(in_channels=3,out_channels=64,kernel_size=3,padding=1,stride=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(in_channels=64,out_channels=64,kernel_size=3,padding=1,stride=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2,stride=2),
        )
1
2
3
4
5
6
7

inplace=True 表示对于输入的张量进行原地操作，即直接对原始的输入张量进行修改，而不是创建一个新的张量。这样做可以节省内存，但会覆盖原始的输入张量，可能会对后续的计算产生影响。因此，当我们需要保留原始的输入张量时，可以将 inplace 参数设置为 False。

VGG和AlexNet的区别

AlexNet和VGG是两个比较早的深度学习卷积神经网络模型，它们都是在ImageNet数据集上进行训练的。它们的主要区别如下：

1. 模型深度不同：AlexNet相对于传统的浅层神经网络，深度更深；而VGG更加深层，包含更多的卷积层和参数。

2. 卷积核尺寸不同：AlexNet中第一个卷积层采用的是11x11的卷积核，而VGG中卷积核的大小为3x3，这个设计使得VGG拥有更多的卷积层和更少的参数。

3. 全连接层的区别：AlexNet的全连接层较少，VGG的全连接层较多，这使得VGG需要更多的内存和计算资源。

综上所述，AlexNet相对于VGG来说，更浅、更宽，拥有更多的全连接层，而VGG则更深、更窄，拥有更多的卷积层和更少的全连接层。

VGG16

模型设计

VGG16是一个卷积神经网络模型，包含13个卷积层、5个池化层和3个全连接层，是由牛津大学计算机视觉组（Visual Geometry Group）在2014年提出的模型，具有较好的图像识别表现。

VGG16模型的架构如下：

输入层：输入图像的大小为224x224x3。

VGG块1

卷积层1：使用64个3x3大小的卷积核进行卷积操作，得到64张大小为224x224的特征图。采用SAME填充，步长为1。然后再通过ReLU非线性激活函数进行激活。

卷积层2：使用64个3x3大小的卷积核进行卷积操作，得到64张大小为224x224的特征图。采用SAME填充，步长为1。然后再通过ReLU非线性激活函数进行激活。

池化层1：使用2x2的最大池化操作，将64张大小为224x224的特征图缩小为64张大小为112x112的特征图。采用SAME填充，步长为2。

VGG块2

卷积层3：使用128个3x3大小的卷积核进行卷积操作，得到128张大小为112x112的特征图。采用SAME填充，步长为1。然后再通过ReLU非线性激活函数进行激活。

卷积层4：使用128个3x3大小的卷积核进行卷积操作，得到128张大小为112x112的特征图。采用SAME填充，步长为1。然后再通过ReLU非线性激活函数进行激活。

池化层2：使用2x2的最大池化操作，将128张大小为112x112的特征图缩小为128张大小为56x56的特征图。采用SAME填充，步长为2。

VGG块3

卷积层5：使用256个3x3大小的卷积核进行卷积操作，得到256张大小为56x56的特征图。采用SAME填充，步长为1。然后再通过ReLU非线性激活函数进行激活。

卷积层6：使用256个3x3大小的卷积核进行卷积操作，得到256张大小为56x56的特征图。采用SAME填充，步长为1。然后再通过ReLU非线性激活函数进行激活。

卷积层7：使用256个3x3大小的卷积核进行卷积操作，得到256张大小为56x56的特征图。采用SAME填充，步长为1。然后再通过ReLU非线性激活函数进行激活。

池化层3：使用2x2的最大池化操作，将256张大小为56x56的特征图缩小为256张大小为28x28的特征图。采用SAME填充，步长为2。

VGG块4

卷积层8-10：使用512个3x3大小的卷积核进行卷积操作，得到512张大小为28x28的特征图。采用SAME填充，步长为1。然后再通过ReLU非线性激活函数进行激活。

池化层4：使用2x2的最大池化操作，将512张大小为28x28的特征图缩小为512张大小为14x14的特征图。采用SAME填充，步长为2。

VGG块5

卷积层11-13：使用512个3x3大小的卷积核进行卷积操作，得到512张大小为14x14的特征图。采用SAME填充，步长为1。然后再通过ReLU非线性激活函数进行激活。

池化层5：使用2x2的最大池化操作，将512张大小为14x14的特征图缩小为512张大小为7x7的特征图。采用SAME填充，步长为2。

全连接层

3个全连接层，第1、2个都有4096个输出通道，第3个全连接层则有1000个输出通道。

实现

class VGG16(nn.Module):
    def __init__(self):
        super(VGG16,self).__init__()
        self.conv1=nn.Sequential(
            nn.Conv2d(in_channels=3,out_channels=64,kernel_size=3,padding=1,stride=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(in_channels=64,out_channels=64,kernel_size=3,padding=1,stride=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2,stride=2),
        )
        self.conv2=nn.Sequential(
            nn.Conv2d(in_channels=64,out_channels=128,kernel_size=3,padding=1,stride=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(in_channels=128,out_channels=128,kernel_size=3,padding=1,stride=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2,stride=2),
        )
        self.conv3=nn.Sequential(
            nn.Conv2d(in_channels=128,out_channels=256,kernel_size=3,padding=1,stride=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(in_channels=256,out_channels=256,kernel_size=3,padding=1,stride=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(in_channels=256,out_channels=256,kernel_size=3,padding=1,stride=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2,stride=2),
        )
        self.conv4=nn.Sequential(
            nn.Conv2d(in_channels=256,out_channels=512,kernel_size=3,padding=1,stride=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(in_channels=512,out_channels=512,kernel_size=3,padding=1,stride=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(in_channels=512,out_channels=512,kernel_size=3,padding=1,stride=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2,stride=2),
        )
        self.conv5=nn.Sequential(
            nn.Conv2d(in_channels=512,out_channels=512,kernel_size=3,padding=1,stride=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(in_channels=512,out_channels=512,kernel_size=3,padding=1,stride=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(in_channels=512,out_channels=512,kernel_size=3,padding=1,stride=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2,stride=2),
        )
        self.feature=nn.Sequential(
            self.conv1,
            self.conv2,
            self.conv3,
            self.conv4,
            self.conv5,
        )
        self.flatten=nn.Flatten()
        self.fc=nn.Sequential(
            nn.Linear(512*7*7,4096),
            nn.ReLU(inplace=True),
            nn.Dropout(0.4),
            nn.Linear(4096,4096),
            nn.ReLU(inplace=True),
            nn.Dropout(0.4),
            nn.Linear(4096,1000),
            #nn.Softmax(10)
        )
    def forward(self,x):
        x=self.feature(x)
        # x=self.flatten(x)
        x = x.view(x.size(0), -1)
        x=self.fc(x)
        return x

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

查看结构

vgg = VGG16()
print(vgg)
x=torch.rand(1,3,224,224)
y=vgg(x)
print(y.shape)
1
2
3
4
5

利用VGG16进行CIFAR10分类

import torch.nn as nn
import torch
import torchvision

if(torch.cuda.is_available()):
    device = torch.device("cuda")
    print("使用GPU训练中：{}".format(torch.cuda.get_device_name()))
else:
    device = torch.device("cpu")
    print("使用CPU训练")

1
2
3
4
5
6
7
8
9
10
11

数据集

# transform的创建（compose方法）
from torchvision import transforms
def get_dataloader_workers():  #@save
    """使用4个进程来读取数据"""
    return 4

def load_data_cifar10(batch_size, resize=None):  #@save
    trans = [transforms.ToTensor()]
    if resize:
        trans.insert(0, transforms.Resize(resize))
    trans = transforms.Compose(trans)
    mnist_train = torchvision.datasets.CIFAR10(
        root="../data", train=True, transform=trans, download=True)
    mnist_test = torchvision.datasets.CIFAR10(
        root="../data", train=False, transform=trans, download=True)
    return (torch.utils.data.DataLoader(mnist_train, batch_size, shuffle=True,
                            num_workers=get_dataloader_workers()),
            torch.utils.data.DataLoader(mnist_test, batch_size, shuffle=False,
                            num_workers=get_dataloader_workers()))
batch_size=4
train_iter, test_iter = load_data_cifar10(batch_size,resize=224)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

超参数，优化器，损失函数

from torch import optim
net=VGG16()
lr=0.001
optimizer=optim.SGD(net.parameters(),lr=lr,momentum=0.9)
loss=nn.CrossEntropyLoss()
epochs=10
1
2
3
4
5
6

训练

def train(net,train_iter,test_iter,num_epochs, lr, device):
    def init_weights(m):
        if type(m) == nn.Linear or type(m) == nn.Conv2d:
            nn.init.xavier_uniform_(m.weight)
    net.apply(init_weights)
    print('training on', device)
    net.to(device)
    for epoch in range(num_epochs):
        net.train()
        train_step = 0
        for i, (X, y) in enumerate(train_iter):
            optimizer.zero_grad()
            X, y = X.to(device), y.to(device)
            y_hat = net(X)
            l=loss(y_hat,y)
            l.backward()
            optimizer.step()
            train_step+=1
            if(train_step%50==0):#每训练一百组输出一次损失
                print("第{}轮的第{}次训练的loss:{}".format((epoch+1),train_step,l.item()))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21