MNIST-Digit.Recognizer-GANs-TensorFlow.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import pickle as pkl\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-2-3efd1c79f029>:2: 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 /Users/sumitsaha/anaconda/lib/python3.6/site-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 /Users/sumitsaha/anaconda/lib/python3.6/site-packages/tensorflow/contrib/learn/python/learn/datasets/base.py:252: _internal_retry.<locals>.wrap.<locals>.wrapped_fn (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use urllib or similar directly.\n",
      "Successfully downloaded train-images-idx3-ubyte.gz 9912422 bytes.\n",
      "WARNING:tensorflow:From /Users/sumitsaha/anaconda/lib/python3.6/site-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 MNIST_data/train-images-idx3-ubyte.gz\n",
      "Successfully downloaded train-labels-idx1-ubyte.gz 28881 bytes.\n",
      "WARNING:tensorflow:From /Users/sumitsaha/anaconda/lib/python3.6/site-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 MNIST_data/train-labels-idx1-ubyte.gz\n",
      "Successfully downloaded t10k-images-idx3-ubyte.gz 1648877 bytes.\n",
      "Extracting MNIST_data/t10k-images-idx3-ubyte.gz\n",
      "Successfully downloaded t10k-labels-idx1-ubyte.gz 4542 bytes.\n",
      "Extracting MNIST_data/t10k-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From /Users/sumitsaha/anaconda/lib/python3.6/site-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"
     ]
    }
   ],
   "source": [
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "mnist = input_data.read_data_sets('MNIST_data')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def model_inputs(real_dim, z_dim):\n",
    "    inputs_real = tf.placeholder(tf.float32, (None, real_dim), name=\"inputs_real\")\n",
    "    inputs_z = tf.placeholder(tf.float32, (None, z_dim), name=\"inputs_z\")\n",
    "    \n",
    "    return inputs_real, inputs_z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generator(z, out_dim, n_units=128, reuse=False,  alpha=0.01):\n",
    "    ''' Build the generator network.\n",
    "    \n",
    "        Arguments\n",
    "        ---------\n",
    "        z : Input tensor for the generator\n",
    "        out_dim : Shape of the generator output\n",
    "        n_units : Number of units in hidden layer\n",
    "        reuse : Reuse the variables with tf.variable_scope\n",
    "        alpha : leak parameter for leaky ReLU\n",
    "        \n",
    "        Returns\n",
    "        -------\n",
    "        out, logits: \n",
    "    '''\n",
    "    with tf.variable_scope('generator', reuse=reuse):\n",
    "        # Hidden layer\n",
    "        h1 = tf.layers.dense(z, n_units, activation=None)\n",
    "        # Leaky ReLU\n",
    "        h1 = tf.maximum(h1, alpha*h1)\n",
    "        \n",
    "        # Logits and tanh output\n",
    "        logits = tf.layers.dense(h1, out_dim, activation=None)\n",
    "        out = tf.nn.tanh(logits)\n",
    "        \n",
    "        return out, logits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def discriminator(x, n_units=128, reuse=False, alpha=0.01):\n",
    "    ''' Build the discriminator network.\n",
    "    \n",
    "        Arguments\n",
    "        ---------\n",
    "        x : Input tensor for the discriminator\n",
    "        n_units: Number of units in hidden layer\n",
    "        reuse : Reuse the variables with tf.variable_scope\n",
    "        alpha : leak parameter for leaky ReLU\n",
    "        \n",
    "        Returns\n",
    "        -------\n",
    "        out, logits: \n",
    "    '''\n",
    "    with tf.variable_scope('discriminator', reuse=reuse):\n",
    "        # Hidden layer\n",
    "        h1 = tf.layers.dense(x, n_units, activation=None)\n",
    "        # Leaky ReLU\n",
    "        h1 = tf.maximum(h1, alpha*h1)\n",
    "        \n",
    "        logits = tf.layers.dense(h1, 1, activation=None)\n",
    "        out = tf.nn.sigmoid(logits)\n",
    "        \n",
    "        return out, logits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Size of input image to discriminator\n",
    "input_size = 784 # 28x28 MNIST images flattened\n",
    "# Size of latent vector to generator\n",
    "z_size = 100\n",
    "# Sizes of hidden layers in generator and discriminator\n",
    "g_hidden_size = 128\n",
    "d_hidden_size = 128\n",
    "# Leak factor for leaky ReLU\n",
    "alpha = 0.01\n",
    "# Label smoothing \n",
    "smooth = 0.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "tf.reset_default_graph()\n",
    "# Create our input placeholders\n",
    "input_real, input_z = model_inputs(input_size, z_size)\n",
    "\n",
    "# Generator network here\n",
    "g_model, g_logits = generator(input_z, input_size, g_hidden_size, reuse=False,  alpha=alpha)\n",
    "# g_model is the generator output\n",
    "\n",
    "# Disriminator network here\n",
    "d_model_real, d_logits_real = discriminator(input_real, d_hidden_size, reuse=False, alpha=alpha)\n",
    "d_model_fake, d_logits_fake = discriminator(g_model, d_hidden_size, reuse=True, alpha=alpha)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate losses\n",
    "d_labels_real = tf.ones_like(d_logits_real) * (1 - smooth)\n",
    "d_labels_fake = tf.zeros_like(d_logits_fake)\n",
    "\n",
    "d_loss_real = tf.nn.sigmoid_cross_entropy_with_logits(labels=d_labels_real, logits=d_logits_real)\n",
    "d_loss_fake = tf.nn.sigmoid_cross_entropy_with_logits(labels=d_labels_fake, logits=d_logits_fake)\n",
    "\n",
    "d_loss = tf.reduce_mean(d_loss_real + d_loss_fake)\n",
    "\n",
    "g_loss = tf.reduce_mean(\n",
    "    tf.nn.sigmoid_cross_entropy_with_logits(\n",
    "        labels=tf.ones_like(d_logits_fake), \n",
    "        logits=d_logits_fake))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Optimizers\n",
    "learning_rate = 0.002\n",
    "\n",
    "# Get the trainable_variables, split into G and D parts\n",
    "t_vars = tf.trainable_variables()\n",
    "g_vars = [var for var in t_vars if var.name.startswith(\"generator\")]\n",
    "d_vars = [var for var in t_vars if var.name.startswith(\"discriminator\")]\n",
    "\n",
    "d_train_opt = tf.train.AdamOptimizer().minimize(d_loss, var_list=d_vars)\n",
    "g_train_opt = tf.train.AdamOptimizer().minimize(g_loss, var_list=g_vars)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/100... Discriminator Loss: 0.3561... Generator Loss: 3.8240\n",
      "Epoch 2/100... Discriminator Loss: 0.3584... Generator Loss: 4.4306\n",
      "Epoch 3/100... Discriminator Loss: 0.4362... Generator Loss: 2.9693\n",
      "Epoch 4/100... Discriminator Loss: 0.6708... Generator Loss: 2.6325\n",
      "Epoch 5/100... Discriminator Loss: 0.6203... Generator Loss: 5.1820\n",
      "Epoch 6/100... Discriminator Loss: 0.6304... Generator Loss: 3.2012\n",
      "Epoch 7/100... Discriminator Loss: 0.7700... Generator Loss: 4.0258\n",
      "Epoch 8/100... Discriminator Loss: 0.8326... Generator Loss: 3.8314\n",
      "Epoch 9/100... Discriminator Loss: 0.9661... Generator Loss: 2.6269\n",
      "Epoch 10/100... Discriminator Loss: 1.0774... Generator Loss: 2.1008\n",
      "Epoch 11/100... Discriminator Loss: 1.7911... Generator Loss: 3.4802\n",
      "Epoch 12/100... Discriminator Loss: 1.1407... Generator Loss: 4.6123\n",
      "Epoch 13/100... Discriminator Loss: 0.9724... Generator Loss: 2.2542\n",
      "Epoch 14/100... Discriminator Loss: 1.1802... Generator Loss: 1.8292\n",
      "Epoch 15/100... Discriminator Loss: 0.9761... Generator Loss: 2.4442\n",
      "Epoch 16/100... Discriminator Loss: 1.0890... Generator Loss: 2.1163\n",
      "Epoch 17/100... Discriminator Loss: 2.1096... Generator Loss: 1.0779\n",
      "Epoch 18/100... Discriminator Loss: 1.2360... Generator Loss: 1.6923\n",
      "Epoch 19/100... Discriminator Loss: 1.1315... Generator Loss: 2.1377\n",
      "Epoch 20/100... Discriminator Loss: 1.1485... Generator Loss: 2.3239\n",
      "Epoch 21/100... Discriminator Loss: 1.1767... Generator Loss: 1.6601\n",
      "Epoch 22/100... Discriminator Loss: 1.4682... Generator Loss: 1.8922\n",
      "Epoch 23/100... Discriminator Loss: 0.9625... Generator Loss: 1.8899\n",
      "Epoch 24/100... Discriminator Loss: 1.2208... Generator Loss: 2.1187\n",
      "Epoch 25/100... Discriminator Loss: 2.3832... Generator Loss: 0.9935\n",
      "Epoch 26/100... Discriminator Loss: 1.1202... Generator Loss: 1.5293\n",
      "Epoch 27/100... Discriminator Loss: 1.1422... Generator Loss: 1.9067\n",
      "Epoch 28/100... Discriminator Loss: 1.2371... Generator Loss: 1.3611\n",
      "Epoch 29/100... Discriminator Loss: 1.2666... Generator Loss: 3.1046\n",
      "Epoch 30/100... Discriminator Loss: 1.1531... Generator Loss: 1.8515\n",
      "Epoch 31/100... Discriminator Loss: 1.3887... Generator Loss: 1.4878\n",
      "Epoch 32/100... Discriminator Loss: 1.0002... Generator Loss: 1.6086\n",
      "Epoch 33/100... Discriminator Loss: 0.7063... Generator Loss: 2.2633\n",
      "Epoch 34/100... Discriminator Loss: 0.8470... Generator Loss: 2.4351\n",
      "Epoch 35/100... Discriminator Loss: 0.7886... Generator Loss: 2.2291\n",
      "Epoch 36/100... Discriminator Loss: 0.7793... Generator Loss: 2.5075\n",
      "Epoch 37/100... Discriminator Loss: 1.2469... Generator Loss: 1.3502\n",
      "Epoch 38/100... Discriminator Loss: 0.9296... Generator Loss: 1.8604\n",
      "Epoch 39/100... Discriminator Loss: 1.2974... Generator Loss: 1.3637\n",
      "Epoch 40/100... Discriminator Loss: 1.0320... Generator Loss: 2.0042\n",
      "Epoch 41/100... Discriminator Loss: 1.3103... Generator Loss: 1.4578\n",
      "Epoch 42/100... Discriminator Loss: 1.1783... Generator Loss: 1.3918\n",
      "Epoch 43/100... Discriminator Loss: 0.9563... Generator Loss: 1.9525\n",
      "Epoch 44/100... Discriminator Loss: 0.9278... Generator Loss: 1.7312\n",
      "Epoch 45/100... Discriminator Loss: 0.7953... Generator Loss: 2.0918\n",
      "Epoch 46/100... Discriminator Loss: 0.9893... Generator Loss: 1.4778\n",
      "Epoch 47/100... Discriminator Loss: 1.1189... Generator Loss: 1.8469\n",
      "Epoch 48/100... Discriminator Loss: 0.7319... Generator Loss: 2.2378\n",
      "Epoch 49/100... Discriminator Loss: 0.8026... Generator Loss: 2.4274\n",
      "Epoch 50/100... Discriminator Loss: 0.9241... Generator Loss: 2.3042\n",
      "Epoch 51/100... Discriminator Loss: 1.0495... Generator Loss: 1.5370\n",
      "Epoch 52/100... Discriminator Loss: 0.8958... Generator Loss: 2.0996\n",
      "Epoch 53/100... Discriminator Loss: 1.0228... Generator Loss: 1.5032\n",
      "Epoch 54/100... Discriminator Loss: 1.1572... Generator Loss: 1.6359\n",
      "Epoch 55/100... Discriminator Loss: 1.0915... Generator Loss: 2.0115\n",
      "Epoch 56/100... Discriminator Loss: 1.0581... Generator Loss: 1.3305\n",
      "Epoch 57/100... Discriminator Loss: 0.8671... Generator Loss: 1.8976\n",
      "Epoch 58/100... Discriminator Loss: 0.9705... Generator Loss: 1.7999\n",
      "Epoch 59/100... Discriminator Loss: 0.9153... Generator Loss: 1.7713\n",
      "Epoch 60/100... Discriminator Loss: 1.2764... Generator Loss: 1.6034\n",
      "Epoch 61/100... Discriminator Loss: 0.8452... Generator Loss: 1.9376\n",
      "Epoch 62/100... Discriminator Loss: 1.1824... Generator Loss: 1.6124\n",
      "Epoch 63/100... Discriminator Loss: 1.1660... Generator Loss: 1.4845\n",
      "Epoch 64/100... Discriminator Loss: 0.9876... Generator Loss: 1.7493\n",
      "Epoch 65/100... Discriminator Loss: 1.3187... Generator Loss: 1.3803\n",
      "Epoch 66/100... Discriminator Loss: 1.4010... Generator Loss: 0.9926\n",
      "Epoch 67/100... Discriminator Loss: 1.0733... Generator Loss: 1.8509\n",
      "Epoch 68/100... Discriminator Loss: 1.0026... Generator Loss: 1.5109\n",
      "Epoch 69/100... Discriminator Loss: 1.3454... Generator Loss: 1.4692\n",
      "Epoch 70/100... Discriminator Loss: 1.1795... Generator Loss: 1.6431\n",
      "Epoch 71/100... Discriminator Loss: 0.9370... Generator Loss: 1.8739\n",
      "Epoch 72/100... Discriminator Loss: 1.1457... Generator Loss: 1.5855\n",
      "Epoch 73/100... Discriminator Loss: 1.2971... Generator Loss: 1.3639\n",
      "Epoch 74/100... Discriminator Loss: 1.1307... Generator Loss: 1.3781\n",
      "Epoch 75/100... Discriminator Loss: 0.9992... Generator Loss: 1.8094\n",
      "Epoch 76/100... Discriminator Loss: 1.0388... Generator Loss: 1.9728\n",
      "Epoch 77/100... Discriminator Loss: 1.0719... Generator Loss: 1.5385\n",
      "Epoch 78/100... Discriminator Loss: 1.0415... Generator Loss: 1.5476\n",
      "Epoch 79/100... Discriminator Loss: 1.2943... Generator Loss: 1.5181\n",
      "Epoch 80/100... Discriminator Loss: 1.0141... Generator Loss: 1.5015\n",
      "Epoch 81/100... Discriminator Loss: 0.8819... Generator Loss: 2.0741\n",
      "Epoch 82/100... Discriminator Loss: 1.1609... Generator Loss: 1.8775\n",
      "Epoch 83/100... Discriminator Loss: 1.0712... Generator Loss: 1.7451\n",
      "Epoch 84/100... Discriminator Loss: 0.9564... Generator Loss: 1.8585\n",
      "Epoch 85/100... Discriminator Loss: 0.9567... Generator Loss: 1.7372\n",
      "Epoch 86/100... Discriminator Loss: 1.0342... Generator Loss: 1.6448\n",
      "Epoch 87/100... Discriminator Loss: 1.1592... Generator Loss: 1.4279\n",
      "Epoch 88/100... Discriminator Loss: 1.1361... Generator Loss: 1.4641\n",
      "Epoch 89/100... Discriminator Loss: 1.0138... Generator Loss: 1.6589\n",
      "Epoch 90/100... Discriminator Loss: 1.1998... Generator Loss: 1.4391\n",
      "Epoch 91/100... Discriminator Loss: 1.1230... Generator Loss: 1.4921\n",
      "Epoch 92/100... Discriminator Loss: 0.9239... Generator Loss: 1.7604\n",
      "Epoch 93/100... Discriminator Loss: 0.9972... Generator Loss: 1.6073\n",
      "Epoch 94/100... Discriminator Loss: 1.0841... Generator Loss: 1.5243\n",
      "Epoch 95/100... Discriminator Loss: 0.9626... Generator Loss: 1.5943\n",
      "Epoch 96/100... Discriminator Loss: 1.0170... Generator Loss: 1.6332\n",
      "Epoch 97/100... Discriminator Loss: 0.9925... Generator Loss: 1.5285\n",
      "Epoch 98/100... Discriminator Loss: 1.1219... Generator Loss: 1.8597\n",
      "Epoch 99/100... Discriminator Loss: 1.0438... Generator Loss: 1.4399\n",
      "Epoch 100/100... Discriminator Loss: 1.1848... Generator Loss: 1.3992\n"
     ]
    }
   ],
   "source": [
    "batch_size = 100\n",
    "epochs = 100\n",
    "samples = []\n",
    "losses = []\n",
    "saver = tf.train.Saver(var_list = g_vars)\n",
    "with tf.Session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    for e in range(epochs):\n",
    "        for ii in range(mnist.train.num_examples//batch_size):\n",
    "            batch = mnist.train.next_batch(batch_size)\n",
    "            \n",
    "            # Get images, reshape and rescale to pass to D\n",
    "            batch_images = batch[0].reshape((batch_size, 784))\n",
    "            batch_images = batch_images*2 - 1\n",
    "            \n",
    "            # Sample random noise for G\n",
    "            batch_z = np.random.uniform(-1, 1, size=(batch_size, z_size))\n",
    "            \n",
    "            # Run optimizers\n",
    "            _ = sess.run(d_train_opt, feed_dict={input_real: batch_images, input_z: batch_z})\n",
    "            _ = sess.run(g_train_opt, feed_dict={input_z: batch_z})\n",
    "        \n",
    "        # At the end of each epoch, get the losses and print them out\n",
    "        train_loss_d = sess.run(d_loss, {input_z: batch_z, input_real: batch_images})\n",
    "        train_loss_g = g_loss.eval({input_z: batch_z})\n",
    "            \n",
    "        print(\"Epoch {}/{}...\".format(e+1, epochs),\n",
    "              \"Discriminator Loss: {:.4f}...\".format(train_loss_d),\n",
    "              \"Generator Loss: {:.4f}\".format(train_loss_g))    \n",
    "        # Save losses to view after training\n",
    "        losses.append((train_loss_d, train_loss_g))\n",
    "        \n",
    "        # Sample from generator as we're training for viewing afterwards\n",
    "        sample_z = np.random.uniform(-1, 1, size=(16, z_size))\n",
    "        gen_samples = sess.run(\n",
    "                       generator(input_z, input_size, reuse=True),\n",
    "                       feed_dict={input_z: sample_z})\n",
    "        samples.append(gen_samples)\n",
    "        saver.save(sess, './checkpoints/generator.ckpt')\n",
    "\n",
    "# Save training generator samples\n",
    "with open('train_samples.pkl', 'wb') as f:\n",
    "    pkl.dump(samples, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x12a109f98>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x132cd9da0>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "losses = np.array(losses)\n",
    "plt.plot(losses.T[0], label='Discriminator')\n",
    "plt.plot(losses.T[1], label='Generator')\n",
    "plt.title(\"Training Losses\")\n",
    "plt.legend()"
   ]
  }
 ],
 "metadata": {
  "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}