example-notebook/Tutorial_04_1 Convolutional network for MNIST(1).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 搭建一个简单的 CNN 实现 MNIST分类\n",
    "前面我们已经使用 tensorflow 实现了全链接网络进行 MNIST 手写字符的分类。现在我们要搭建一个简单的卷积神经网络来进行分类，在学习本教程之前，你应该掌握 CNN 的原理，如果你还没有理解的话，建议先学习一下： [CS231n: Convolutional Neural Networks (CNNs / ConvNets)](http://cs231n.github.io/convolutional-networks/)\n",
    "\n",
    "需要注意的一点是 padding 的方式，在 padding 中有 \"valid\" 和 \"same\" 两种方式，可以参考[tensorflow conv2d的padding解释以及参数解释](https://blog.csdn.net/lujiandong1/article/details/53728053)：\n",
    "- valid: 在滑动窗口的时候，如果最后剩下的部分不够窗口大小了，直接丢弃最后的部分。\n",
    "- same: 在图片周围填充 0，填充方式如下。\n",
    "\n",
    "![padding意图](https://img-blog.csdn.net/20161218155916268?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvbHVqaWFuZG9uZzE=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)\n",
    "图片来自：https://blog.csdn.net/lujiandong1/article/details/53728053\n",
    "\n",
    "关于 \"same\" 方式的padding计算，可以参考官方文档：https://www.tensorflow.org/api_guides/python/nn#convolution\n",
    "\n",
    "计算如下，取一个维度进行分析，比如取高度 n \n",
    "\n",
    "$$n_o = \\left \\lceil{\\frac{n_i}{s}}\\right \\rceil$$\n",
    "\n",
    "其中，$n_i$ 表示输入的高度，$s$ 表示滑动步长 stride， $n_o$ 表示输出的高度。可以看到，**使用 `same` 方式，输出维度和窗口大小是没有关系的。**\n",
    "\n",
    "那么，需要 padding 的个数为 :\n",
    "$$n_{padding} = (n_o- 1)*s + f - n_i$$\n",
    "\n",
    "其中， $f$ 为卷积核的高度。\n",
    "\n",
    "得到需要 padding 的数量以后，一般都是在两端均匀padding，那么在上方 padding 的数量为：\n",
    "$$n_{toppad} = \\lfloor{n_{padding}/2}\\rfloor$$\n",
    "\n",
    "则在下方padding的数量为：\n",
    "$$n_{uppad} = n_{padding} - n_{toppad}$$\n",
    "\n",
    "为了初学者能够更好地理解，下面都采用最暴力的方式来写。实际上卷积层，全链接层之类的，我们都会定义一个函数来实现。在下一个例子中，我们再写一个优雅一点的 CNN 网络。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings('ignore')  # 不打印 warning \n",
    "\n",
    "import tensorflow as tf\n",
    "\n",
    "# 设置GPU按需增长\n",
    "config = tf.ConfigProto()\n",
    "config.gpu_options.allow_growth = True\n",
    "sess = tf.Session(config=config)\n",
    "\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.导入数据，用 tensorflow 导入"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /usr/local/lib/python3.5/dist-packages/tensorflow/contrib/learn/python/learn/datasets/base.py:198: retry (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use the retry module or similar alternatives.\n",
      "WARNING:tensorflow:From <ipython-input-2-5aa8f2eb5f17>:3: read_data_sets (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "WARNING:tensorflow:From /usr/local/lib/python3.5/dist-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:260: maybe_download (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please write your own downloading logic.\n",
      "WARNING:tensorflow:From /usr/local/lib/python3.5/dist-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:262: extract_images (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting ../data/MNIST_data/train-images-idx3-ubyte.gz\n",
      "WARNING:tensorflow:From /usr/local/lib/python3.5/dist-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:267: extract_labels (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting ../data/MNIST_data/train-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From /usr/local/lib/python3.5/dist-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:110: dense_to_one_hot (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.one_hot on tensors.\n",
      "Extracting ../data/MNIST_data/t10k-images-idx3-ubyte.gz\n",
      "Extracting ../data/MNIST_data/t10k-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From /usr/local/lib/python3.5/dist-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:290: DataSet.__init__ (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "(10000, 10)\n",
      "(55000, 10)\n"
     ]
    }
   ],
   "source": [
    "# 用tensorflow 导入数据\n",
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "mnist = input_data.read_data_sets('../data/MNIST_data', one_hot=True) \n",
    "# 看看咱们样本的数量\n",
    "print(mnist.test.labels.shape)\n",
    "print(mnist.train.labels.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. 构建网络"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def weight_variable(shape):\n",
    "    # 用正态分布来初始化权值\n",
    "    initial = tf.truncated_normal(shape, stddev=0.1)\n",
    "    return tf.Variable(initial)\n",
    "\n",
    "def bias_variable(shape):\n",
    "    # 本例中用relu激活函数，所以用一个很小的正偏置较好\n",
    "    initial = tf.constant(0.1, shape=shape)\n",
    "    return tf.Variable(initial)\n",
    "\n",
    "# 定义卷积层\n",
    "def conv2d(x, W):\n",
    "    # 默认 strides[0]=strides[3]=1, strides[1]为x方向步长，strides[2]为y方向步长\n",
    "    return tf.nn.conv2d(x, W, strides=[1,1,1,1], padding='SAME')\n",
    "\n",
    "# pooling 层\n",
    "def max_pool_2x2(x):\n",
    "    return tf.nn.max_pool(x, ksize=[1,2,2,1], strides=[1,2,2,1], padding='SAME')\n",
    "\n",
    "\n",
    "X_input = tf.placeholder(tf.float32, [None, 784])\n",
    "y_input = tf.placeholder(tf.float32, [None, 10])\n",
    "\n",
    "# 把X转为卷积所需要的形式\n",
    "X = tf.reshape(X_input, [-1, 28, 28, 1])\n",
    "# 第一层卷积：5×5×1卷积核32个 [5，5，1，32]\n",
    "W_conv1 = weight_variable([5,5,1,32])\n",
    "b_conv1 = bias_variable([32])\n",
    "h_conv1 = tf.nn.relu(conv2d(X, W_conv1) + b_conv1)\n",
    "\n",
    "# 第一个pooling 层\n",
    "h_pool1 = max_pool_2x2(h_conv1)\n",
    "\n",
    "# 第二层卷积：5×5×32卷积核64个 [5，5，32，64]\n",
    "W_conv2 = weight_variable([5,5,32,64])\n",
    "b_conv2 = bias_variable([64])\n",
    "h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)\n",
    "\n",
    "# 第二个pooling 层,输出[None, 7, 7, 64] ? \n",
    "h_pool2 = max_pool_2x2(h_conv2)\n",
    "\n",
    "# flatten\n",
    "h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])\n",
    "\n",
    "# fc1\n",
    "W_fc1 = weight_variable([7*7*64, 1024])\n",
    "b_fc1 = bias_variable([1024])\n",
    "h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)\n",
    "\n",
    "# dropout: 输出的维度和h_fc1一样，只是随机部分值被值为零\n",
    "keep_prob = tf.placeholder(tf.float32)\n",
    "h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)\n",
    "\n",
    "# 输出层\n",
    "W_fc2 = weight_variable([1024, 10])\n",
    "b_fc2 = bias_variable([10])\n",
    "y_pred = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "看看各层输出 tensor 的维度，在 notebook 中，最方便的就是你可以经常打印变量的状态来看看是不是和你想的是一致的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_input: Tensor(\"Placeholder:0\", shape=(?, 784), dtype=float32)\n",
      "X:       Tensor(\"Reshape:0\", shape=(?, 28, 28, 1), dtype=float32)\n",
      "y_input: Tensor(\"Placeholder_1:0\", shape=(?, 10), dtype=float32)\n",
      "h_conv1: Tensor(\"Relu:0\", shape=(?, 28, 28, 32), dtype=float32)\n",
      "h_pool1: Tensor(\"MaxPool:0\", shape=(?, 14, 14, 32), dtype=float32)\n",
      "h_conv2: Tensor(\"Relu_1:0\", shape=(?, 14, 14, 64), dtype=float32)\n",
      "h_pool2: Tensor(\"MaxPool_1:0\", shape=(?, 7, 7, 64), dtype=float32)\n",
      "h_fc1:   Tensor(\"Relu_2:0\", shape=(?, 1024), dtype=float32)\n",
      "y_pred:  Tensor(\"Softmax:0\", shape=(?, 10), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "print('X_input:', X_input)\n",
    "print('X:      ', X)\n",
    "print('y_input:', y_input)\n",
    "print('h_conv1:', h_conv1)\n",
    "print('h_pool1:', h_pool1)\n",
    "print('h_conv2:', h_conv2)\n",
    "print('h_pool2:', h_pool2)\n",
    "print('h_fc1:  ', h_fc1)\n",
    "print('y_pred: ', y_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.训练和评估"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b> 在测试的时候不使用 mini_batch， 那么测试的时候会占用较多的GPU（8817M），这在 notebook 交互式编程中是不推荐的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 500, train cost=32.956459, acc=0.890000; test cost=1617.352783, acc=0.955700\n",
      "step 1000, train cost=14.774936, acc=0.950000; test cost=1061.980713, acc=0.969400\n",
      "step 1500, train cost=13.221946, acc=0.950000; test cost=755.346191, acc=0.976700\n",
      "step 2000, train cost=11.899247, acc=0.960000; test cost=616.950256, acc=0.980600\n",
      "step 2500, train cost=13.984218, acc=0.980000; test cost=558.348022, acc=0.981400\n",
      "step 3000, train cost=14.924292, acc=0.970000; test cost=455.922638, acc=0.985600\n",
      "step 3500, train cost=2.872833, acc=0.980000; test cost=436.595032, acc=0.984600\n",
      "step 4000, train cost=8.945153, acc=0.980000; test cost=411.047852, acc=0.986000\n",
      "step 4500, train cost=6.661867, acc=0.980000; test cost=355.093719, acc=0.987400\n",
      "step 5000, train cost=1.669370, acc=1.000000; test cost=343.728882, acc=0.987600\n"
     ]
    }
   ],
   "source": [
    "cross_entropy = -tf.reduce_sum(y_input*tf.log(y_pred))\n",
    "train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)\n",
    "\n",
    "correct_prediction = tf.equal(tf.argmax(y_pred,1), tf.argmax(y_input,1))\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_prediction, \"float\"))\n",
    "sess.run(tf.global_variables_initializer())\n",
    "\n",
    "for i in range(5000):\n",
    "    X_batch, y_batch = mnist.train.next_batch(batch_size=100)\n",
    "    cost, acc,  _ = sess.run([cross_entropy, accuracy, train_step], feed_dict={X_input: X_batch, y_input: y_batch, keep_prob: 0.5})\n",
    "    if (i+1) % 500 == 0:\n",
    "        test_cost, test_acc = sess.run([cross_entropy, accuracy], feed_dict={X_input: mnist.test.images, y_input: mnist.test.labels, keep_prob: 1.0})\n",
    "        print(\"step {}, train cost={:.6f}, acc={:.6f}; test cost={:.6f}, acc={:.6f}\".format(i+1, cost, acc, test_cost, test_acc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b> 下面改成了 test 也用 mini_batch 的形式， 显存只用了 529M,所以还是很成功的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 500, train cost=24.613052, acc=0.920000; test cost=15.051726, acc=0.955600; pass 2.5465638637542725s\n",
      "step 1000, train cost=14.351367, acc=0.960000; test cost=9.154838, acc=0.973900; pass 2.396472930908203s\n",
      "step 1500, train cost=23.211666, acc=0.950000; test cost=7.125742, acc=0.978200; pass 2.392526149749756s\n",
      "step 2000, train cost=14.013665, acc=0.950000; test cost=5.870811, acc=0.982000; pass 2.3678934574127197s\n",
      "step 2500, train cost=3.635154, acc=1.000000; test cost=4.959528, acc=0.984300; pass 2.4310600757598877s\n",
      "step 3000, train cost=4.492582, acc=0.980000; test cost=3.975064, acc=0.986300; pass 2.397819757461548s\n",
      "step 3500, train cost=1.197423, acc=1.000000; test cost=3.901103, acc=0.986800; pass 2.602867364883423s\n",
      "step 4000, train cost=13.277801, acc=0.950000; test cost=3.582187, acc=0.988500; pass 2.360400915145874s\n",
      "step 4500, train cost=5.978199, acc=0.980000; test cost=3.084232, acc=0.989600; pass 2.3935186862945557s\n",
      "step 5000, train cost=1.932325, acc=0.990000; test cost=2.832213, acc=0.991000; pass 2.3541934490203857s\n"
     ]
    }
   ],
   "source": [
    "cross_entropy = -tf.reduce_sum(y_input * tf.log(y_pred))\n",
    "train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)\n",
    "\n",
    "# 3.预测准确结果统计\n",
    "correct_prediction = tf.equal(tf.argmax(y_pred, 1), tf.argmax(y_input, 1))  \n",
    "accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\n",
    "\n",
    "# 定义了变量必须要初始化，或者下面形式\n",
    "sess.run(tf.global_variables_initializer())\n",
    "\n",
    "import time\n",
    "\n",
    "\n",
    "time0 = time.time()\n",
    "# 训练\n",
    "for i in range(5000):\n",
    "    X_batch, y_batch = mnist.train.next_batch(batch_size=100)\n",
    "    cost, acc,  _ = sess.run([cross_entropy, accuracy, train_step], feed_dict={X_input: X_batch, y_input: y_batch, keep_prob: 0.5})\n",
    "    if (i+1) % 500 == 0:\n",
    "        # 分 100 个batch 迭代\n",
    "        test_acc = 0.0\n",
    "        test_cost = 0.0\n",
    "        N = 100\n",
    "        for j in range(N):\n",
    "            X_batch, y_batch = mnist.test.next_batch(batch_size=100)\n",
    "            _cost, _acc = sess.run([cross_entropy, accuracy], feed_dict={X_input: X_batch, y_input: y_batch, keep_prob: 1.0})\n",
    "            test_acc += _acc\n",
    "            test_cost += _cost\n",
    "        print(\"step {}, train cost={:.6f}, acc={:.6f}; test cost={:.6f}, acc={:.6f}; pass {}s\".format(i+1, cost, acc, test_cost/N, test_acc/N, time.time() - time0))\n",
    "        time0 = time.time()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. 查看网络中间结果"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b> 在学习 CNN 的过程中，老是看到他们用图片的形式展示了中间层卷积的输出。好吧，这下我必须得自己实现以下看看呀！！！</b>\n",
    "<br/> 关于 python 图片操作主要有 matplotlib 和 PIL 两个库（refer to: http://www.cnblogs.com/yinxiangnan-charles/p/5928689.html）。\n",
    "<br/>我们使用 matplotlib 来完成这个任务。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1 图像操作基础"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 0. 0. 0. 0. 0. 1. 0. 0. 0.]\n",
      "img_data shape = (784,)\n"
     ]
    }
   ],
   "source": [
    "# 我们先来看看数据是什么样的\n",
    "img1 = mnist.train.images[0]\n",
    "label1 = mnist.train.labels[0]\n",
    "print(label1)\n",
    "print('img_data shape =', img1.shape)  # 我们需要把它转为 28 * 28 的矩阵\n",
    "img1 = img1.reshape([28, 28])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "# import matplotlib.image as mpimg  # 用于读取图片，这里用不上\n",
    "\n",
    "plt.imshow(img1)\n",
    "plt.axis('off') # 不显示坐标轴\n",
    "plt.show()   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "好吧，是显示了图片，但是结果是热度图像。我们想显示的是灰度图像。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 我们可以通过设置 cmap 参数来显示灰度图\n",
    "plt.imshow(img1, cmap='gray') # 'hot' 是热度图\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2 显示网络中间结果"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "好了，有了前面的图像操作基础，我们就该试试吧！！！"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 28, 28, 32)\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "# 首先应该把 img1 转为正确的shape (None, 784)\n",
    "X_img = img1.reshape([-1, 784])\n",
    "y_img = mnist.train.labels[1].reshape([-1, 10])\n",
    "# 我们要看 Conv1 的结果，即 h_conv1\n",
    "result = sess.run([h_conv1], feed_dict={X_input: X_img, keep_prob:1.0})[0]\n",
    "print(result.shape)\n",
    "print(type(result))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "好的，我们成功的计算得到了 h_conv1，那么赶紧 imshow() 看看吧！！！"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 32 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for i in range(32):\n",
    "    show_img = result[:,:,:,i]\n",
    "    show_img = show_img.reshape([28, 28])\n",
    "    plt.subplot(4, 8, i + 1)\n",
    "    plt.imshow(show_img, cmap='gray')\n",
    "    plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "哈哈，成功啦！从上面的结果中，我们可以看到不同的滤波器（卷积核）学习到了不同的特征。比如有的滤波器学习到了边缘信息，有的则学习到了骨干的信息。感觉好有趣，不由自主的想对另一个数字看看。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0. 0. 0. 0. 1. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 1. 0.]\n",
      " [0. 1. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 1. 0. 0.]\n",
      " [0. 0. 0. 1. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]\n",
      " [0. 0. 0. 0. 0. 0. 1. 0. 0. 0.]\n",
      " [0. 0. 0. 1. 0. 0. 0. 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "print(mnist.train.labels[:10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 32 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 首先应该把 img1 转为正确的shape (None, 784)\n",
    "X_img = mnist.train.images[5].reshape([-1, 784])\n",
    "result = sess.run([h_conv1], feed_dict={X_input: X_img, keep_prob:1.0})[0]\n",
    "\n",
    "for i in range(32):\n",
    "    show_img = result[:,:,:,i]\n",
    "    show_img = show_img.reshape([28, 28])\n",
    "    plt.subplot(4, 8, i + 1)\n",
    "    plt.imshow(show_img, cmap='gray')\n",
    "    plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 总结\n",
    "这个教程我们搭建了一个非常简单的CNN进行 MNIST 手写数字的识别。上面的各个层都是一行一行的非常“脚本”式的写法，在初学者来说，一行一行地运行能够更好地理解每行代码的意思。\n",
    "\n",
    "实际上，就一个简单的图像分类任务，其网络结构可能非常复杂。比如 AlexNet 就有好几个 conv layer/ pooling layer/ fully connected layer 等等，更别说 GoogLeNet 和 ResNet。对于这些庞大的网络，我们不可能再一行一行地去写，而是要把 conv layer/ pooling layer/ fully connected layer / BN layer 分别封装成函数。同时，要好好地利用前面我们学到的 tf.variable_scope() 和 tf.get_variable() 来优雅地定义网络结构。\n",
    "\n",
    "此外，网络的初始化也会影响网络的性能，还有在模型训练的过程中，怎么组织数据的输入，怎么选择 batch_size 等都是我们要考虑的。而这些内容需要自己解决具体的问题慢慢总结出来。"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}