{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.simplefilter(action='ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from time import time\n",
    "\n",
    "import tensorflow as tf\n",
    "tf.logging.set_verbosity(tf.logging.ERROR)  # 过滤掉 Tensorflow 的 Warning 信息\n",
    "\n",
    "import tensorflow.examples.tutorials.mnist.input_data as input_data\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. 数据预处理"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting data/train-images-idx3-ubyte.gz\n",
      "Extracting data/train-labels-idx1-ubyte.gz\n",
      "Extracting data/t10k-images-idx3-ubyte.gz\n",
      "Extracting data/t10k-labels-idx1-ubyte.gz\n"
     ]
    }
   ],
   "source": [
    "mnist = input_data.read_data_sets('data/', one_hot=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train images shape: (55000, 784)\n",
      "train labels shape: (55000, 10)\n",
      "\n",
      "validation images shape: (5000, 784)\n",
      "validation labels shape: (5000, 10)\n",
      "\n",
      "test images shape: (10000, 784)\n",
      "test labels shape: (10000, 10)\n"
     ]
    }
   ],
   "source": [
    "print('train images shape:', mnist.train.images.shape)\n",
    "print('train labels shape:', mnist.train.labels.shape)\n",
    "print()\n",
    "print('validation images shape:', mnist.validation.images.shape)\n",
    "print('validation labels shape:', mnist.validation.labels.shape)\n",
    "print()\n",
    "print('test images shape:', mnist.test.images.shape)\n",
    "print('test labels shape:', mnist.test.labels.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. 建立共享函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.1 定义 weight 函数, 用于建立权重张量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def weight(shape):\n",
    "    return tf.Variable(tf.truncated_normal(shape, stddev=0.1), name='W')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.2 定义 bias 函数, 用于建立偏差张量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bias(shape):\n",
    "    return tf.Variable(tf.constant(0.1, shape=shape), name='b')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.3 定义 conv2d 函数, 用于进行卷积运算"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def conv2d(x, W):\n",
    "    return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.4 定义 max_pool_2x2 函数, 用于建立池化层"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def max_pool_2x2(x):\n",
    "    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. 建立模型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.1 输入层"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope('Input_Layer'):\n",
    "    x = tf.placeholder('float', shape=[None, 784], name='x')\n",
    "    x_image = tf.reshape(x, [-1, 28, 28, 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.2 卷积层1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope('C1_Conv'):\n",
    "    W1 = weight([5, 5, 1, 16])\n",
    "    b1 = bias([16])\n",
    "    Conv1 = conv2d(x_image, W1) + b1\n",
    "    C1_Conv = tf.nn.relu(Conv1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope('C1_Pool'):\n",
    "    C1_Pool = max_pool_2x2(C1_Conv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.3 卷积层2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope('C2_Conv'):\n",
    "    W2 = weight([5, 5, 16, 36])\n",
    "    b2 = bias([36])\n",
    "    Conv2 = conv2d(C1_Pool, W2) + b2\n",
    "    C2_Conv = tf.nn.relu(Conv2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope('C2_Pool'):\n",
    "    C2_Pool = max_pool_2x2(C2_Conv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.4 全连接层"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope('D_Flat'):\n",
    "    D_Flat = tf.reshape(C2_Pool, [-1, 1764])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope('D_Hidden_Layer'):\n",
    "    W3 = weight([1764, 128])\n",
    "    b3 = bias([128])\n",
    "    D_Hidden = tf.nn.relu(tf.matmul(D_Flat, W3) + b3)\n",
    "    D_Hidden_Dropout = tf.nn.dropout(D_Hidden, keep_prob=0.8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.5 输出层"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope('Output_Layer'):\n",
    "    W4 = weight([128, 10])\n",
    "    b4 = bias([10])\n",
    "    y_predict = tf.nn.softmax(tf.matmul(D_Hidden_Dropout, W4) + b4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. 定义训练方式"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.1 建立训练数据 label 真实值的 placeholder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope('optimizer'):\n",
    "    # 定义损失函数\n",
    "    y_label = tf.placeholder('float', [None, 10], name='y_label')\n",
    "    \n",
    "    # 定义损失函数\n",
    "    loss_function = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=y_predict, labels=y_label))\n",
    "    \n",
    "    # 定义优化器\n",
    "    optimizer = tf.train.AdamOptimizer(learning_rate=0.0001).minimize(loss_function)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. 定义评估模型准确率的方式"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope('evaluate_model'):\n",
    "    correct_prediction = tf.equal(tf.argmax(y_label, axis=1), \n",
    "                                  tf.argmax(y_predict, axis=1))\n",
    "    accuracy = tf.reduce_mean(tf.cast(correct_prediction, 'float'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6. 开始训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_epochs = 15\n",
    "batch_size = 100\n",
    "total_batch = int(mnist.train.num_examples / batch_size)\n",
    "epoch_list = []\n",
    "loss_list = []\n",
    "acc_list = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train epoch: 01 loss: 1.667564631 acc: 0.8122\n",
      "train epoch: 02 loss: 1.628974557 acc: 0.8394\n",
      "train epoch: 03 loss: 1.615294456 acc: 0.8528\n",
      "train epoch: 04 loss: 1.520540953 acc: 0.9522\n",
      "train epoch: 05 loss: 1.505755424 acc: 0.961\n",
      "train epoch: 06 loss: 1.498941064 acc: 0.9678\n",
      "train epoch: 07 loss: 1.494952202 acc: 0.9696\n",
      "train epoch: 08 loss: 1.493835688 acc: 0.9722\n",
      "train epoch: 09 loss: 1.489154339 acc: 0.9734\n",
      "train epoch: 10 loss: 1.488664269 acc: 0.9754\n",
      "train epoch: 11 loss: 1.486197829 acc: 0.9776\n",
      "train epoch: 12 loss: 1.484781146 acc: 0.9784\n",
      "train epoch: 13 loss: 1.484792829 acc: 0.9784\n",
      "train epoch: 14 loss: 1.483059764 acc: 0.9798\n",
      "train epoch: 15 loss: 1.481593132 acc: 0.981\n",
      "\n",
      "train finished. takes 788.1317231655121 seconds\n"
     ]
    }
   ],
   "source": [
    "start_time = time()\n",
    "sess = tf.Session()\n",
    "sess.run(tf.global_variables_initializer())\n",
    "\n",
    "for epoch in range(train_epochs):\n",
    "    for i in range(total_batch):\n",
    "        x_batch, y_batch = mnist.train.next_batch(batch_size=batch_size)\n",
    "        sess.run(optimizer, feed_dict={x: x_batch, y_label: y_batch})\n",
    "    \n",
    "    loss, acc = sess.run([loss_function, accuracy], \n",
    "                         feed_dict={x: mnist.validation.images, y_label: mnist.validation.labels})\n",
    "    epoch_list.append(epoch+1)\n",
    "    loss_list.append(loss)\n",
    "    acc_list.append(acc)\n",
    "    print('train epoch:', '%02d' % (epoch + 1), 'loss:', '{:.9f}'.format(loss), 'acc:', acc)\n",
    "\n",
    "print()\n",
    "print('train finished. takes', time() - start_time, 'seconds')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7. 以图形显示训练过程"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_train_history(x_values, y_values, title):\n",
    "    plt.plot(x_values, y_values, label=title)\n",
    "    plt.xlabel('Epoch')\n",
    "    plt.ylabel(title)\n",
    "    plt.legend([title], loc='upper left')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_train_history(epoch_list, acc_list, 'acc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_train_history(epoch_list, loss_list, 'loss')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8. 评估模型准确率"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy: 0.9811\n"
     ]
    }
   ],
   "source": [
    "print('accuracy:', sess.run(accuracy, feed_dict={x: mnist.test.images, y_label: mnist.test.labels}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9. 进行预测"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 9.1 执行预测"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "prediction_result = sess.run(tf.argmax(y_predict, axis=1), feed_dict={x: mnist.test.images})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 9.2 预测结果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([7, 2, 1, 0, 4, 1, 4, 9, 5, 9])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prediction_result[:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 9.3 定义函数以显示10项预测结"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_images_labels_prediction(images, labels, predictions, idx, num=10):\n",
    "    \"\"\"\n",
    "    images: 数字图像数组\n",
    "    labels: 真实值数组\n",
    "    predictions: 预测结果数据\n",
    "    idx: 开始显示的数据index\n",
    "    num: 要显示的数据项数, 默认为10, 不超过25\n",
    "    \"\"\"\n",
    "    fig = plt.gcf()\n",
    "    fig.set_size_inches(12, 14)\n",
    "    if num > 25:\n",
    "        num = 25\n",
    "    for i in range(0, num):\n",
    "        ax = plt.subplot(5, 5, i+1)\n",
    "        ax.imshow(images[idx].reshape(28, 28), cmap='binary')\n",
    "        title = 'lable=' + str(np.argmax(labels[idx]))\n",
    "        if len(predictions) > 0:\n",
    "            title += ',predict=' + str(predictions[idx])\n",
    "        ax.set_title(title, fontsize=10)\n",
    "        ax.set_xticks([])\n",
    "        ax.set_yticks([])\n",
    "        idx += 1\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x1008 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_images_labels_prediction(mnist.test.images, mnist.test.labels, prediction_result, 0, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 10. 找出预测错误"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i=18 label=3 predict=8\n",
      "i=151 label=9 predict=8\n",
      "i=247 label=4 predict=6\n",
      "i=290 label=8 predict=4\n"
     ]
    }
   ],
   "source": [
    "for i in range(300):\n",
    "    label = np.argmax(mnist.test.labels[i])\n",
    "    predict = prediction_result[i]\n",
    "    if predict != label:\n",
    "        print('i=' + str(i), 'label=' + str(label), 'predict=' + str(predict))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_images_labels_predict_error(images, labels, prediction_result):\n",
    "    fig = plt.gcf()\n",
    "    fig.set_size_inches(12, 14)\n",
    "    num = 0\n",
    "    idx = 0\n",
    "    while num < 10:\n",
    "        label = np.argmax(mnist.test.labels[idx])\n",
    "        predict = prediction_result[idx]\n",
    "        if predict != label:\n",
    "            ax = plt.subplot(5, 5, num+1)\n",
    "            ax.imshow(np.reshape(images[idx], (28, 28)), cmap='binary')\n",
    "            ax.set_title('idx:' + str(idx) + ',l:' + str(label) + ',p:' + str(predict), fontsize=9)\n",
    "            num += 1\n",
    "        idx += 1\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x1008 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_images_labels_predict_error(mnist.test.images, mnist.test.labels, prediction_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11. 保存模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model saved in file: save_model/tf/model_mnist_cnn_tf\n"
     ]
    }
   ],
   "source": [
    "saver = tf.train.Saver()\n",
    "save_path = saver.save(sess, 'save_model/tf/model_mnist_cnn_tf')\n",
    "print('model saved in file: %s' % save_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 12. 将计算图写入log文件, 用于在 TensorBoard 中查看"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "merged = tf.summary.merge_all()\n",
    "train_writer = tf.summary.FileWriter('log/graph_mnist_cnn', sess.graph)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "sess.close()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tensorflow-keras-practice",
   "language": "python",
   "name": "tensorflow-keras-practice"
  },
  "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}