【模型复现】-alexnet，nn.Sequential顺序结构构建网络

深度卷积神经网络（AlexNet）

• 在LeNet提出后的将近20年里，神经网络一度被其他机器学习方法超越，如支持向量机。虽然LeNet可以在早期的小数据集上取得好的成绩，但是在更大的真实数据集上的表现并不尽如人意。一方面，神经网络计算复杂。虽然20世纪90年代也有过一些针对神经网络的加速硬件，但并没有像之后GPU那样大量普及。因此，训练一个多通道、多层和有大量参数的卷积神经网络在当年很难完成。另一方面，当年研究者还没有大量深入研究参数初始化和非凸优化算法等诸多领域，导致复杂的神经网络的训练通常较困难。

• 神经网络可以直接基于图像的原始像素进行分类。这种称为端到端（end-to-end）的方法节省了很多中间步骤。然而，在很长一段时间里更流行的是研究者通过勤劳与智慧所设计并生成的手工特征。这类图像分类研究的主要流程是：

  • 获取图像数据集；
  • 使用已有的特征提取函数生成图像的特征；
  • 使用机器学习模型对图像的特征分类。

• 当时认为的机器学习部分仅限最后这一步。如果那时候跟机器学习研究者交谈，他们会认为机器学习既重要又优美。优雅的定理证明了许多分类器的性质。机器学习领域生机勃勃、严谨而且极其有用。然而，如果跟计算机视觉研究者交谈，则是另外一幅景象。他们会告诉你图像识别里“不可告人”的现实是：计算机视觉流程中真正重要的是数据和特征。也就是说，使用较干净的数据集和较有效的特征甚至比机器学习模型的选择对图像分类结果的影响更大。

AlexNet【读点论文】把深度学习引入大众视野 alexnet_羞儿的博客-CSDN博客

• 2012年，AlexNet横空出世。这个模型的名字来源于论文第一作者的姓名Alex Krizhevsky 。AlexNet使用了8层卷积神经网络，并以很大的优势赢得了ImageNet 2012图像识别挑战赛。它首次证明了学习到的特征可以超越手工设计的特征，从而一举打破计算机视觉研究的前状。

• 第一，与相对较小的LeNet相比，AlexNet包含8层变换，其中有5层卷积和2层全连接隐藏层，以及1个全连接输出层。下面我们来详细描述这些层的设计。

• AlexNet第一层中的卷积窗口形状是$11\times 11$。因为ImageNet中绝大多数图像的高和宽均比MNIST图像的高和宽大10倍以上，ImageNet图像的物体占用更多的像素，所以需要更大的卷积窗口来捕获物体。第二层中的卷积窗口形状减小到$5\times 5$，之后全采用$3\times 3$。此外，第一、第二和第五个卷积层之后都使用了窗口形状为$3\times 3$、步幅为2的最大池化层。而且，AlexNet使用的卷积通道数也大于LeNet中的卷积通道数数十倍。

• 紧接着最后一个卷积层的是两个输出个数为4096的全连接层。这两个巨大的全连接层带来将近1 GB的模型参数。由于早期显存的限制，最早的AlexNet使用双数据流的设计使一个GPU只需要处理一半模型。幸运的是，显存在过去几年得到了长足的发展，因此通常我们不再需要这样的特别设计了。

• 第二，AlexNet将sigmoid激活函数改成了更加简单的ReLU激活函数。一方面，ReLU激活函数的计算更简单，例如它并没有sigmoid激活函数中的求幂运算。另一方面，ReLU激活函数在不同的参数初始化方法下使模型更容易训练。这是由于当sigmoid激活函数输出极接近0或1时，这些区域的梯度几乎为0，从而造成反向传播无法继续更新部分模型参数；而ReLU激活函数在正区间的梯度恒为1。因此，若模型参数初始化不当，sigmoid函数可能在正区间得到几乎为0的梯度，从而令模型无法得到有效训练。

• 第三，AlexNet通过丢弃法pytorch-模型训练中过拟合和欠拟合问题。从模型复杂度和数据集大小排查问题_羞儿的博客-CSDN博客来控制全连接层的模型复杂度。而LeNet并没有使用丢弃法。

• 第四，AlexNet引入了大量的图像增强，如翻转、裁剪和颜色变化，从而进一步扩大数据集来缓解过拟合。

• 

• 卷积层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）；

• 卷积层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）；

• 卷积层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）；

• 卷积层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）；

• 卷积层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）；

• 全连接层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；

