{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CNTK 206  Part B: Deep Convolutional GAN with MNIST data\n",
    "\n",
    "**Prerequisites**: We assume that you have successfully downloaded the MNIST data by completing the tutorial titled CNTK_103A_MNIST_DataLoader.ipynb.\n",
    "\n",
    "## Introduction\n",
    "\n",
    "[Generative models](https://en.wikipedia.org/wiki/Generative_model) have gained a [lot of attention](https://openai.com/blog/generative-models/) in deep learning community which has traditionally leveraged [discriminative models](https://en.wikipedia.org/wiki/Discriminative_model) for (semi-supervised) and unsupervised learning. \n",
    "\n",
    "## Overview\n",
    "In the previous tutorial we introduce the original GAN implementation by [Goodfellow et al](https://arxiv.org/pdf/1406.2661v1.pdf) at NIPS  2014. This pioneering work has since then been extended and many techniques have been published amongst which the Deep Convolutional Generative Adversarial Network a.k.a. DCGAN has become the recommended launch pad in the community.\n",
    "\n",
    "In this tutorial, we introduce an implementation of the DCGAN with some well tested architectural constraints that improve stability in the GAN training: \n",
    "\n",
    "- We use [strided convolutions](https://en.wikipedia.org/wiki/Convolutional_neural_network) in the (discriminator) and [fractional-strided convolutions](https://arxiv.org/pdf/1603.07285v1.pdf) in the generator.\n",
    "- We have used batch normalization in both the generator and the discriminator\n",
    "- We have removed fully connected hidden layers for deeper architectures.\n",
    "- We use ReLU activation in generator for all layers except for the output, which uses Tanh.\n",
    "- We use LeakyReLU activation in the discriminator for all layers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import os\n",
    "\n",
    "import cntk as C\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "\n",
    "In the block below, we check if we are running this notebook in the CNTK internal test machines by looking for environment variables defined there. We then select the right target device (GPU vs CPU) to test this notebook. In other cases, we use CNTK's default policy to use the best available device (GPU, if available, else CPU)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Select the right target device when this notebook is being tested:\n",
    "if 'TEST_DEVICE' in os.environ:\n",
    "    if os.environ['TEST_DEVICE'] == 'cpu':\n",
    "        C.device.set_default_device(C.device.cpu())\n",
    "    else:\n",
    "        C.device.set_default_device(C.device.gpu(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are two run modes:\n",
    "- *Fast mode*: `isFast` is set to `True`. This is the default mode for the notebooks, which means we train for fewer iterations or train / test on limited data. This ensures functional correctness of the notebook though the models produced are far from what a completed training would produce.\n",
    "\n",
    "- *Slow mode*: We recommend the user to set this flag to `False` once the user has gained familiarity with the notebook content and wants to gain insight from running the notebooks for a longer period with different parameters for training. \n",
    "\n",
    "**Note**\n",
    "If the `isFlag` is set to `False` the notebook will take a few hours on a GPU enabled machine. You can try fewer iterations by setting the `num_minibatches` to a smaller number say `20,000` which comes at the expense of quality of the generated images."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "isFast = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Reading\n",
    "The input to the GAN will be a vector of random numbers. At the end of the traning, the GAN \"learns\" to generate images of hand written digits drawn from the [MNIST database](https://en.wikipedia.org/wiki/MNIST_database). We will be using the same MNIST data generated in tutorial 103A.  A more in-depth discussion of the data format and reading methods can be seen in previous tutorials.  For our purposes, just know that the following function returns an object that will be used to generate images from the MNIST dataset.  Since we are building an unsupervised model, we only need to read in `features` and ignore the `labels`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data directory is ..\\Examples\\Image\\DataSets\\MNIST\n"
     ]
    }
   ],
   "source": [
    "# Ensure the training data is generated and available for this tutorial\n",
    "# We search in two locations in the toolkit for the cached MNIST data set.\n",
    "\n",
    "data_found = False\n",
    "for data_dir in [os.path.join(\"..\", \"Examples\", \"Image\", \"DataSets\", \"MNIST\"),\n",
    "                 os.path.join(\"data\", \"MNIST\")]:\n",
    "    train_file = os.path.join(data_dir, \"Train-28x28_cntk_text.txt\")\n",
    "    if os.path.isfile(train_file):\n",
    "        data_found = True\n",
    "        break\n",
    "        \n",
    "if not data_found:\n",
    "    raise ValueError(\"Please generate the data by completing CNTK 103 Part A\")\n",
    "    \n",
    "print(\"Data directory is {0}\".format(data_dir))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def create_reader(path, is_training, input_dim, label_dim):\n",
    "    deserializer = C.io.CTFDeserializer(\n",
    "        filename = path,\n",
    "        streams = C.io.StreamDefs(\n",
    "            labels_unused = C.io.StreamDef(field = 'labels', shape = label_dim, is_sparse = False),\n",
    "            features = C.io.StreamDef(field = 'features', shape = input_dim, is_sparse = False\n",
    "            )\n",
    "        )\n",
    "    )\n",
    "    return C.io.MinibatchSource(\n",
    "        deserializers = deserializer,\n",
    "        randomize = is_training,\n",
    "        max_sweeps = C.io.INFINITELY_REPEAT if is_training else 1\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The random noise we will use to train the GAN is provided by the `noise_sample` function to generate random noise samples from a uniform distribution within the interval [-1, 1]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "np.random.seed(123)\n",
    "def noise_sample(num_samples):\n",
    "    return np.random.uniform(\n",
    "        low = -1.0,\n",
    "        high = 1.0,\n",
    "        size = [num_samples, g_input_dim]\n",
    "    ).astype(np.float32)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model Creation\n",
    "\n",
    "First we provide a brief recap of the basics of GAN. You may skip this block if you are familiar with CNTK 206A. \n",
    "\n",
    "A GAN network is composed of two sub-networks, one called the Generator ($G$) and the other Discriminator ($D$). \n",
    "- The **Generator** takes random noise vector ($z$) as input and strives to output synthetic (fake) image ($x^*$) that is indistinguishable from the real image ($x$) from the MNIST dataset. \n",
    "- The **Discriminator** strives to differentiate between the real image ($x$) and the fake ($x^*$) image.\n",
    "\n",
    "![GAN-flow](https://www.cntk.ai/jup/GAN_basic_flow.png)\n",
    "\n",
    "In each training iteration, the Generator produces more realistic fake images (in other words *minimizes* the difference between the real and generated counterpart) and the Discriminator *maximizes* the probability of assigning the correct label (real vs. fake) to both real examples (from training set) and the generated fake ones. The two conflicting objectives between the sub-networks ($G$ and $D$) leads to the GAN network (when trained) converge to an equilibrium, where the Generator produces realistic looking fake MNIST images and the Discriminator can at best randomly guess whether images are real or fake. The resulting Generator model once trained produces realistic MNIST image with the input being a random number. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model config\n",
    "\n",
    "First, we establish some of the architectural and training hyper-parameters for our model.  \n",
    "\n",
    "- The generator network is fractional strided convolutional network.  The input is a 10-dimensional random vector and the output of the generator is a flattened version of a 28 x 28 fake image. The discriminator is strided-convolution network.  It takes as input the 784 dimensional output of the generator or a real MNIST image, reshapes into a 28 x 28 image format and outputs a single scalar - the estimated probability that the input image is a real MNIST image."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model components\n",
    "We build a computational graph for our model, one each for the generator and the discriminator. First, we establish some of the architectural parameters of our model. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# architectural parameters\n",
    "img_h, img_w = 28, 28\n",
    "kernel_h, kernel_w = 5, 5 \n",
    "stride_h, stride_w = 2, 2\n",
    "\n",
    "# Input / Output parameter of Generator and Discriminator\n",
    "g_input_dim = 100\n",
    "g_output_dim = d_input_dim = img_h * img_w\n",
    "\n",
    "# We expect the kernel shapes to be square in this tutorial and\n",
    "# the strides to be of the same length along each data dimension\n",
    "if kernel_h == kernel_w:\n",
    "    gkernel = dkernel = kernel_h\n",
    "else:\n",
    "    raise ValueError('This tutorial needs square shaped kernel') \n",
    "            \n",
    "if stride_h == stride_w:\n",
    "    gstride = dstride = stride_h\n",
    "else:\n",
    "    raise ValueError('This tutorial needs same stride in all dims')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Helper functions\n",
    "def bn_with_relu(x, activation=C.relu):\n",
    "    h = C.layers.BatchNormalization(map_rank=1)(x)\n",
    "    return C.relu(h)\n",
    "\n",
    "# We use param-relu function to use a leak=0.2 since CNTK implementation \n",
    "# of Leaky ReLU is fixed to 0.01\n",
    "def bn_with_leaky_relu(x, leak=0.2):\n",
    "    h = C.layers.BatchNormalization(map_rank=1)(x)\n",
    "    r = C.param_relu(C.constant((np.ones(h.shape)*leak).astype(np.float32)), h)\n",
    "    return r"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Generator**\n",
    "\n",
    "The generator takes a 100-dimensional random vector (for starters) as input ($z$) and the outputs a 784 dimensional vector, corresponding to a flattened version of a 28 x 28 fake (synthetic) image ($x^*$). In this tutorial, we use fractionally strided convolutions (a.k.a ConvolutionTranspose) with ReLU activations except for the last layer. We use a tanh activation on the last layer to make sure that the output of the generator function is confined to the interval [-1, 1]. The use of ReLU and tanh activation functions are key in addition to using the fractionally strided convolutions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def convolutional_generator(z):\n",
    "    with C.layers.default_options(init=C.normal(scale=0.02)):\n",
    "        print('Generator input shape: ', z.shape)\n",
    "\n",
    "        s_h2, s_w2 = img_h//2, img_w//2 #Input shape (14,14)\n",
    "        s_h4, s_w4 = img_h//4, img_w//4 # Input shape (7,7)\n",
    "        gfc_dim = 1024\n",
    "        gf_dim = 64\n",
    "\n",
    "        h0 = C.layers.Dense(gfc_dim, activation=None)(z)\n",
    "        h0 = bn_with_relu(h0)\n",
    "        print('h0 shape', h0.shape)\n",
    "\n",
    "        h1 = C.layers.Dense([gf_dim * 2, s_h4,  s_w4], activation=None)(h0)\n",
    "        h1 = bn_with_relu(h1)\n",
    "        print('h1 shape', h1.shape)\n",
    "\n",
    "        h2 = C.layers.ConvolutionTranspose2D(gkernel,\n",
    "                                  num_filters=gf_dim*2,\n",
    "                                  strides=gstride,\n",
    "                                  pad=True,\n",
    "                                  output_shape=(s_h2, s_w2),\n",
    "                                  activation=None)(h1)\n",
    "        h2 = bn_with_relu(h2)\n",
    "        print('h2 shape', h2.shape)\n",
    "\n",
    "        h3 = C.layers.ConvolutionTranspose2D(gkernel,\n",
    "                                  num_filters=1,\n",
    "                                  strides=gstride,\n",
    "                                  pad=True,\n",
    "                                  output_shape=(img_h, img_w),\n",
    "                                  activation=C.sigmoid)(h2)\n",
    "        print('h3 shape :', h3.shape)\n",
    "\n",
    "        return C.reshape(h3, img_h * img_w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Discriminator**\n",
    "\n",
    "The discriminator takes as input ($x^*$) the 784 dimensional output of the generator or a real MNIST image, re-shapes the input to a 28 x 28 image and outputs the estimated probability that the input image is a real MNIST image. The network is modeled using strided convolution with Leaky ReLU activation except for the last layer. We use a sigmoid activation on the last layer to ensure the discriminator output lies in the inteval of [0,1]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def convolutional_discriminator(x):\n",
    "    with C.layers.default_options(init=C.normal(scale=0.02)):\n",
    "\n",
    "        dfc_dim = 1024\n",
    "        df_dim = 64\n",
    "\n",
    "        print('Discriminator convolution input shape', x.shape)\n",
    "        x = C.reshape(x, (1, img_h, img_w))\n",
    "\n",
    "        h0 = C.layers.Convolution2D(dkernel, 1, strides=dstride)(x)\n",
    "        h0 = bn_with_leaky_relu(h0, leak=0.2)\n",
    "        print('h0 shape :', h0.shape)\n",
    "\n",
    "        h1 = C.layers.Convolution2D(dkernel, df_dim, strides=dstride)(h0)\n",
    "        h1 = bn_with_leaky_relu(h1, leak=0.2)\n",
    "        print('h1 shape :', h1.shape)\n",
    "\n",
    "        h2 = C.layers.Dense(dfc_dim, activation=None)(h1)\n",
    "        h2 = bn_with_leaky_relu(h2, leak=0.2)\n",
    "        print('h2 shape :', h2.shape)\n",
    "\n",
    "        h3 = C.layers.Dense(1, activation=C.sigmoid)(h2)\n",
    "        print('h3 shape :', h3.shape)\n",
    "\n",
    "        return h3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use a minibatch size of 128 and a fixed learning rate of 0.0002 for training. In the fast mode (`isFast = True`)  we verify only functional correctness with 5000 iterations. \n",
    "\n",
    "**Note**: In the slow mode, the results look a lot better but it requires in the order of 10 minutes depending on your hardware. In general, the more number of minibatches one trains, the better is the fidelity of the generated images."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# training config\n",
    "minibatch_size = 128\n",
    "num_minibatches = 5000 if isFast else 10000\n",
    "lr = 0.0002\n",
    "momentum = 0.5 #equivalent to beta1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Build the graph\n",
    "\n",
    "The rest of the computational graph is mostly responsible for coordinating the training algorithms and parameter updates, which is particularly tricky with GANs for couple reasons. The GANs are sensitive to the choice of learner and the parameters. Many of the parameters chosen here are based on many hard learnt lessons from the community. You may directly go to the code if you have read the basic GAN tutorial. \n",
    "\n",
    "- First, the discriminator must be used on both the real MNIST images and fake images generated by the generator function.  One way to represent this in the computational graph is to create a clone of the output of the discriminator function, but with substituted inputs.  Setting `method=share` in the `clone` function ensures that  both paths through the discriminator model use the same set of parameters.\n",
    "\n",
    "\n",
    "- Second, we need to update the parameters for the generator and discriminator model separately using the gradients from different loss functions.  We can get the parameters for a `Function` in the graph with the `parameters` attribute.  However, when updating the model parameters, update only the parameters of the respective models while keeping the other parameters unchanged. In other words, when updating the generator we will update only the parameters of the $G$ function while keeping the parameters of the $D$ function fixed and vice versa.\n",
    "\n",
    "### Training the Model\n",
    "The code for training the GAN very closely follows the algorithm as presented in the [original NIPS 2014 paper](https://arxiv.org/pdf/1406.2661v1.pdf). In this implementation, we train $D$ to maximize the probability of assigning the correct label (fake vs. real) to both training examples and the samples from $G$. In other words, $D$ and $G$ play the following two-player minimax game with the value function $V(G,D)$:\n",
    "\n",
    "$$\n",
    "    \\min_G \\max_D V(D,G)= \\mathbb{E}_{x}[ log D(x) ] + \\mathbb{E}_{z}[ log(1 - D(G(z))) ]\n",
    "$$\n",
    "\n",
    "At the optimal point of this game the generator will produce realistic looking data while the discriminator will predict that the generated image is indeed fake with a probability of 0.5. The [algorithm referred below](https://arxiv.org/pdf/1406.2661v1.pdf) is implemented in this tutorial.\n",
    "\n",
    "![NIPS2014](https://www.cntk.ai/jup/GAN_goodfellow_NIPS2014.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def build_graph(noise_shape, image_shape, generator, discriminator):\n",
    "    input_dynamic_axes = [C.Axis.default_batch_axis()]\n",
    "    Z = C.input_variable(noise_shape, dynamic_axes=input_dynamic_axes)\n",
    "    X_real = C.input_variable(image_shape, dynamic_axes=input_dynamic_axes)\n",
    "    X_real_scaled = X_real / 255.0\n",
    "\n",
    "    # Create the model function for the generator and discriminator models\n",
    "    X_fake = generator(Z)\n",
    "    D_real = discriminator(X_real_scaled)\n",
    "    D_fake = D_real.clone(\n",
    "        method = 'share',\n",
    "        substitutions = {X_real_scaled.output: X_fake.output}\n",
    "    )\n",
    "\n",
    "    # Create loss functions and configure optimazation algorithms\n",
    "    G_loss = 1.0 - C.log(D_fake)\n",
    "    D_loss = -(C.log(D_real) + C.log(1.0 - D_fake))\n",
    "\n",
    "    G_learner = C.adam(\n",
    "        parameters = X_fake.parameters,\n",
    "        lr = C.learning_rate_schedule(lr, C.UnitType.sample),\n",
    "        momentum = C.momentum_schedule(0.5)\n",
    "    )\n",
    "    D_learner = C.adam(\n",
    "        parameters = D_real.parameters,\n",
    "        lr = C.learning_rate_schedule(lr, C.UnitType.sample),\n",
    "        momentum = C.momentum_schedule(0.5)\n",
    "    )\n",
    "\n",
    "    # Instantiate the trainers\n",
    "    G_trainer = C.Trainer(X_fake,\n",
    "                        (G_loss, None),\n",
    "                        G_learner)\n",
    "    D_trainer = C.Trainer(D_real,\n",
    "                        (D_loss, None),\n",
    "                        D_learner)\n",
    "\n",
    "    return X_real, X_fake, Z, G_trainer, D_trainer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the value functions defined we proceed to interatively train the GAN model. The training of the model can take significnantly long depending on the hardware especiallly if `isFast` flag is turned off."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def train(reader_train, generator, discriminator):\n",
    "    X_real, X_fake, Z, G_trainer, D_trainer = \\\n",
    "        build_graph(g_input_dim, d_input_dim, generator, discriminator)\n",
    "\n",
    "    # print out loss for each model for upto 25 times\n",
    "    print_frequency_mbsize = num_minibatches // 25\n",
    "   \n",
    "    print(\"First row is Generator loss, second row is Discriminator loss\")\n",
    "    pp_G = C.logging.ProgressPrinter(print_frequency_mbsize)\n",
    "    pp_D = C.logging.ProgressPrinter(print_frequency_mbsize)\n",
    "\n",
    "    k = 2\n",
    "\n",
    "    input_map = {X_real: reader_train.streams.features}\n",
    "    for train_step in range(num_minibatches):\n",
    "\n",
    "        # train the discriminator model for k steps\n",
    "        for gen_train_step in range(k):\n",
    "            Z_data = noise_sample(minibatch_size)\n",
    "            X_data = reader_train.next_minibatch(minibatch_size, input_map)\n",
    "            if X_data[X_real].num_samples == Z_data.shape[0]:\n",
    "                batch_inputs = {X_real: X_data[X_real].data, Z: Z_data}\n",
    "                D_trainer.train_minibatch(batch_inputs)\n",
    "\n",
    "        # train the generator model for a single step\n",
    "        Z_data = noise_sample(minibatch_size)\n",
    "        batch_inputs = {Z: Z_data}\n",
    "\n",
    "        G_trainer.train_minibatch(batch_inputs)\n",
    "        G_trainer.train_minibatch(batch_inputs)\n",
    "\n",
    "        pp_G.update_with_trainer(G_trainer)\n",
    "        pp_D.update_with_trainer(D_trainer)\n",
    "\n",
    "        G_trainer_loss = G_trainer.previous_minibatch_loss_average\n",
    "\n",
    "    return Z, X_fake, G_trainer_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generator input shape:  (100,)\n",
      "h0 shape (1024,)\n",
      "h1 shape (128, 7, 7)\n",
      "h2 shape (128, 14, 14)\n",
      "h3 shape : (1, 28, 28)\n",
      "Discriminator convolution input shape (784,)\n",
      "h0 shape : (1, 12, 12)\n",
      "h1 shape : (64, 4, 4)\n",
      "h2 shape : (1024,)\n",
      "h3 shape : (1,)\n",
      "First row is Generator loss, second row is Discriminator loss\n",
      " Minibatch[   1- 200]: loss = 3.068327 * 25600;\n",
      " Minibatch[   1- 200]: loss = 0.576258 * 25600;\n",
      " Minibatch[ 201- 400]: loss = 2.548759 * 25600;\n",
      " Minibatch[ 201- 400]: loss = 0.751483 * 25600;\n",
      " Minibatch[ 401- 600]: loss = 2.492979 * 25600;\n",
      " Minibatch[ 401- 600]: loss = 0.733529 * 25600;\n",
      " Minibatch[ 601- 800]: loss = 2.640448 * 25600;\n",
      " Minibatch[ 601- 800]: loss = 0.630277 * 25600;\n",
      " Minibatch[ 801-1000]: loss = 2.613499 * 25600;\n",
      " Minibatch[ 801-1000]: loss = 0.641353 * 25600;\n",
      " Minibatch[1001-1200]: loss = 2.941752 * 25600;\n",
      " Minibatch[1001-1200]: loss = 0.508987 * 25600;\n",
      " Minibatch[1201-1400]: loss = 3.154518 * 25600;\n",
      " Minibatch[1201-1400]: loss = 0.457012 * 25600;\n",
      " Minibatch[1401-1600]: loss = 3.031533 * 25600;\n",
      " Minibatch[1401-1600]: loss = 0.464435 * 25600;\n",
      " Minibatch[1601-1800]: loss = 3.002604 * 25600;\n",
      " Minibatch[1601-1800]: loss = 0.471941 * 25600;\n",
      " Minibatch[1801-2000]: loss = 2.935072 * 25600;\n",
      " Minibatch[1801-2000]: loss = 0.494520 * 25600;\n",
      " Minibatch[2001-2200]: loss = 2.532236 * 25600;\n",
      " Minibatch[2001-2200]: loss = 0.642679 * 25600;\n",
      " Minibatch[2201-2400]: loss = 2.343875 * 25600;\n",
      " Minibatch[2201-2400]: loss = 0.734038 * 25600;\n",
      " Minibatch[2401-2600]: loss = 2.220511 * 25600;\n",
      " Minibatch[2401-2600]: loss = 0.761546 * 25600;\n",
      " Minibatch[2601-2800]: loss = 2.135404 * 25600;\n",
      " Minibatch[2601-2800]: loss = 0.837375 * 25600;\n",
      " Minibatch[2801-3000]: loss = 2.024169 * 25600;\n",
      " Minibatch[2801-3000]: loss = 0.915809 * 25600;\n",
      " Minibatch[3001-3200]: loss = 1.979185 * 25600;\n",
      " Minibatch[3001-3200]: loss = 0.919028 * 25600;\n",
      " Minibatch[3201-3400]: loss = 1.977707 * 25600;\n",
      " Minibatch[3201-3400]: loss = 0.947804 * 25600;\n",
      " Minibatch[3401-3600]: loss = 1.966524 * 25600;\n",
      " Minibatch[3401-3600]: loss = 0.970254 * 25600;\n",
      " Minibatch[3601-3800]: loss = 1.941212 * 25600;\n",
      " Minibatch[3601-3800]: loss = 0.995152 * 25600;\n",
      " Minibatch[3801-4000]: loss = 1.876207 * 25600;\n",
      " Minibatch[3801-4000]: loss = 1.048710 * 25600;\n",
      " Minibatch[4001-4200]: loss = 1.891443 * 25600;\n",
      " Minibatch[4001-4200]: loss = 1.089349 * 25600;\n",
      " Minibatch[4201-4400]: loss = 1.872024 * 25600;\n",
      " Minibatch[4201-4400]: loss = 1.115871 * 25600;\n",
      " Minibatch[4401-4600]: loss = 1.853380 * 25600;\n",
      " Minibatch[4401-4600]: loss = 1.141012 * 25600;\n",
      " Minibatch[4601-4800]: loss = 1.822673 * 25600;\n",
      " Minibatch[4601-4800]: loss = 1.152480 * 25600;\n",
      " Minibatch[4801-5000]: loss = 1.823204 * 25600;\n",
      " Minibatch[4801-5000]: loss = 1.171813 * 25600;\n"
     ]
    }
   ],
   "source": [
    "reader_train = create_reader(train_file, True, d_input_dim, label_dim=10)\n",
    "\n",
    "# G_input, G_output, G_trainer_loss = train(reader_train, dense_generator, dense_discriminator)\n",
    "G_input, G_output, G_trainer_loss = train(reader_train,\n",
    "                                          convolutional_generator,\n",
    "                                          convolutional_discriminator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training loss of the generator is: 1.71\n"
     ]
    }
   ],
   "source": [
    "# Print the generator loss \n",
    "print(\"Training loss of the generator is: {0:.2f}\".format(G_trainer_loss))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generating Fake (Synthetic) Images\n",
    "\n",
    "Now that we have trained the model, we can create fake images simply by feeding random noise into the generator and displaying the outputs.  Below are a few images generated from random samples.  To get a new set of samples, you can re-run the last cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWUAAAEECAYAAADwLSVEAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1cb1fd06198>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_images(images, subplot_shape):\n",
    "    plt.style.use('ggplot')\n",
    "    fig, axes = plt.subplots(*subplot_shape)\n",
    "    for image, ax in zip(images, axes.flatten()):\n",
    "        ax.imshow(image.reshape(28, 28), vmin=0, vmax=1.0, cmap='gray')\n",
    "        ax.axis('off')\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "noise = noise_sample(36)\n",
    "images = G_output.eval({G_input: noise})\n",
    "plot_images(images, subplot_shape=[6, 6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Larger number of iterations should generate more realistic looking MNIST images. A sampling of such generated images are shown below.\n",
    "\n",
    "![DCGAN-results](http://www.cntk.ai/jup/cntk206B_dcgan_result.jpg)\n",
    "\n",
    "**Note**: It takes a large number of iterations to capture a representation of the real world signal. Even simple dense networks can be quite effective in modelling data albeit MNIST is a relatively simple dataset as well."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**Suggested Task**\n",
    "\n",
    "- Please refer to several hacks presented in this [article](https://github.com/soumith/ganhacks) by Soumith Chintala, Facebook Research. While some of the hacks have been incorporated in this notebook, there are several others I would suggest that you try out.\n",
    "\n",
    "- Performance is a key aspect to deep neural networks training. Study how the changing the minibatch sizes impact the performance both with regards to quality of the generated images and the time it takes to train a model.\n",
    "\n",
    "- Try generating fake images using the CIFAR-10 data set as the training data. How does the network above performs? There are other variation in GAN, such as [conditional GAN](https://arxiv.org/pdf/1411.1784.pdf) where the network is additionally conditioned on the input label. Try implementing the labels.\n"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}