FaceGeneratorDCGAN.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "69b13cbca3614de202fe1b5de41e3f2166b4067b",
    "colab": {},
    "colab_type": "code",
    "id": "CAkj8P6m-AJA"
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import time\n",
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "from glob import glob\n",
    "import datetime\n",
    "import random\n",
    "from PIL import Image\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "269879e2953fb178303e03dcbcbf3f52ff2dee7b",
    "colab": {},
    "colab_type": "code",
    "id": "fdzDJyNa-dDA"
   },
   "outputs": [],
   "source": [
    "def generator(z, output_channel_dim, training):\n",
    "    with tf.variable_scope(\"generator\", reuse= not training):\n",
    "        \n",
    "        # 8x8x1024\n",
    "        fully_connected = tf.layers.dense(z, 8*8*1024)\n",
    "        fully_connected = tf.reshape(fully_connected, (-1, 8, 8, 1024))\n",
    "        fully_connected = tf.nn.leaky_relu(fully_connected)\n",
    "\n",
    "        # 8x8x1024 -> 16x16x512\n",
    "        trans_conv1 = tf.layers.conv2d_transpose(inputs=fully_connected,\n",
    "                                                 filters=512,\n",
    "                                                 kernel_size=[5,5],\n",
    "                                                 strides=[2,2],\n",
    "                                                 padding=\"SAME\",\n",
    "                                                 kernel_initializer=tf.truncated_normal_initializer(stddev=WEIGHT_INIT_STDDEV),\n",
    "                                                 name=\"trans_conv1\")\n",
    "        batch_trans_conv1 = tf.layers.batch_normalization(inputs = trans_conv1,\n",
    "                                                          training=training,\n",
    "                                                          epsilon=EPSILON,\n",
    "                                                          name=\"batch_trans_conv1\")\n",
    "        trans_conv1_out = tf.nn.leaky_relu(batch_trans_conv1,\n",
    "                                           name=\"trans_conv1_out\")\n",
    "        \n",
    "        # 16x16x512 -> 32x32x256\n",
    "        trans_conv2 = tf.layers.conv2d_transpose(inputs=trans_conv1_out,\n",
    "                                                 filters=256,\n",
    "                                                 kernel_size=[5,5],\n",
    "                                                 strides=[2,2],\n",
    "                                                 padding=\"SAME\",\n",
    "                                                 kernel_initializer=tf.truncated_normal_initializer(stddev=WEIGHT_INIT_STDDEV),\n",
    "                                                 name=\"trans_conv2\")\n",
    "        batch_trans_conv2 = tf.layers.batch_normalization(inputs = trans_conv2,\n",
    "                                                          training=training,\n",
    "                                                          epsilon=EPSILON,\n",
    "                                                          name=\"batch_trans_conv2\")\n",
    "        trans_conv2_out = tf.nn.leaky_relu(batch_trans_conv2,\n",
    "                                           name=\"trans_conv2_out\")\n",
    "        \n",
    "        # 32x32x256 -> 64x64x128\n",
    "        trans_conv3 = tf.layers.conv2d_transpose(inputs=trans_conv2_out,\n",
    "                                                 filters=128,\n",
    "                                                 kernel_size=[5,5],\n",
    "                                                 strides=[2,2],\n",
    "                                                 padding=\"SAME\",\n",
    "                                                 kernel_initializer=tf.truncated_normal_initializer(stddev=WEIGHT_INIT_STDDEV),\n",
    "                                                 name=\"trans_conv3\")\n",
    "        batch_trans_conv3 = tf.layers.batch_normalization(inputs = trans_conv3,\n",
    "                                                          training=training,\n",
    "                                                          epsilon=EPSILON,\n",
    "                                                          name=\"batch_trans_conv3\")\n",
    "        trans_conv3_out = tf.nn.leaky_relu(batch_trans_conv3,\n",
    "                                           name=\"trans_conv3_out\")\n",
    "        \n",
    "        # 64x64x128 -> 128x128x64\n",
    "        trans_conv4 = tf.layers.conv2d_transpose(inputs=trans_conv3_out,\n",
    "                                                 filters=64,\n",
    "                                                 kernel_size=[5,5],\n",
    "                                                 strides=[2,2],\n",
    "                                                 padding=\"SAME\",\n",
    "                                                 kernel_initializer=tf.truncated_normal_initializer(stddev=WEIGHT_INIT_STDDEV),\n",
    "                                                 name=\"trans_conv4\")\n",
    "        batch_trans_conv4 = tf.layers.batch_normalization(inputs = trans_conv4,\n",
    "                                                          training=training,\n",
    "                                                          epsilon=EPSILON,\n",
    "                                                          name=\"batch_trans_conv4\")\n",
    "        trans_conv4_out = tf.nn.leaky_relu(batch_trans_conv4,\n",
    "                                           name=\"trans_conv4_out\")\n",
    "        \n",
    "        # 128x128x64 -> 128x128x3\n",
    "        logits = tf.layers.conv2d_transpose(inputs=trans_conv4_out,\n",
    "                                            filters=3,\n",
    "                                            kernel_size=[5,5],\n",
    "                                            strides=[1,1],\n",
    "                                            padding=\"SAME\",\n",
    "                                            kernel_initializer=tf.truncated_normal_initializer(stddev=WEIGHT_INIT_STDDEV),\n",
    "                                            name=\"logits\")\n",
    "        out = tf.tanh(logits, name=\"out\")\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "fd0ecc8bd98a8bab6d8cd0e51aed1a0dbc500f79",
    "colab": {},
    "colab_type": "code",
    "id": "1dIfUSZF-qeL"
   },
   "outputs": [],
   "source": [
    "def discriminator(x, reuse):\n",
    "    with tf.variable_scope(\"discriminator\", reuse=reuse): \n",
    "        \n",
    "        # 128*128*3 -> 64x64x64 \n",
    "        conv1 = tf.layers.conv2d(inputs=x,\n",
    "                                 filters=64,\n",
    "                                 kernel_size=[5,5],\n",
    "                                 strides=[2,2],\n",
    "                                 padding=\"SAME\",\n",
    "                                 kernel_initializer=tf.truncated_normal_initializer(stddev=WEIGHT_INIT_STDDEV),\n",
    "                                 name='conv1')\n",
    "        batch_norm1 = tf.layers.batch_normalization(conv1,\n",
    "                                                    training=True,\n",
    "                                                    epsilon=EPSILON,\n",
    "                                                    name='batch_norm1')\n",
    "        conv1_out = tf.nn.leaky_relu(batch_norm1,\n",
    "                                     name=\"conv1_out\")\n",
    "        \n",
    "        # 64x64x64-> 32x32x128 \n",
    "        conv2 = tf.layers.conv2d(inputs=conv1_out,\n",
    "                                 filters=128,\n",
    "                                 kernel_size=[5, 5],\n",
    "                                 strides=[2, 2],\n",
    "                                 padding=\"SAME\",\n",
    "                                 kernel_initializer=tf.truncated_normal_initializer(stddev=WEIGHT_INIT_STDDEV),\n",
    "                                 name='conv2')\n",
    "        batch_norm2 = tf.layers.batch_normalization(conv2,\n",
    "                                                    training=True,\n",
    "                                                    epsilon=EPSILON,\n",
    "                                                    name='batch_norm2')\n",
    "        conv2_out = tf.nn.leaky_relu(batch_norm2,\n",
    "                                     name=\"conv2_out\")\n",
    "        \n",
    "        # 32x32x128 -> 16x16x256  \n",
    "        conv3 = tf.layers.conv2d(inputs=conv2_out,\n",
    "                                 filters=256,\n",
    "                                 kernel_size=[5, 5],\n",
    "                                 strides=[2, 2],\n",
    "                                 padding=\"SAME\",\n",
    "                                 kernel_initializer=tf.truncated_normal_initializer(stddev=WEIGHT_INIT_STDDEV),\n",
    "                                 name='conv3')\n",
    "        batch_norm3 = tf.layers.batch_normalization(conv3,\n",
    "                                                    training=True,\n",
    "                                                    epsilon=EPSILON,\n",
    "                                                    name='batch_norm3')\n",
    "        conv3_out = tf.nn.leaky_relu(batch_norm3,\n",
    "                                     name=\"conv3_out\")\n",
    "        \n",
    "        # 16x16x256 -> 16x16x512\n",
    "        conv4 = tf.layers.conv2d(inputs=conv3_out,\n",
    "                                 filters=512,\n",
    "                                 kernel_size=[5, 5],\n",
    "                                 strides=[1, 1],\n",
    "                                 padding=\"SAME\",\n",
    "                                 kernel_initializer=tf.truncated_normal_initializer(stddev=WEIGHT_INIT_STDDEV),\n",
    "                                 name='conv4')\n",
    "        batch_norm4 = tf.layers.batch_normalization(conv4,\n",
    "                                                    training=True,\n",
    "                                                    epsilon=EPSILON,\n",
    "                                                    name='batch_norm4')\n",
    "        conv4_out = tf.nn.leaky_relu(batch_norm4,\n",
    "                                     name=\"conv4_out\")\n",
    "        \n",
    "        # 16x16x512 -> 8x8x1024\n",
    "        conv5 = tf.layers.conv2d(inputs=conv4_out,\n",
    "                                filters=1024,\n",
    "                                kernel_size=[5, 5],\n",
    "                                strides=[2, 2],\n",
    "                                padding=\"SAME\",\n",
    "                                kernel_initializer=tf.truncated_normal_initializer(stddev=WEIGHT_INIT_STDDEV),\n",
    "                                name='conv5')\n",
    "        batch_norm5 = tf.layers.batch_normalization(conv5,\n",
    "                                                    training=True,\n",
    "                                                    epsilon=EPSILON,\n",
    "                                                    name='batch_norm5')\n",
    "        conv5_out = tf.nn.leaky_relu(batch_norm5,\n",
    "                                     name=\"conv5_out\")\n",
    "\n",
    "        flatten = tf.reshape(conv5_out, (-1, 8*8*1024))\n",
    "        logits = tf.layers.dense(inputs=flatten,\n",
    "                                 units=1,\n",
    "                                 activation=None)\n",
    "        out = tf.sigmoid(logits)\n",
    "        return out, logits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "b24938d4786878c0df90b7cedab93568d01fba09",
    "colab": {},
    "colab_type": "code",
    "id": "PgEg-7ce-qjv"
   },
   "outputs": [],
   "source": [
    "def model_loss(input_real, input_z, output_channel_dim):\n",
    "    g_model = generator(input_z, output_channel_dim, True)\n",
    "\n",
    "    noisy_input_real = input_real + tf.random_normal(shape=tf.shape(input_real),\n",
    "                                                     mean=0.0,\n",
    "                                                     stddev=random.uniform(0.0, 0.1),\n",
    "                                                     dtype=tf.float32)\n",
    "    \n",
    "    d_model_real, d_logits_real = discriminator(noisy_input_real, reuse=False)\n",
    "    d_model_fake, d_logits_fake = discriminator(g_model, reuse=True)\n",
    "    \n",
    "    d_loss_real = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_real,\n",
    "                                                                         labels=tf.ones_like(d_model_real)*random.uniform(0.9, 1.0)))\n",
    "    d_loss_fake = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_fake,\n",
    "                                                                         labels=tf.zeros_like(d_model_fake)))\n",
    "    d_loss = tf.reduce_mean(0.5 * (d_loss_real + d_loss_fake))\n",
    "    g_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_fake,\n",
    "                                                                    labels=tf.ones_like(d_model_fake)))\n",
    "    return d_loss, g_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "7dbc0c421979ed07e96b97dd89bb6371e24912ae",
    "colab": {},
    "colab_type": "code",
    "id": "sh0wH3f1-qrI"
   },
   "outputs": [],
   "source": [
    "def model_optimizers(d_loss, g_loss):\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",
    "    update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)\n",
    "    gen_updates = [op for op in update_ops if op.name.startswith('generator') or op.name.startswith('discriminator')]\n",
    "    \n",
    "    with tf.control_dependencies(gen_updates):\n",
    "        d_train_opt = tf.train.AdamOptimizer(learning_rate=LR_D, beta1=BETA1).minimize(d_loss, var_list=d_vars)\n",
    "        g_train_opt = tf.train.AdamOptimizer(learning_rate=LR_G, beta1=BETA1).minimize(g_loss, var_list=g_vars)  \n",
    "    return d_train_opt, g_train_opt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "98640bff572fd14dacb3c133bee04a3019f139dc",
    "colab": {},
    "colab_type": "code",
    "id": "Y3ic2whC-i1Q"
   },
   "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=\"input_z\")\n",
    "    learning_rate_G = tf.placeholder(tf.float32, name=\"lr_g\")\n",
    "    learning_rate_D = tf.placeholder(tf.float32, name=\"lr_d\")\n",
    "    return inputs_real, inputs_z, learning_rate_G, learning_rate_D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "f50ecde09443ec43074c916c197c1bddec783ef1",
    "colab": {},
    "colab_type": "code",
    "id": "cqsjGWY0-i9m"
   },
   "outputs": [],
   "source": [
    "def show_samples(sample_images, name, epoch):\n",
    "    figure, axes = plt.subplots(1, len(sample_images), figsize = (IMAGE_SIZE, IMAGE_SIZE))\n",
    "    for index, axis in enumerate(axes):\n",
    "        axis.axis('off')\n",
    "        image_array = sample_images[index]\n",
    "        axis.imshow(image_array)\n",
    "        image = Image.fromarray(image_array)\n",
    "        image.save(name+\"_\"+str(epoch)+\"_\"+str(index)+\".png\") \n",
    "    plt.savefig(name+\"_\"+str(epoch)+\".png\", bbox_inches='tight', pad_inches=0)\n",
    "    plt.show()\n",
    "    plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "99f792f2bccdc7b70511bde7b276e5fe72ebd38e",
    "colab": {},
    "colab_type": "code",
    "id": "ABruaSXz-dLn"
   },
   "outputs": [],
   "source": [
    "def test(sess, input_z, out_channel_dim, epoch):\n",
    "    example_z = np.random.uniform(-1, 1, size=[SAMPLES_TO_SHOW, input_z.get_shape().as_list()[-1]])\n",
    "    samples = sess.run(generator(input_z, out_channel_dim, False), feed_dict={input_z: example_z})\n",
    "    sample_images = [((sample + 1.0) * 127.5).astype(np.uint8) for sample in samples]\n",
    "    show_samples(sample_images, OUTPUT_DIR + \"samples\", epoch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "80caaf83ab3ce84c96f2d50f623138fbeb6b5a36",
    "colab": {},
    "colab_type": "code",
    "id": "7jlynGxL-KM5"
   },
   "outputs": [],
   "source": [
    "def summarize_epoch(epoch, sess, d_losses, g_losses, input_z, data_shape, saver):\n",
    "    print(\"\\nEpoch {}/{}\".format(epoch, EPOCHS),\n",
    "          \"\\nD Loss: {:.5f}\".format(np.mean(d_losses[-MINIBATCH_SIZE:])),\n",
    "          \"\\nG Loss: {:.5f}\".format(np.mean(g_losses[-MINIBATCH_SIZE:])))\n",
    "    fig, ax = plt.subplots()\n",
    "    plt.plot(d_losses, label='Discriminator', alpha=0.6)\n",
    "    plt.plot(g_losses, label='Generator', alpha=0.6)\n",
    "    plt.title(\"Losses\")\n",
    "    plt.legend()\n",
    "    plt.savefig(OUTPUT_DIR + \"losses_\" + str(epoch) + \".png\")\n",
    "    plt.show()\n",
    "    plt.close()\n",
    "    saver.save(sess, OUTPUT_DIR + \"model_\" + str(epoch) + \".ckpt\")\n",
    "    test(sess, input_z, data_shape[3], epoch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "b473c2d608c518b083e380afb4abc59918649f49",
    "colab": {},
    "colab_type": "code",
    "id": "qREM80mB-KVB"
   },
   "outputs": [],
   "source": [
    "def get_batch(dataset):\n",
    "    files = random.sample(dataset, BATCH_SIZE)\n",
    "    batch = []\n",
    "    for file in files:\n",
    "        if random.choice([True, False]):\n",
    "            batch.append(np.asarray(Image.open(file).transpose(Image.FLIP_LEFT_RIGHT)))\n",
    "        else:\n",
    "            batch.append(np.asarray(Image.open(file)))                     \n",
    "    batch = np.asarray(batch)\n",
    "    normalized_batch = (batch / 127.5) - 1.0\n",
    "    return normalized_batch, files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "3157b1180042f57417164303eb04ea0d8694a23c",
    "colab": {},
    "colab_type": "code",
    "id": "zmfeOwQl-KYr"
   },
   "outputs": [],
   "source": [
    "def train(data_shape, epoch, checkpoint_path):\n",
    "    input_images, input_z, lr_G, lr_D = model_inputs(data_shape[1:], NOISE_SIZE)\n",
    "    d_loss, g_loss = model_loss(input_images, input_z, data_shape[3])\n",
    "    d_opt, g_opt = model_optimizers(d_loss, g_loss)\n",
    "    \n",
    "    with tf.Session() as sess:\n",
    "        sess.run(tf.global_variables_initializer())\n",
    "        saver = tf.train.Saver()\n",
    "        if checkpoint_path is not None:\n",
    "            saver.restore(sess, checkpoint_path)\n",
    "            \n",
    "        iteration = 0\n",
    "        d_losses = []\n",
    "        g_losses = []\n",
    "        \n",
    "        for epoch in range(EPOCH, EPOCHS):        \n",
    "            epoch += 1\n",
    "            epoch_dataset = DATASET.copy()\n",
    "            \n",
    "            for i in range(MINIBATCH_SIZE):\n",
    "                iteration_start_time = time.time()\n",
    "                iteration += 1\n",
    "                batch_images, used_files = get_batch(epoch_dataset)\n",
    "                [epoch_dataset.remove(file) for file in used_files]\n",
    "                \n",
    "                batch_z = np.random.uniform(-1, 1, size=(BATCH_SIZE, NOISE_SIZE))\n",
    "                _ = sess.run(d_opt, feed_dict={input_images: batch_images, input_z: batch_z, lr_D: LR_D})\n",
    "                _ = sess.run(g_opt, feed_dict={input_images: batch_images, input_z: batch_z, lr_G: LR_G})\n",
    "                d_losses.append(d_loss.eval({input_z: batch_z, input_images: batch_images}))\n",
    "                g_losses.append(g_loss.eval({input_z: batch_z}))\n",
    "                \n",
    "                elapsed_time = round(time.time()-iteration_start_time, 3)\n",
    "                remaining_files = len(epoch_dataset)\n",
    "                print(\"\\rEpoch: \" + str(epoch) +\n",
    "                      \", iteration: \" + str(iteration) + \n",
    "                      \", d_loss: \" + str(round(d_losses[-1], 3)) +\n",
    "                      \", g_loss: \" + str(round(g_losses[-1], 3)) +\n",
    "                      \", duration: \" + str(elapsed_time) + \n",
    "                      \", minutes remaining: \" + str(round(remaining_files/BATCH_SIZE*elapsed_time/60, 1)) +\n",
    "                      \", remaining files in batch: \" + str(remaining_files)\n",
    "                      , sep=' ', end=' ', flush=True)\n",
    "                \n",
    "            summarize_epoch(epoch, sess, d_losses, g_losses, input_z, data_shape, saver)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "f62171dc195cc18db6087c24180487f17f6035e7",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 674
    },
    "colab_type": "code",
    "id": "_4GB3G-D-Key",
    "outputId": "0e702c85-d086-4750-caee-1ac3ed6564e2"
   },
   "outputs": [],
   "source": [
    "# Hyperparameters\n",
    "IMAGE_SIZE = 128\n",
    "NOISE_SIZE = 100\n",
    "LR_D = 0.00004\n",
    "LR_G = 0.0002\n",
    "BATCH_SIZE = 64\n",
    "EPOCH = 0 # Non-zero only if we are resuming training with model checkpoint\n",
    "EPOCHS = 5 #EPOCH + number of epochs to perform\n",
    "BETA1 = 0.5\n",
    "WEIGHT_INIT_STDDEV = 0.02\n",
    "EPSILON = 0.00005\n",
    "SAMPLES_TO_SHOW = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "44d5d6dff4acd1cd52fb7157dd293bb711fb4a8d"
   },
   "outputs": [],
   "source": [
    "# Data (https://www.kaggle.com/greg115/celebrities-100k)\n",
    "BASE_PATH = \"../input/\"\n",
    "DATASET_LIST_PATH = BASE_PATH + \"100k.txt\"\n",
    "INPUT_DATA_DIR = BASE_PATH + \"100k/100k/\"\n",
    "OUTPUT_DIR = \"./\"\n",
    "DATASET = [INPUT_DATA_DIR + str(line).rstrip() for line in open(DATASET_LIST_PATH,\"r\")]\n",
    "DATASET_SIZE = len(DATASET) \n",
    "MINIBATCH_SIZE = DATASET_SIZE // BATCH_SIZE\n",
    "\n",
    "# Optional - model path to resume training\n",
    "#MODEL_PATH = BASE_PATH + \"models/\" + \"model_\" + str(EPOCH) + \".ckpt\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_uuid": "334430e166a0ef81a81cb252e375a7250b92eb17",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 946
    },
    "colab_type": "code",
    "id": "LZ8A7ql4-In_",
    "outputId": "a7029f33-c223-4645-b5c4-d9c800732b19"
   },
   "outputs": [],
   "source": [
    "# Training\n",
    "with tf.Graph().as_default():\n",
    "    train(data_shape=(DATASET_SIZE, IMAGE_SIZE, IMAGE_SIZE, 3),\n",
    "          epoch=EPOCH,\n",
    "          checkpoint_path=None)"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "DCGAN-Celebrities.ipynb",
   "provenance": [],
   "version": "0.3.2"
  },
  "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}