• 全连接层FC7

  • FC7的基本结构为：全连接–>>ReLU–>Dropout

    • 全连接：此层的全连接，输入1×1×4096;

    • 激活函数：ReLU；

    • Dropout：全连接层中去掉了一些神经节点，达到防止过拟合，FC7输出为1×1×4096；

• 全连接层FC8

  • FC8的基本结构为：全连接–>>softmax

    • 全连接：此层的全连接，输入1×1×4096;

    • softmax：softmax为1000，FC8输出为1×1×1000；（原论文做的是imagenet论文任务是1000分类，本文做的是fashion-mnist任务10分类就好）

• import time
  import torch
  from torch import nn, optim
  import torchvision
  device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
  class AlexNet(nn.Module):
      def __init__(self):
          super(AlexNet, self).__init__()
          self.conv = nn.Sequential(
              nn.Conv2d(1, 96, 11, 4), # in_channels, out_channels, kernel_size, stride, padding
              nn.ReLU(),
              nn.MaxPool2d(3, 2), # kernel_size, stride
              # 减小卷积窗口，使用填充为2来使得输入与输出的高和宽一致，且增大输出通道数
              nn.Conv2d(96, 256, 5, 1, 2),
              nn.ReLU(),
              nn.MaxPool2d(3, 2),
              # 连续3个卷积层，且使用更小的卷积窗口。除了最后的卷积层外，进一步增大了输出通道数。
              # 前两个卷积层后不使用池化层来减小输入的高和宽
              nn.Conv2d(256, 384, 3, 1, 1),
              nn.ReLU(),
              nn.Conv2d(384, 384, 3, 1, 1),
              nn.ReLU(),
              nn.Conv2d(384, 256, 3, 1, 1),
              nn.ReLU(),
              nn.MaxPool2d(3, 2)
          )
           # 这里全连接层的输出个数比LeNet中的大数倍。使用丢弃层来缓解过拟合
          self.fc = nn.Sequential(
              nn.Linear(256*5*5, 4096),
              nn.ReLU(),
              nn.Dropout(0.5),
              nn.Linear(4096, 4096),
              nn.ReLU(),
              nn.Dropout(0.5),
              # 输出层。由于这里使用Fashion-MNIST，所以用类别数为10，而非论文中的1000
              nn.Linear(4096, 10),
          )
      def forward(self, img):
          feature = self.conv(img)
          output = self.fc(feature.view(img.shape[0], -1))# 先转换张量形状
          return output
  net = AlexNet()  # 实例化
  print(net) 
  

