mnist_GAN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MNIST - Generative Adversarial Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import division, print_function, absolute_import\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting /tmp/data/train-images-idx3-ubyte.gz\n",
      "Extracting /tmp/data/train-labels-idx1-ubyte.gz\n",
      "Extracting /tmp/data/t10k-images-idx3-ubyte.gz\n",
      "Extracting /tmp/data/t10k-labels-idx1-ubyte.gz\n"
     ]
    }
   ],
   "source": [
    "# Import MNIST data\n",
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "mnist = input_data.read_data_sets(\"/tmp/data/\", one_hot=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Training Params\n",
    "learning_rate = 0.0002\n",
    "batch_size = 128\n",
    "num_steps = 70000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Network Params\n",
    "image_dim = 784\n",
    "gen_hidden_dim = 256\n",
    "disc_hidden_dim = 256\n",
    "noise_dim = 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Custom Initializer\n",
    "def xav(shape):\n",
    "    return tf.random_normal(shape=shape,stddev=1./tf.sqrt(shape[0]/2.))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Store layers weight and biases\n",
    "weights = {\n",
    "    'gen_hidden_1' :tf.Variable(xav([noise_dim,gen_hidden_dim])),\n",
    "    'gen_out' : tf.Variable(xav([gen_hidden_dim,image_dim])),\n",
    "    'disc_hidden_1' : tf.Variable(xav([image_dim,disc_hidden_dim])),\n",
    "    'disc_out' : tf.Variable(xav([disc_hidden_dim,1]))\n",
    "}\n",
    "\n",
    "biases = {\n",
    "    'gen_hidden_1' : tf.Variable(tf.zeros([gen_hidden_dim])),\n",
    "    'gen_out' : tf.Variable(tf.zeros([image_dim])),\n",
    "    'disc_hidden_1' : tf.Variable(tf.zeros([disc_hidden_dim])),\n",
    "    'disc_out' : tf.Variable(tf.zeros([1]))\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Generator\n",
    "def generator(x):\n",
    "    hid_layer = tf.add(tf.matmul(x,weights['gen_hidden_1']),biases['gen_hidden_1'])\n",
    "    hid_layer = tf.nn.relu(hid_layer)\n",
    "    \n",
    "    out_layer = tf.add(tf.matmul(hid_layer,weights['gen_out']),biases['gen_out'])\n",
    "    out_layer = tf.nn.sigmoid(out_layer)\n",
    "    \n",
    "    return out_layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Discriminator\n",
    "def discriminator(x):\n",
    "    hid_layer = tf.add(tf.matmul(x,weights['disc_hidden_1']),biases['disc_hidden_1'])\n",
    "    hid_layer = tf.nn.relu(hid_layer)\n",
    "    \n",
    "    out_layer = tf.add(tf.matmul(hid_layer,weights['disc_out']),biases['disc_out'])\n",
    "    out_layer = tf.nn.sigmoid(out_layer)\n",
    "    \n",
    "    return out_layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Building Network\n",
    "\n",
    "#Network inputs\n",
    "gen_input = tf.placeholder(tf.float32,shape=[None,noise_dim],name='input_noise')\n",
    "disc_input = tf.placeholder(tf.float32,shape=[None,image_dim],name='disc_input')\n",
    "\n",
    "#Build Gen Network\n",
    "gen_output = generator(gen_input)\n",
    "\n",
    "#Build 2 Disc Networks(one from noise input and one from generator samples)\n",
    "disc_real = discriminator(disc_input)\n",
    "disc_fake = discriminator(gen_output)\n",
    "\n",
    "#Build Loss\n",
    "gen_loss = -tf.reduce_mean(tf.log(disc_fake))\n",
    "disc_loss = -tf.reduce_mean(tf.log(disc_real)  + tf.log(1. - disc_fake))\n",
    "\n",
    "#Build Optimizers\n",
    "optimizer_gen = tf.train.AdamOptimizer(learning_rate=learning_rate)\n",
    "optimizer_disc = tf.train.AdamOptimizer(learning_rate=learning_rate)\n",
    "\n",
    "#VARIABLES\n",
    "gen_vars = [weights['gen_hidden_1'],weights['gen_out'],\n",
    "           biases['gen_hidden_1'],biases['gen_out']]\n",
    "disc_vars = [weights['disc_hidden_1'],weights['disc_out'],\n",
    "           biases['disc_hidden_1'],biases['disc_out']]\n",
    "\n",
    "#Training ops\n",
    "train_gen = optimizer_gen.minimize(gen_loss,var_list=gen_vars)\n",
    "train_disc = optimizer_disc.minimize(disc_loss,var_list=disc_vars)\n",
    "\n",
    "init = tf.global_variables_initializer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Step 1: Generator Loss: 1.210587, Discriminator Loss: 1.236065\n",
      "Step 2000: Generator Loss: 4.695496, Discriminator Loss: 0.035461\n",
      "Step 4000: Generator Loss: 4.490327, Discriminator Loss: 0.040897\n",
      "Step 6000: Generator Loss: 4.175813, Discriminator Loss: 0.123997\n",
      "Step 8000: Generator Loss: 4.636317, Discriminator Loss: 0.114911\n",
      "Step 10000: Generator Loss: 3.550632, Discriminator Loss: 0.154316\n",
      "Step 12000: Generator Loss: 3.194623, Discriminator Loss: 0.253326\n",
      "Step 14000: Generator Loss: 4.805747, Discriminator Loss: 0.194194\n",
      "Step 16000: Generator Loss: 3.901429, Discriminator Loss: 0.209401\n",
      "Step 18000: Generator Loss: 3.324996, Discriminator Loss: 0.246867\n",
      "Step 20000: Generator Loss: 3.528189, Discriminator Loss: 0.338830\n",
      "Step 22000: Generator Loss: 3.614625, Discriminator Loss: 0.232057\n",
      "Step 24000: Generator Loss: 3.660890, Discriminator Loss: 0.309236\n",
      "Step 26000: Generator Loss: 3.354062, Discriminator Loss: 0.266566\n",
      "Step 28000: Generator Loss: 3.893543, Discriminator Loss: 0.367374\n",
      "Step 30000: Generator Loss: 3.563570, Discriminator Loss: 0.369771\n",
      "Step 32000: Generator Loss: 3.053637, Discriminator Loss: 0.265534\n",
      "Step 34000: Generator Loss: 3.150243, Discriminator Loss: 0.357412\n",
      "Step 36000: Generator Loss: 2.813179, Discriminator Loss: 0.356583\n",
      "Step 38000: Generator Loss: 2.718931, Discriminator Loss: 0.365824\n",
      "Step 40000: Generator Loss: 3.282542, Discriminator Loss: 0.508961\n",
      "Step 42000: Generator Loss: 2.600945, Discriminator Loss: 0.389456\n",
      "Step 44000: Generator Loss: 2.900861, Discriminator Loss: 0.462351\n",
      "Step 46000: Generator Loss: 2.798539, Discriminator Loss: 0.480631\n",
      "Step 48000: Generator Loss: 2.607337, Discriminator Loss: 0.508952\n",
      "Step 50000: Generator Loss: 2.831182, Discriminator Loss: 0.426506\n",
      "Step 52000: Generator Loss: 2.552653, Discriminator Loss: 0.413408\n",
      "Step 54000: Generator Loss: 2.804512, Discriminator Loss: 0.469867\n",
      "Step 56000: Generator Loss: 3.484885, Discriminator Loss: 0.364386\n",
      "Step 58000: Generator Loss: 2.848963, Discriminator Loss: 0.485169\n",
      "Step 60000: Generator Loss: 2.540829, Discriminator Loss: 0.510922\n",
      "Step 62000: Generator Loss: 3.100945, Discriminator Loss: 0.421623\n",
      "Step 64000: Generator Loss: 2.481862, Discriminator Loss: 0.571678\n",
      "Step 66000: Generator Loss: 2.676787, Discriminator Loss: 0.367919\n",
      "Step 68000: Generator Loss: 2.778974, Discriminator Loss: 0.441408\n",
      "Step 70000: Generator Loss: 2.925525, Discriminator Loss: 0.512687\n"
     ]
    }
   ],
   "source": [
    "#Start Training\n",
    "sess = tf.Session()\n",
    "sess.run(init)\n",
    "for i in range(1,num_steps+1):\n",
    "    batch_x, _ = mnist.train.next_batch(batch_size)\n",
    "    z = np.random.uniform(-1.,1.,size=[batch_size,noise_dim])\n",
    "\n",
    "    feed_dict = {disc_input:batch_x,gen_input:z}\n",
    "    _,_,gl,dl = sess.run([train_gen,train_disc,gen_loss,disc_loss],feed_dict=feed_dict)\n",
    "    if i%2000 == 0 or i == 1:\n",
    "        print('Step %i: Generator Loss: %f, Discriminator Loss: %f' %(i,gl,dl))    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Testing\n",
    "n = 6\n",
    "canvas = np.empty((28 * n, 28 * n))\n",
    "for i in range(n):\n",
    "    z = np.random.uniform(-1., 1., size=[n, noise_dim])\n",
    "    g = sess.run(gen_output, feed_dict={gen_input: z})\n",
    "    g = -1 * (g - 1)\n",
    "    for j in range(n):\n",
    "        canvas[i * 28:(i + 1) * 28, j * 28:(j + 1) * 28] = g[j].reshape([28, 28])\n",
    "\n",
    "plt.figure(figsize=(n, n))\n",
    "plt.imshow(canvas, origin=\"upper\", cmap=\"gray\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}