notebooks/cnn_mnist_basic.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\"\"\"\n",
    " Convolutional Neural Network (CNN) with MNIST\n",
    " @Sungjoon Choi (sungjoon.choi@cpslab.snu.ac.kr\n",
    " based on \"https://github.com/aymericdamien/TensorFlow-Examples/\"\n",
    "\"\"\"\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "%matplotlib inline  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "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)\n",
    "trainimg   = mnist.train.images\n",
    "trainlabel = mnist.train.labels\n",
    "testimg    = mnist.test.images\n",
    "testlabel  = mnist.test.labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Network Ready to Go!\n"
     ]
    }
   ],
   "source": [
    "# Define convolutional neural network architecture \n",
    "\n",
    "# Parameters\n",
    "learning_rate   = 0.001\n",
    "training_epochs = 5\n",
    "batch_size      = 100\n",
    "display_step    = 1\n",
    "\n",
    "# Network\n",
    "n_input  = 784\n",
    "n_output = 10\n",
    "weights  = {\n",
    "    'wc1': tf.Variable(tf.random_normal([3, 3, 1, 64], stddev=0.1)),\n",
    "    'wc2': tf.Variable(tf.random_normal([3, 3, 64, 128], stddev=0.1)),\n",
    "    'wd1': tf.Variable(tf.random_normal([7*7*128, 1024], stddev=0.1)),\n",
    "    'wd2': tf.Variable(tf.random_normal([1024, n_output], stddev=0.1))\n",
    "}\n",
    "biases   = {\n",
    "    'bc1': tf.Variable(tf.random_normal([64], stddev=0.1)),\n",
    "    'bc2': tf.Variable(tf.random_normal([128], stddev=0.1)),\n",
    "    'bd1': tf.Variable(tf.random_normal([1024], stddev=0.1)),\n",
    "    'bd2': tf.Variable(tf.random_normal([n_output], stddev=0.1))\n",
    "}\n",
    "\n",
    "def conv_basic(_input, _w, _b, _keepratio):\n",
    "    # Input\n",
    "    _input_r = tf.reshape(_input, shape=[-1, 28, 28, 1])\n",
    "    \n",
    "    # Conv1\n",
    "    _conv1 = tf.nn.relu(tf.nn.bias_add(\n",
    "            tf.nn.conv2d(_input_r, _w['wc1'], strides=[1, 1, 1, 1], padding='SAME')\n",
    "            , _b['bc1']))\n",
    "    _pool1 = tf.nn.max_pool(_conv1, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')\n",
    "    _pool_dr1 = tf.nn.dropout(_pool1, _keepratio)\n",
    "    \n",
    "    # Conv2\n",
    "    _conv2 = tf.nn.relu(tf.nn.bias_add(\n",
    "            tf.nn.conv2d(_pool_dr1, _w['wc2'], strides=[1, 1, 1, 1], padding='SAME')\n",
    "            , _b['bc2']))\n",
    "    _pool2 = tf.nn.max_pool(_conv2, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')\n",
    "    _pool_dr2 = tf.nn.dropout(_pool2, _keepratio)\n",
    "    \n",
    "    # Vectorize\n",
    "    _dense1 = tf.reshape(_pool_dr2, [-1, _w['wd1'].get_shape().as_list()[0]])\n",
    "    \n",
    "    # Fc1\n",
    "    _fc1 = tf.nn.relu(tf.add(tf.matmul(_dense1, _w['wd1']), _b['bd1']))\n",
    "    _fc_dr1 = tf.nn.dropout(_fc1, _keepratio)\n",
    "    \n",
    "    # Fc2\n",
    "    _out = tf.add(tf.matmul(_fc_dr1, _w['wd2']), _b['bd2'])\n",
    "    \n",
    "    # Return everything\n",
    "    out = {\n",
    "        'input_r': _input_r,\n",
    "        'conv1': _conv1,\n",
    "        'pool1': _pool1,\n",
    "        'pool1_dr1': _pool_dr1,\n",
    "        'conv2': _conv2,\n",
    "        'pool2': _pool2,\n",
    "        'pool_dr2': _pool_dr2,\n",
    "        'dense1': _dense1,\n",
    "        'fc1': _fc1,\n",
    "        'fc_dr1': _fc_dr1,\n",
    "        'out': _out\n",
    "    }\n",
    "    return out\n",
    "\n",
    "\n",
    "# tf Graph input\n",
    "x = tf.placeholder(tf.float32, [None, n_input])\n",
    "y = tf.placeholder(tf.float32, [None, n_output])\n",
    "keepratio = tf.placeholder(tf.float32)\n",
    "\n",
    "# Functions! \n",
    "_pred = conv_basic(x, weights, biases, keepratio)['out']\n",
    "cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(_pred, y))\n",
    "optm = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)\n",
    "_corr = tf.equal(tf.argmax(_pred,1), tf.argmax(y,1)) # Count corrects\n",
    "accr = tf.reduce_mean(tf.cast(_corr, tf.float32)) # Accuracy\n",
    "init = tf.initialize_all_variables()\n",
    "\n",
    "# Saver \n",
    "save_step = 1;\n",
    "saver = tf.train.Saver(max_to_keep=training_epochs) \n",
    "\n",
    "print (\"Network Ready to Go!\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 000/005 cost: 0.341295869\n",
      " Training accuracy: 0.990\n",
      " Test accuracy: 0.977\n",
      "Epoch: 001/005 cost: 0.052735616\n",
      " Training accuracy: 1.000\n",
      " Test accuracy: 0.987\n",
      "Epoch: 002/005 cost: 0.032829108\n",
      " Training accuracy: 0.990\n",
      " Test accuracy: 0.990\n",
      "Epoch: 003/005 cost: 0.023922637\n",
      " Training accuracy: 0.990\n",
      " Test accuracy: 0.990\n",
      "Epoch: 004/005 cost: 0.018678759\n",
      " Training accuracy: 0.990\n",
      " Test accuracy: 0.992\n",
      "Optimization Finished.\n"
     ]
    }
   ],
   "source": [
    "do_train = 1\n",
    "\n",
    "# Do some optimizations\n",
    "sess = tf.Session()\n",
    "sess.run(init)\n",
    "\n",
    "if do_train == 1:\n",
    "    for epoch in range(training_epochs):\n",
    "        avg_cost = 0.\n",
    "        total_batch = int(mnist.train.num_examples/batch_size)\n",
    "        # Loop over all batches\n",
    "        for i in range(total_batch):\n",
    "            batch_xs, batch_ys = mnist.train.next_batch(batch_size)\n",
    "            # Fit training using batch data\n",
    "            sess.run(optm, feed_dict={x: batch_xs, y: batch_ys, keepratio:0.7})\n",
    "            # Compute average loss\n",
    "            avg_cost += sess.run(cost, feed_dict={x: batch_xs, y: batch_ys, keepratio:1.})/total_batch\n",
    "\n",
    "        # Display logs per epoch step\n",
    "        if epoch % display_step == 0: \n",
    "            print (\"Epoch: %03d/%03d cost: %.9f\" % (epoch, training_epochs, avg_cost))\n",
    "            train_acc = sess.run(accr, feed_dict={x: batch_xs, y: batch_ys, keepratio:1.})\n",
    "            print (\" Training accuracy: %.3f\" % (train_acc))\n",
    "            test_acc = sess.run(accr, feed_dict={x: testimg, y: testlabel, keepratio:1.})\n",
    "            print (\" Test accuracy: %.3f\" % (test_acc))\n",
    "\n",
    "        # Save Net\n",
    "        if epoch % save_step == 0:\n",
    "            saver.save(sess, \"nets/cnn_basic.ckpt-\" + str(epoch))\n",
    "\n",
    "    print (\"Optimization Finished.\")\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Restore net\n",
    "if do_train == 0:\n",
    "    epoch = 4\n",
    "    saver.restore(sess, \"nets/cnn_basic.ckpt-\" + str(epoch))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Test accuracy: 0.992\n"
     ]
    }
   ],
   "source": [
    "# Compute test accuracy\n",
    "test_acc = sess.run(accr, feed_dict={x: testimg, y: testlabel, keepratio:1.})\n",
    "print (\" Test accuracy: %.3f\" % (test_acc))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}