Tensorflow，Alexnet和MNIST数据 识别手写的数字（入门，代码，解析）

2012年，Hinton的学生Alex Krizhevsky提出了深度卷积神经网络模型AlexNet，它可以算是LeNet的一种更深更宽的版本。AlexNet以显著的优势赢得了竞争激烈的ILSVRC 2012比赛，top-5的错误率降低至了16.4%，远远领先第二名的26.2%的成绩。AlexNet的出现意义非常重大，它证明了CNN在复杂模型下的有效性，而且使用GPU使得训练在可接受的时间范围内得到结果，让CNN和GPU都大火了一把。AlexNet可以说是神经网络在低谷期后的第一次发声，确立了深度学习（深度卷积网络）在计算机视觉的统治地位，同时也推动了深度学习在语音识别、自然语言处理、强化学习等领域的拓展。

AlexNet每层的超参数如图所示：

其中， 
Input：图片尺寸224*224 
Conv1：卷积核11*11，步长4，96个filter（卷积核尺寸较大） 
ReLU 
LRN1 
Max pooling1：3*3，步长2 
Conv2：卷积核5*5，步长1，256个filter 
ReLU 
LRN2 
Max pooling2：3*3，步长2 
Conv3：卷积核3*3，步长1，384个filter 
ReLU 
Conv4：卷积核3*3，步长1，384个filter 
ReLU 
Conv5：卷积核3*3，步长1，256个filter 
ReLU 
Max pooling3：3*3，步长2 
FC1：4096 
ReLU 
FC2：4096 
ReLU 
FC3（Output）：1000
 

在这里要注意一下原来Alexnet输入的图片大小为:224*224*3，MNIST数据输入图像是28*28*1，需要对原网络的卷积核进行对应的更改。

参看的文章

① https://blog.csdn.net/Greyhatjzy/article/details/70197008 代码①

② https://blog.csdn.net/lwplwf/article/details/72870378 代码②

③ https://blog.csdn.net/taoyanqi8932/article/details/71081390 原理介绍

一、两个代码的区别

①和②的主要区别是：

1.网络的不同：①中的1，2，5层网络有norm层和dropout层，②没有；②在6，7全链接层有dropout，①没有；

2.训练的方法不同：①中是在限制条件（step * batch_size < training_epochs）的依次取batch进行训练，run(optm)的次数是step* batch_size；②是先看训练集有几个patch，也就是total_batch，对每一个patch进行训练，这个算一个epoch，也就是run(optm)的次数是training_epochs*total_batch。

这两种训练方法的原理是一样的。

首先看看mnist.train.next_batch函数，作用效果是按数据顺序依次返回下一个batch,如果取了一些batch后发现剩余数据不到一个batch的数量，此函数会默认将数据打乱，用打乱数据的开头和剩余数据拼接成一个batch。

def next_batch(self, batch_size, fake_data=False, shuffle=True):
    """Return the next `batch_size` examples from this data set."""
    if fake_data: #是否使用假数据
      fake_image = [1] * 784
      if self.one_hot:
        fake_label = [1] + [0] * 9
      else:
        fake_label = 0
      return [fake_image for _ in xrange(batch_size)], [
          fake_label for _ in xrange(batch_size)
      ]
    start = self._index_in_epoch#指针指向开头
    # Shuffle for the first epoch
    if self._epochs_completed == 0 and start == 0 and shuffle:#打乱数据
      perm0 = numpy.arange(self._num_examples)
      numpy.random.shuffle(perm0)
      self._images = self.images[perm0]
      self._labels = self.labels[perm0]
    # Go to the next epoch#如果指针指到快结尾了，剩余部分不到一个batch量
    if start + batch_size > self._num_examples:
      # Finished epoch
      self._epochs_completed += 1 #表示已经完成一次数据的输出
      # Get the rest examples in this epoch
      rest_num_examples = self._num_examples - start
      images_rest_part = self._images[start:self._num_examples]
      labels_rest_part = self._labels[start:self._num_examples]
      # Shuffle the data
      if shuffle:
        perm = numpy.arange(self._num_examples)
        numpy.random.shuffle(perm)
        self._images = self.images[perm]
        self._labels = self.labels[perm]
      # Start next epoch
      start = 0
      self._index_in_epoch = batch_size - rest_num_examples
      end = self._index_in_epoch
      images_new_part = self._images[start:end]
      labels_new_part = self._labels[start:end]
      return numpy.concatenate(  #将前一个数据的尾和shuttle后数据的头连接到一起
          (images_rest_part, images_new_part), axis=0), numpy.concatenate(
              (labels_rest_part, labels_new_part), axis=0)
    else: #正常按照顺序取batch
      self._index_in_epoch += batch_size
      end = self._index_in_epoch
      return self._images[start:end], self._labels[start:end]

所以②训练相对于①训练有点多此一举，不过透露了训练的实质。

 

二、代码的运行：

代码①可以迅速的实现，但是代码②会发现内存不足，原因是代码②有对测试数据的测试，所以删掉测试数据那句代码就可以快乐的跑啦（需要更改的地方如下）

if epoch % display_step == 0:
        train_accuracy = sess.run(accuracy, feed_dict={x: batch_xs, y: batch_ys, keep_prob: 1.0})
        #test_accuracy = sess.run(accuracy, feed_dict={x: mnist.test.images, y: mnist.test.labels, keep_prob:1.0})
        print("Epoch: %03d/%03d cost: %.9f TRAIN ACCURACY: %.3f " % (epoch, training_epochs, avg_cost, train_accuracy))

其次代码②为什么比代码①慢呢？

因为代码①每run一次(optimizer)都会输出一次结果，而代码②是run了total_batch次(optimizer)才输出一次结果。所以给人的感觉比较慢咯~~