2D-Shapes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2-D CNN Example (shape classification)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "A Convolutional Network implementation example using TensorFlow library.\n",
    "This example tries to classify images of square and circles.\n",
    "\n",
    "Author: Rodrigo Ceballos\n",
    "\n",
    "Adapted from: https://github.com/aymericdamien/TensorFlow-Examples/\n",
    "'''\n",
    "\n",
    "from __future__ import print_function\n",
    "\n",
    "import tensorflow as tf\n",
    "import pickle\n",
    "from dataset_def import Dataset\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parameters\n",
    "learning_rate = 0.01\n",
    "beta = 0.01 # multiplies with regularization term in loss function\n",
    "training_iters = 20000\n",
    "batch_size = 64\n",
    "display_step = 10\n",
    "\n",
    "# Where to save logs\n",
    "logs_path = '/tmp/tensorflow_logs/shapes2D'\n",
    "\n",
    "# Network Parameters\n",
    "n_input = 28**2 # Data generated in data_gen notebook is 28 by 28 by default\n",
    "n_classes = 2 # Squares and Circles\n",
    "dropout = 0.75 # Dropout, probability to keep units\n",
    "\n",
    "# tf Graph input\n",
    "x = tf.placeholder(tf.float32, [None, n_input])\n",
    "y = tf.placeholder(tf.float32, [None, n_classes])\n",
    "keep_prob = tf.placeholder(tf.float32) #dropout (keep probability)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Create some wrappers for simplicity\n",
    "def conv2d(x, W, b, strides=1):\n",
    "    # Conv2D wrapper, with bias and relu activation\n",
    "    x = tf.nn.conv2d(x, W, strides=[1, strides, strides, 1], padding='SAME')\n",
    "    x = tf.nn.bias_add(x, b)\n",
    "    return tf.nn.relu(x)\n",
    "\n",
    "def maxpool2d(x, k=2):\n",
    "    # MaxPool2D wrapper\n",
    "    return tf.nn.max_pool(x, ksize=[1, k, k, 1], strides=[1, k, k, 1],\n",
    "                          padding='SAME')\n",
    "\n",
    "# Create model\n",
    "def conv_net(x, weights, biases, dropout):\n",
    "    # Reshape input picture\n",
    "    x = tf.reshape(x, shape=[-1, 28, 28, 1])\n",
    "\n",
    "    # Convolution Layer\n",
    "    conv1 = conv2d(x, weights['wc1'], biases['bc1'])\n",
    "    # Max Pooling (down-sampling)\n",
    "    conv1 = maxpool2d(conv1, k=2)\n",
    "\n",
    "    # Convolution Layer\n",
    "    conv2 = conv2d(conv1, weights['wc2'], biases['bc2'])\n",
    "    # Max Pooling (down-sampling)\n",
    "    conv2 = maxpool2d(conv2, k=2)\n",
    "\n",
    "    # Fully connected layer\n",
    "    # Reshape conv2 output to fit fully connected layer input\n",
    "    fc1 = tf.reshape(conv2, [-1, weights['wd1'].get_shape().as_list()[0]])\n",
    "    fc1 = tf.add(tf.matmul(fc1, weights['wd1']), biases['bd1'])\n",
    "    fc1 = tf.nn.relu(fc1)\n",
    "    # Apply Dropout\n",
    "    fc1 = tf.nn.dropout(fc1, dropout)\n",
    "\n",
    "    # Output, class prediction\n",
    "    out = tf.add(tf.matmul(fc1, weights['out']), biases['out'])\n",
    "    return out\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def variable_summaries(var):\n",
    "    \"\"\"Attach a lot of summaries to a Tensor (for TensorBoard visualization).\"\"\"\n",
    "    with tf.name_scope('summaries'):\n",
    "        mean = tf.reduce_mean(var)\n",
    "        tf.summary.scalar('mean', mean)\n",
    "        with tf.name_scope('stddev'):\n",
    "            stddev = tf.sqrt(tf.reduce_mean(tf.square(var - mean)))\n",
    "        tf.summary.scalar('stddev', stddev)\n",
    "        tf.summary.scalar('max', tf.reduce_max(var))\n",
    "        tf.summary.scalar('min', tf.reduce_min(var))\n",
    "        tf.summary.histogram('histogram', var)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "layer_sizes = [16,32,64]\n",
    "# Store layers weight & bias\n",
    "weights = {\n",
    "    # 5x5 conv, 1 input, 32 outputs\n",
    "    'wc1': tf.Variable(tf.random_normal([5, 5, 1, layer_sizes[0]])),\n",
    "    # 5x5 conv, 32 inputs, 64 outputs\n",
    "    'wc2': tf.Variable(tf.random_normal([5, 5, layer_sizes[0], layer_sizes[1]])),\n",
    "    # fully connected, 7*7*64 inputs, 1024 outputs\n",
    "    'wd1': tf.Variable(tf.random_normal([7*7*layer_sizes[1], layer_sizes[2]])),\n",
    "    # 1024 inputs, 10 outputs (class prediction)\n",
    "    'out': tf.Variable(tf.random_normal([layer_sizes[2], n_classes]))\n",
    "}\n",
    "\n",
    "biases = {\n",
    "    'bc1': tf.Variable(tf.random_normal([layer_sizes[0]])),\n",
    "    'bc2': tf.Variable(tf.random_normal([layer_sizes[1]])),\n",
    "    'bd1': tf.Variable(tf.random_normal([layer_sizes[2]])),\n",
    "    'out': tf.Variable(tf.random_normal([n_classes]))\n",
    "}\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:loading data...\n",
      "INFO:tensorflow:DONE\n"
     ]
    }
   ],
   "source": [
    "# Load data\n",
    "tf.logging.info('loading data...')\n",
    "with open('data/shapes/2D_train_dataset.pickle', 'rb') as data:\n",
    "    train_dataset = pickle.load(data)\n",
    "    \n",
    "with open('data/shapes/2D_test_dataset.pickle', 'rb') as data:\n",
    "    test_dataset = pickle.load(data)\n",
    "tf.logging.info('DONE')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Construct model\n",
    "pred = conv_net(x, weights, biases, keep_prob)\n",
    "\n",
    "\n",
    "# Regularize Weights\n",
    "for name, weight in weights.iteritems():\n",
    "    if 'regularizer' in locals(): regularizer += tf.nn.l2_loss(weight)\n",
    "    else: regularizer = tf.nn.l2_loss(weight)\n",
    "    \n",
    "# Define loss and optimizer\n",
    "with tf.name_scope('Loss'):\n",
    "    cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred, labels=y) + beta*regularizer)\n",
    "    variable_summaries(cost)\n",
    "optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)\n",
    "\n",
    "# Evaluate model\n",
    "correct_pred = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))\n",
    "with tf.name_scope('Accuracy'):\n",
    "    accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))\n",
    "    variable_summaries(accuracy)\n",
    "\n",
    "\n",
    "# Create a summary to monitor cost tensor\n",
    "cost_summ = tf.summary.scalar(\"loss\", cost)\n",
    "# Create a summary to monitor accuracy tensor\n",
    "acc_summ = tf.summary.scalar(\"accuracy\", accuracy)\n",
    "# Merge all summaries into a single op\n",
    "merged = tf.summary.merge([cost_summ, acc_summ]);\n",
    "\n",
    "# Initializing the variables\n",
    "init = tf.global_variables_initializer()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iter 1280, Minibatch Loss= 3075.438721, Training Accuracy= 0.59375, Testing Accuracy= 0.58000\n",
      "Iter 2560, Minibatch Loss= 2396.412598, Training Accuracy= 0.75000, Testing Accuracy= 0.69000\n",
      "Iter 3840, Minibatch Loss= 2159.945312, Training Accuracy= 0.84375, Testing Accuracy= 0.79000\n",
      "Iter 5120, Minibatch Loss= 2083.622559, Training Accuracy= 0.85938, Testing Accuracy= 0.80000\n",
      "Iter 6400, Minibatch Loss= 1985.552856, Training Accuracy= 0.88281, Testing Accuracy= 0.86000\n",
      "Iter 7680, Minibatch Loss= 1932.157227, Training Accuracy= 0.92969, Testing Accuracy= 0.85000\n",
      "Iter 8960, Minibatch Loss= 1868.141113, Training Accuracy= 0.95312, Testing Accuracy= 0.86000\n",
      "Iter 10240, Minibatch Loss= 1817.896606, Training Accuracy= 0.94531, Testing Accuracy= 0.87000\n",
      "Iter 11520, Minibatch Loss= 1765.983154, Training Accuracy= 1.00000, Testing Accuracy= 0.87000\n",
      "Iter 12800, Minibatch Loss= 1724.656250, Training Accuracy= 0.98438, Testing Accuracy= 0.91000\n",
      "Iter 14080, Minibatch Loss= 1685.036377, Training Accuracy= 0.99219, Testing Accuracy= 0.89000\n",
      "Iter 15360, Minibatch Loss= 1646.319824, Training Accuracy= 0.98438, Testing Accuracy= 0.91000\n",
      "Iter 16640, Minibatch Loss= 1610.472412, Training Accuracy= 0.99219, Testing Accuracy= 0.89000\n",
      "Iter 17920, Minibatch Loss= 1576.518677, Training Accuracy= 0.98438, Testing Accuracy= 0.92000\n",
      "Iter 19200, Minibatch Loss= 1544.958740, Training Accuracy= 0.99219, Testing Accuracy= 0.91000\n",
      "Optimization Finished!\n",
      "Testing Accuracy: 0.93\n",
      "Run the command line:\n",
      "--> tensorboard --logdir=/tmp/tensorflow_logs \n",
      "Then open http://0.0.0.0:6006/ into your web browser\n"
     ]
    }
   ],
   "source": [
    "# Launch the graph\n",
    "with tf.Session() as sess:\n",
    "    sess.run(init)\n",
    "    step = 1\n",
    "    \n",
    "    # op to write logs to Tensorboard\n",
    "    summary_writer = tf.summary.FileWriter(logs_path, graph=tf.get_default_graph())\n",
    "    \n",
    "    # Keep training until reach max iterations\n",
    "    while step * batch_size < training_iters:\n",
    "        \n",
    "        batch_x, batch_y = train_dataset.next_batch(batch_size)\n",
    "        # Run optimization op (backprop)\n",
    "        _, summary = sess.run([optimizer, merged], feed_dict={x: batch_x, y: batch_y,\n",
    "                                       keep_prob: dropout})\n",
    "        summary_writer.add_summary(summary, step)\n",
    "        \n",
    "        if step % display_step == 0:\n",
    "            # Calculate batch loss and accuracy\n",
    "            loss, acc = sess.run([cost, accuracy], feed_dict={x: batch_x,\n",
    "                                                              y: batch_y,\n",
    "                                                              keep_prob: 1.})\n",
    "            test_batch_x, test_batch_y = test_dataset.next_batch(256)\n",
    "            accTest = sess.run(accuracy, feed_dict={x: test_batch_x,\n",
    "                                      y: test_batch_y,\n",
    "                                      keep_prob: 1.})\n",
    "            print(\"Iter \" + str(step*batch_size) + \\\n",
    "                  \", Minibatch Loss= \" + \"{:.6f}\".format(loss) + \\\n",
    "                  \", Training Accuracy= \" + \"{:.5f}\".format(acc) + \\\n",
    "                  \", Testing Accuracy= \" + \"{:.5f}\".format(accTest) )\n",
    "            \n",
    "            \n",
    "            \n",
    "            \n",
    "        step += 1\n",
    "    print(\"Optimization Finished!\")\n",
    "\n",
    "    # Calculate accuracy for 256 mnist test images\n",
    "    test_batch_x, test_batch_y = test_dataset.next_batch(256)\n",
    "    print(\"Testing Accuracy:\", \\\n",
    "        sess.run(accuracy, feed_dict={x: test_batch_x,\n",
    "                                      y: test_batch_y,\n",
    "                                      keep_prob: 1.}))\n",
    "    print(\"Run the command line:\\n\" \\\n",
    "          \"--> tensorboard --logdir=/tmp/tensorflow_logs \" \\\n",
    "          \"\\nThen open http://0.0.0.0:6006/ into your web browser\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### DANGER: Deletes logged data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os, shutil\n",
    "def deleteFolderContents(folder_path, delete_sub_dir = False):\n",
    "    for the_file in os.listdir(folder_path):\n",
    "        file_path = os.path.join(folder_path, the_file)\n",
    "        try:\n",
    "            if os.path.isfile(file_path):\n",
    "                os.unlink(file_path)\n",
    "            elif delete_sub_dir and os.path.isdir(file_path): shutil.rmtree(file_path)\n",
    "        except Exception as e:\n",
    "            print(e)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CAREFUL: DELETE ALL LOGS\n",
    "folder = '/tmp/tensorflow_logs/'\n",
    "deleteFolderContents(folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# CAREFUL, DELETE THIS LOG (need to run)\n",
    "deleteFolderContents(logs_path)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:ceNeuron]",
   "language": "python",
   "name": "conda-env-ceNeuron-py"
  },
  "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}