专栏：神经网络复现目录

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

文章目录

• 深度卷积神经网络（AlexNet）
• • 学习表征
  • AlexNet 架构
  • 模型设计
  • 使用模型进行Fashion-MNIST分类
  • • 数据集
    • 超参数、优化器，损失函数
    • 训练
    • 测试
    • 结果

深度卷积神经网络（AlexNet）

学习表征

学习表征（Representation Learning）是机器学习中一个重要的研究领域，旨在通过学习数据的表征，从而更好地完成各种任务。在传统机器学习中，通常需要手工设计特征，然后将这些特征输入到模型中进行训练。这种方法需要具有专业领域知识的人员手工设计特征，费时费力，且很难设计出完美的特征。

而学习表征则是通过机器自动学习数据的特征表示，省去了手动设计特征的过程，提高了效率和性能。学习表征的方法可以分为无监督学习和监督学习两种。其中，无监督学习是指在没有标注信息的情况下学习数据的表征，比如自编码器、受限玻尔兹曼机、深度信念网络等；监督学习则是利用带有标注信息的数据进行学习，比如卷积神经网络、递归神经网络等。

通过学习表征，可以更好地完成各种任务，如图像分类、目标检测、语音识别等。同时，学习表征也是深度学习领域的一个重要研究方向，有助于深入理解深度神经网络的工作原理和特性。

有趣的是，在网络的最底层，模型学习到了一些类似于传统滤波器的特征抽取器。 下图从AlexNet论文 (Krizhevsky et al., 2012)复制的，描述了底层图像特征。

AlexNet的更高层建立在这些底层表示的基础上，以表示更大的特征，如眼睛、鼻子、草叶等等。而更高的层可以检测整个物体，如人、飞机、狗或飞盘。最终的隐藏神经元可以学习图像的综合表示，从而使属于不同类别的数据易于区分。尽管一直有一群执着的研究者不断钻研，试图学习视觉数据的逐级表征，然而很长一段时间里这些尝试都未有突破。深度卷积神经网络的突破出现在2012年。突破可归因于两个关键因素。

AlexNet 架构

若图像大小为A ×\times× A，卷积核大小为D ×\times× D，扩充边缘padding=B，步长stride=C
则卷积后的特征图FeatureMap大小为（A-D+B*2+C）/ C

值得注意的一点：原图输入224 × 224，实际上进行了随机裁剪，实际大小为227 × 227。

1. 卷积层C1
   C1的基本结构为：卷积–>ReLU–>池化
   卷积：输入227 × 227 × 3，96个11×11×3的卷积核，不扩充边缘padding = 0，步长stride = 4，因此其FeatureMap大小为(227-11+0×2+4)/4 = 55，即55×55×96;
   激活函数：ReLU；
   池化：池化核大小3 × 3，不扩充边缘padding = 0，步长stride = 2，因此其FeatureMap输出大小为(55-3+0×2+2)/2=27, 即C1输出为27×27×96（此处未将输出分到两个GPU中，若按照论文将分成两组，每组为27×27×48）
2. 卷积层C2
   C2的基本结构为：卷积–>ReLU–>池化
   卷积：输入27×27×96，256个5×5×96的卷积核，扩充边缘padding = 2， 步长stride = 1，因此其FeatureMap大小为(27-5+2×2+1)/1 = 27，即27×27×256;
   激活函数：ReLU；
   池化：池化核大小3 × 3，不扩充边缘padding = 0，步长stride = 2，因此其FeatureMap输出大小为(27-3+0+2)/2=13, 即C2输出为13×13×256（此处未将输出分到两个GPU中，若按照论文将分成两组，每组为13×13×128）；
3. 卷积层C3
   C3的基本结构为：卷积–>ReLU。注意一点：此层没有进行MaxPooling操作。
   卷积：输入13×13×256，384个3×3×256的卷积核， 扩充边缘padding = 1，步长stride = 1，因此其FeatureMap大小为(13-3+1×2+1)/1 = 13，即13×13×384;
   激活函数：ReLU，即C3输出为13×13×384（此处未将输出分到两个GPU中，若按照论文将分成两组，每组为13×13×192）
4. 卷积层C4
   C4的基本结构为：卷积–>ReLU。注意一点：此层也没有进行MaxPooling操作。
   卷积：输入13×13×384，384个3×3×384的卷积核， 扩充边缘padding = 1，步长stride = 1，因此其FeatureMap大小为(13-3+1×2+1)/1 = 13，即13×13×384;
   激活函数：ReLU，即C4输出为13×13×384（此处未将输出分到两个GPU中，若按照论文将分成两组，每组为13×13×192）；
5. 卷积层C5
   C5的基本结构为：卷积–>ReLU–>池化
   卷积：输入13×13×384，256个3×3×384的卷积核，扩充边缘padding = 1，步长stride = 1，因此其FeatureMap大小为(13-3+1×2+1)/1 = 13，即13×13×256;
   激活函数：ReLU；
   池化：池化核大小3 × 3， 扩充边缘padding = 0，步长stride = 2，因此其FeatureMap输出大小为(13-3+0×2+2)/2=6, 即C5输出为6×6×256（此处未将输出分到两个GPU中，若按照论文将分成两组，每组为6×6×128）；
