专栏：神经网络复现目录

---

本章介绍的是现代神经网络的结构和复现，包括深度卷积神经网络（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),)

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

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

查看结构

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

利用VGG16进行CIFAR10分类

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

数据集

# transform的创建（compose方法）
from torchvision import transforms
def get_dataloader_workers():  #@save"""使用4个进程来读取数据"""return 4def load_data_cifar10(batch_size, resize=None):  #@savetrans = [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)

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

from torch import optim
net=VGG16()
lr=0.001
optimizer=optim.SGD(net.parameters(),lr=lr,momentum=0.9)
loss=nn.CrossEntropyLoss()
epochs=10

训练

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 = 0for 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+=1if(train_step%50==0):#每训练一百组输出一次损失print("第{}轮的第{}次训练的loss:{}".format((epoch+1),train_step,l.item()))