• AlexNet(
    (conv): Sequential(
      (0): Conv2d(1, 96, kernel_size=(11, 11), stride=(4, 4))
      (1): ReLU()
      (2): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
      (3): Conv2d(96, 256, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
      (4): ReLU()
      (5): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
      (6): Conv2d(256, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (7): ReLU()
      (8): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (9): ReLU()
      (10): Conv2d(384, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (11): ReLU()
      (12): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
    )
    (fc): Sequential(
      (0): Linear(in_features=6400, out_features=4096, bias=True)
      (1): ReLU()
      (2): Dropout(p=0.5, inplace=False)
      (3): Linear(in_features=4096, out_features=4096, bias=True)
      (4): ReLU()
      (5): Dropout(p=0.5, inplace=False)
      (6): Linear(in_features=4096, out_features=10, bias=True)
    )
  )
  

读取数据

• 虽然论文中AlexNet使用ImageNet数据集，但因为ImageNet数据集训练时间较长，我们仍用前面的Fashion-MNIST数据集来演示AlexNet。读取数据的时候我们额外做了一步将图像高和宽扩大到AlexNet使用的图像高和宽224。这个可以通过torchvision.transforms.Resize实例来实现。也就是说，我们在ToTensor实例前使用Resize实例，然后使用Compose实例来将这两个变换串联以方便调用。

• def load_data_fashion_mnist(batch_size, resize=None, root='~/Datasets/FashionMNIST'):
      """Download the fashion mnist dataset and then load into memory."""
      trans = []
      if resize:
          trans.append(torchvision.transforms.Resize(size=resize))
      trans.append(torchvision.transforms.ToTensor())
      transform = torchvision.transforms.Compose(trans)
      mnist_train = torchvision.datasets.FashionMNIST(root=root, train=True, download=True, transform=transform)
      mnist_test = torchvision.datasets.FashionMNIST(root=root, train=False, download=True, transform=transform)
      train_iter = torch.utils.data.DataLoader(mnist_train, batch_size=batch_size, shuffle=True, num_workers=0)
      test_iter = torch.utils.data.DataLoader(mnist_test, batch_size=batch_size, shuffle=False, num_workers=0)
      return train_iter, test_iter
  batch_size = 256
  # 如出现“out of memory”的报错信息，可减小batch_size或resize
  train_iter, test_iter = load_data_fashion_mnist(batch_size, resize=224)
  print(train_iter, test_iter)
  

• <torch.utils.data.dataloader.DataLoader object at 0x0000027C458F4BB0> <torch.utils.data.dataloader.DataLoader object at 0x0000027C45976490>
  

训练

• 这时候我们可以开始训练AlexNet了。相对于LeNet，由于图片尺寸变大了而且模型变大了，所以需要更大的显存，也需要更长的训练时间了。

• def evaluate_accuracy(data_iter, net, device=None):
      if device is None and isinstance(net, torch.nn.Module):
          # 如果没指定device就使用net的device
          device = list(net.parameters())[0].device
      acc_sum, n = 0.0, 0
      with torch.no_grad():
          for X, y in data_iter:
              if isinstance(net, torch.nn.Module):
                  net.eval() # 评估模式, 这会关闭dropout
                  acc_sum += (net(X.to(device)).argmax(dim=1) == y.to(device)).float().sum().cpu().item()
                  net.train() # 改回训练模式
              else: # 自定义的模型, 3.13节之后不会用到, 不考虑GPU
                  if('is_training' in net.__code__.co_varnames): # 如果有is_training这个参数
                      # 将is_training设置成False
                      acc_sum += (net(X, is_training=False).argmax(dim=1) == y).float().sum().item()
                  else:
                      acc_sum += (net(X).argmax(dim=1) == y).float().sum().item()
              n += y.shape[0]
      return acc_sum / n
  def train_Fashion(net, train_iter, test_iter, batch_size, optimizer, device, num_epochs):
      net = net.to(device)
      print("training on ", device)
      loss = torch.nn.CrossEntropyLoss()
      for epoch in range(num_epochs):
          train_l_sum, train_acc_sum, n, batch_count, start = 0.0, 0.0, 0, 0, time.time()
          for X, y in train_iter:
              X = X.to(device)
              y = y.to(device)
              y_hat = net(X)
              l = loss(y_hat, y)
              optimizer.zero_grad()
              l.backward()
              optimizer.step()
              train_l_sum += l.cpu().item()
              train_acc_sum += (y_hat.argmax(dim=1) == y).sum().cpu().item()
              n += y.shape[0]
              batch_count += 1
          test_acc = evaluate_accuracy(test_iter, net)
          print('epoch %d, loss %.4f, train acc %.3f, test acc %.3f, time %.1f sec'
                % (epoch + 1, train_l_sum / batch_count, train_acc_sum / n, test_acc, time.time() - start))
  lr, num_epochs = 0.001, 10
  optimizer = torch.optim.Adam(net.parameters(), lr=lr)
  train_Fashion(net, train_iter, test_iter, batch_size, optimizer, device, num_epochs)
  

• training on  cpu
  epoch 1, loss 0.6371, train acc 0.757, test acc 0.856, time 1915.4 sec
  epoch 2, loss 0.3452, train acc 0.872, test acc 0.875, time 1999.4 sec
  epoch 3, loss 0.2973, train acc 0.891, test acc 0.898, time 2058.1 sec
  epoch 4, loss 0.2600, train acc 0.903, test acc 0.896, time 2060.1 sec
  epoch 5, loss 0.2442, train acc 0.909, test acc 0.904, time 2054.4 sec
  epoch 6, loss 0.2276, train acc 0.916, test acc 0.904, time 2060.6 sec
  epoch 7, loss 0.2175, train acc 0.919, test acc 0.909, time 2052.6 sec
  epoch 8, loss 0.2015, train acc 0.925, test acc 0.914, time 2060.6 sec
  epoch 9, loss 0.1899, train acc 0.929, test acc 0.918, time 2056.9 sec
  epoch 10, loss 0.1847, train acc 0.931, test acc 0.917, time 2062.2 sec
  

• AlexNet跟LeNet结构类似，但使用了更多的卷积层和更大的参数空间来拟合大规模数据集ImageNet。它是浅层神经网络和深度神经网络的分界线。虽然看上去AlexNet的实现比LeNet的实现也就多了几行代码而已，但这个观念上的转变和真正优秀实验结果的产生令学术界付出了很多年。