6. 全连接层FC6
   FC6的基本结构为：全连接–>>ReLU–>Dropout
   全连接：此层的全连接实际上是通过卷积进行的，输入6×6×256，4096个6×6×256的卷积核，扩充边缘padding = 0, 步长stride = 1, 因此其FeatureMap大小为(6-6+0×2+1)/1 = 1，即1×1×4096;
   激活函数：ReLU；
   Dropout：全连接层中去掉了一些神经节点，达到防止过拟合，FC6输出为1×1×4096；
7. 全连接层FC7
   FC7的基本结构为：全连接–>>ReLU–>Dropout
   全连接：此层的全连接，输入1×1×4096;
   激活函数：ReLU；
   Dropout：全连接层中去掉了一些神经节点，达到防止过拟合，FC7输出为1×1×4096；
8. 全连接层FC8
   FC8的基本结构为：全连接–>>softmax
   全连接：此层的全连接，输入1×1×4096;
   softmax：softmax为1000，FC8输出为1×1×1000；

模型设计

class AlexNet(nn.Module):def __init__(self):super(AlexNet,self).__init__()#卷积层self.conv = nn.Sequential(#C1nn.Conv2d(in_channels=1,out_channels=96,kernel_size=11,padding=0,stride=4),nn.ReLU(),nn.MaxPool2d(kernel_size=3,stride=2),#C2nn.Conv2d(in_channels=96,out_channels=256,kernel_size=5,padding=2,stride=1),nn.ReLU(),nn.MaxPool2d(kernel_size=3,stride=2),#C3nn.Conv2d(in_channels=256,out_channels=384,kernel_size=3,padding=1,stride=1),nn.ReLU(),nn.MaxPool2d(kernel_size=3,stride=2),#C4nn.Conv2d(in_channels=384,out_channels=384,kernel_size=3,padding=1,stride=1),nn.ReLU(),#C5nn.Conv2d(in_channels=384,out_channels=256,kernel_size=3,padding=1,stride=1),nn.ReLU(),nn.MaxPool2d(kernel_size=3,stride=2),nn.Flatten(),#拉直层)#全连接层self.fc=nn.Sequential(#FC6nn.Linear(256*5*5,4096),nn.ReLU(),nn.Dropout(0.5),#FC7nn.Linear(4096,4096),nn.ReLU(),nn.Dropout(0.5),nn.Linear(4096,10),)def forward(self,img):feature=self.conv(img)output=self.fc(feature)return outputdef layers(self):return [self.conv, self.fc]

使用模型进行Fashion-MNIST分类

数据集

def get_dataloader_workers():  #@save"""使用4个进程来读取数据"""return 4def load_data_fashion_mnist(batch_size, resize=None):  #@save"""下载Fashion-MNIST数据集，然后将其加载到内存中"""trans = [transforms.ToTensor()]if resize:trans.insert(0, transforms.Resize(resize))trans = transforms.Compose(trans)mnist_train = torchvision.datasets.FashionMNIST(root="../data", train=True, transform=trans, download=True)mnist_test = torchvision.datasets.FashionMNIST(root="../data", train=False, transform=trans, download=True)return (data.DataLoader(mnist_train, batch_size, shuffle=True,num_workers=get_dataloader_workers()),data.DataLoader(mnist_test, batch_size, shuffle=False,num_workers=get_dataloader_workers()))

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

#超参数，优化器和损失函数
batch_size = 128
train_iter, test_iter = load_data_fashion_mnist(batch_size, resize=224)
lr, num_epochs = 0.01, 10
optimizer = torch.optim.SGD(net.parameters(), lr=lr)
loss = nn.CrossEntropyLoss()

训练

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 = 0total_loss = 0.0#总损失total_correct = 0#总正确数total_examples = 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()total_loss += l.item()total_correct += (y_hat.argmax(dim=1) == y).sum().item()total_examples += y.size(0)train_step+=1if(train_step%50==0):#每训练一百组输出一次损失print("第{}轮的第{}次训练的loss:{}".format((epoch+1),train_step,l.item()))train(net,train_iter,test_iter,num_epochs,lr,device)

测试

from d2l import torch as d2l
def predict(net, test_iter, n=6):  #@savefor X, y in test_iter:X, y = X.to('cuda'), y.to('cuda')breaktrues = d2l.get_fashion_mnist_labels(y)preds = d2l.get_fashion_mnist_labels(net(X).argmax(axis=1))titles = [true +'\n' + pred for true, pred in zip(trues, preds)]d2l.show_images(X[0:n].cpu().reshape((n, 224, 224)), 1, n, titles=titles[0:n])
predict(net, test_iter)

结果