experiment_bouncingMnistOriginal_tensorflow.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "import tensorflow as tf\n",
    "import sonnet as snt\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import datasets.dataset_bouncingMnistOriginal as dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Hyperparameters\"\"\"\n",
    "batch_size = 16\n",
    "image_size = (64,64,1)\n",
    "num_input_frames = 10\n",
    "num_output_frames = 10\n",
    "dynamic_filter_size = (9,9)\n",
    "num_frames = num_input_frames + num_output_frames\n",
    "num_epochs = 100\n",
    "batches_per_epoch = 200\n",
    "learning_rate = 1e-4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "\"\"\"Setting up the data\"\"\"\n",
    "dh = dataset.DataHandler(num_frames=num_frames, batch_size=batch_size, image_size=image_size[0])\n",
    "def get_batch():\n",
    "    frames = dh.GetBatch() # (batch, c, h, w, frames)\n",
    "    frames = np.transpose(frames, [0,2,3,1,4]) # (batch, h, w, c, frames)\n",
    "    return frames\n",
    "\n",
    "# # Uncomment to show a data sample\n",
    "# frames = get_batch()\n",
    "# print(np.min(frames), np.max(frames))\n",
    "# for i in range(frames.shape[-1]):\n",
    "#     plt.imshow(frames[0,:,:,0,i], cmap=\"gray\")\n",
    "#     plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "\"\"\"Defining the model (using a Sonnet module)\"\"\"\n",
    "class Model(snt.AbstractModule):\n",
    "    def __init__(self, filter_size=(9,9), name=\"model\"):\n",
    "        super(Model, self).__init__(name=name)\n",
    "        self._filter_size = filter_size\n",
    "        self._refinement_network = False\n",
    "        self._dynamic_bias = False\n",
    "    \n",
    "    def _build(self, input_frames):\n",
    "        hidden_state = tf.zeros((batch_size, image_size[0]/2, image_size[1]/2, 128))\n",
    "        input_frames = tf.unstack(input_frames, axis=-1)\n",
    "        output_frames = []\n",
    "        for i in range(num_input_frames + num_output_frames - 1):\n",
    "            if i < num_input_frames:\n",
    "                input_frame = input_frames[i]\n",
    "            else:\n",
    "                input_frame = prediction\n",
    "            prediction, hidden_state = self._predict(input_frame, hidden_state)\n",
    "            \n",
    "            if i >= num_input_frames - 1:\n",
    "                output_frames.append(prediction)\n",
    "        return tf.stack(output_frames, -1)\n",
    "            \n",
    "    def _predict(self, input_frame, hidden_state):\n",
    "        with tf.variable_scope(\"forward_net\", reuse=tf.AUTO_REUSE):\n",
    "            ###############################\n",
    "            #  filter-generating network  #\n",
    "            ###############################\n",
    "            ## encoder\n",
    "            output = tf.layers.conv2d(input_frame, filters=32, kernel_size=[3,3], strides=[1,1], padding=\"same\", activation=tf.nn.leaky_relu)\n",
    "            output = tf.layers.conv2d(output, filters=32, kernel_size=[3,3], strides=[2,2], padding=\"same\", activation=tf.nn.leaky_relu)\n",
    "            output = tf.layers.conv2d(output, filters=64, kernel_size=[3,3], strides=[1,1], padding=\"same\", activation=tf.nn.leaky_relu)\n",
    "            output = tf.layers.conv2d(output, filters=64, kernel_size=[3,3], strides=[1,1], padding=\"same\", activation=tf.nn.leaky_relu)\n",
    "\n",
    "            ## mid\n",
    "            output = tf.layers.conv2d(output, filters=128, kernel_size=[3,3], strides=[1,1], padding=\"same\", activation=tf.nn.leaky_relu)\n",
    "            \n",
    "            hidden = tf.layers.conv2d(hidden_state, filters=128, kernel_size=[3,3], strides=[1,1], padding=\"same\", activation=tf.nn.leaky_relu)\n",
    "            hidden = tf.layers.conv2d(hidden, filters=128, kernel_size=[3,3], strides=[1,1], padding=\"same\", activation=tf.nn.leaky_relu)\n",
    "            output = output + hidden\n",
    "            hidden_state = output\n",
    "\n",
    "            ## decoder\n",
    "            output = tf.layers.conv2d(output, filters=64, kernel_size=[3,3], strides=[1,1], padding=\"same\", activation=tf.nn.leaky_relu)\n",
    "            output = tf.layers.conv2d(output, filters=64, kernel_size=[3,3], strides=[1,1], padding=\"same\", activation=tf.nn.leaky_relu)\n",
    "            output = tf.image.resize_nearest_neighbor(output, size=(2*output.get_shape()[1].value, 2*output.get_shape()[2].value), align_corners=False)\n",
    "            output = tf.layers.conv2d(output, filters=64, kernel_size=[3,3], strides=[1,1], padding=\"same\", activation=tf.nn.leaky_relu)\n",
    "            output = tf.layers.conv2d(output, filters=64, kernel_size=[3,3], strides=[1,1], padding=\"same\", activation=tf.nn.leaky_relu)\n",
    "\n",
    "            output = tf.layers.conv2d(output, filters=128, kernel_size=[1,1], strides=[1,1], padding=\"same\", activation=tf.nn.leaky_relu)\n",
    "\n",
    "            dynamic_filters = tf.layers.conv2d(output, filters=self._filter_size[0]*self._filter_size[1], kernel_size=[1,1], padding=\"same\")\n",
    "            dynamic_filters = tf.nn.softmax(dynamic_filters, axis=-1)\n",
    "\n",
    "            if self._dynamic_bias:\n",
    "                dynamic_bias = tf.layers.conv2d(output, filters=1, kernel_size=[1,1], padding=\"same\")\n",
    "            else:\n",
    "                dynamic_bias = 0\n",
    "\n",
    "            #########################\n",
    "            #  transformer network  #\n",
    "            #########################\n",
    "            input_frame_transformed = tf.extract_image_patches(\n",
    "                input_frame + dynamic_bias, [1, self._filter_size[0], self._filter_size[1], 1],\n",
    "                strides=[1,1,1,1], rates=[1,1,1,1], padding=\"SAME\")\n",
    "\n",
    "            output_dynconv = tf.reduce_sum(dynamic_filters * input_frame_transformed, -1, keepdims=True)\n",
    "\n",
    "            ########################\n",
    "            #  refinement network  #\n",
    "            ########################\n",
    "            if self._refinement_network:\n",
    "                raise NotImplementedError\n",
    "            else:\n",
    "                output = output_dynconv\n",
    "\n",
    "            prediction = output\n",
    "        return prediction, hidden_state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_number_of_variables():\n",
    "    total_parameters = 0\n",
    "    for variable in tf.trainable_variables():\n",
    "        shape = variable.get_shape()\n",
    "        variable_parameters = 1\n",
    "        for dim in shape:\n",
    "            variable_parameters *= dim.value\n",
    "        total_parameters += variable_parameters\n",
    "    return total_parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of trainable variables: 637361\n",
      "step 0: 0.188147425652\n",
      "step 200: 0.172864109278\n",
      "step 400: 0.148750826716\n",
      "step 600: 0.14619037509\n",
      "step 800: 0.14079734683\n",
      "step 1000: 0.132678329945\n",
      "step 1200: 0.13169375062\n",
      "step 1400: 0.123050458729\n",
      "step 1600: 0.138654798269\n",
      "step 1800: 0.108268171549\n",
      "step 2000: 0.108702003956\n",
      "step 2200: 0.119791224599\n",
      "step 2400: 0.100986845791\n",
      "step 2600: 0.124250985682\n",
      "step 2800: 0.113862849772\n",
      "step 3000: 0.108988255262\n",
      "step 3200: 0.111163198948\n",
      "step 3400: 0.115988686681\n",
      "step 3600: 0.111781135201\n",
      "step 3800: 0.10149051249\n",
      "step 4000: 0.10397644341\n",
      "step 4200: 0.102068722248\n",
      "step 4400: 0.100963830948\n",
      "step 4600: 0.0994943231344\n",
      "step 4800: 0.0927717983723\n",
      "step 5000: 0.105177082121\n",
      "step 5200: 0.0996600389481\n",
      "step 5400: 0.0961814671755\n",
      "step 5600: 0.102031096816\n",
      "step 5800: 0.0958395004272\n",
      "step 6000: 0.0930742844939\n",
      "step 6200: 0.0952256992459\n",
      "step 6400: 0.0907455682755\n",
      "step 6600: 0.0954805538058\n",
      "step 6800: 0.0977541208267\n",
      "step 7000: 0.0859362185001\n",
      "step 7200: 0.100127443671\n",
      "step 7400: 0.0826132521033\n",
      "step 7600: 0.0892592668533\n",
      "step 7800: 0.0790208280087\n",
      "step 8000: 0.0843544453382\n",
      "step 8200: 0.087178170681\n",
      "step 8400: 0.0872898101807\n",
      "step 8600: 0.0970190018415\n",
      "step 8800: 0.0826547071338\n",
      "step 9000: 0.100375920534\n",
      "step 9200: 0.0932356417179\n",
      "step 9400: 0.0857145786285\n",
      "step 9600: 0.08726811409\n",
      "step 9800: 0.0862513184547\n",
      "step 10000: 0.0893311351538\n",
      "step 10200: 0.0832550600171\n",
      "step 10400: 0.0886023715138\n",
      "step 10600: 0.077807366848\n",
      "step 10800: 0.079680070281\n",
      "step 11000: 0.0838633030653\n",
      "step 11200: 0.0870060622692\n",
      "step 11400: 0.0838550999761\n",
      "step 11600: 0.0781540721655\n",
      "step 11800: 0.0858708769083\n",
      "step 12000: 0.0737644657493\n",
      "step 12200: 0.084895953536\n",
      "step 12400: 0.0828903615475\n",
      "step 12600: 0.0784460827708\n",
      "step 12800: 0.0835370570421\n",
      "step 13000: 0.0835139155388\n",
      "step 13200: 0.0897642374039\n",
      "step 13400: 0.0825219154358\n",
      "step 13600: 0.0787909328938\n",
      "step 13800: 0.0797055140138\n",
      "step 14000: 0.0738325864077\n",
      "step 14200: 0.0707044675946\n",
      "step 14400: 0.0851129293442\n",
      "step 14600: 0.0843106880784\n",
      "step 14800: 0.0815888121724\n",
      "step 15000: 0.0797896832228\n",
      "step 15200: 0.0870543196797\n",
      "step 15400: 0.0781055092812\n",
      "step 15600: 0.0751888006926\n",
      "step 15800: 0.0769328027964\n",
      "step 16000: 0.0832989364862\n",
      "step 16200: 0.0790105015039\n",
      "step 16400: 0.0785121321678\n",
      "step 16600: 0.0787084624171\n",
      "step 16800: 0.0827111899853\n",
      "step 17000: 0.0757173448801\n",
      "step 17200: 0.0848463326693\n",
      "step 17400: 0.0780518427491\n",
      "step 17600: 0.0703959092498\n",
      "step 17800: 0.0732543617487\n",
      "step 18000: 0.0811257213354\n",
      "step 18200: 0.078071013093\n",
      "step 18400: 0.0800310224295\n",
      "step 18600: 0.0749358832836\n",
      "step 18800: 0.0803201496601\n",
      "step 19000: 0.077392436564\n",
      "step 19200: 0.0737467035651\n",
      "step 19400: 0.0709891319275\n",
      "step 19600: 0.0755176767707\n",
      "step 19800: 0.0813283771276\n"
     ]
    }
   ],
   "source": [
    "tf.reset_default_graph()\n",
    "\n",
    "# Set up placeholders\n",
    "input_frames = tf.placeholder(tf.float32, shape=(batch_size,) + image_size + (num_input_frames,))\n",
    "output_frames = tf.placeholder(tf.float32, shape=(batch_size,) + image_size + (num_output_frames,))\n",
    "\n",
    "# Initialize the model\n",
    "model = Model(filter_size=dynamic_filter_size)\n",
    "predictions = model(input_frames)\n",
    "\n",
    "# Clip the predictions to lie in [0+eps,1-eps], so they can be fed to the bce loss function.\n",
    "predictions = tf.clip_by_value(predictions, np.finfo(np.float32).eps, 1-np.finfo(np.float32).eps)\n",
    "\n",
    "# Binary cross-entropy loss function\n",
    "bce = -output_frames*tf.log(predictions) - (1-output_frames)*tf.log(1-predictions)\n",
    "frame_loss = tf.reduce_mean(bce, [1,2,3])\n",
    "batch_loss = tf.reduce_mean(frame_loss, -1)\n",
    "loss = tf.reduce_mean(batch_loss, 0)\n",
    "\n",
    "# Setting up the optimizer\n",
    "optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)\n",
    "train_step = optimizer.minimize(loss)\n",
    "\n",
    "# Main training loop\n",
    "print(\"Number of trainable variables: {}\".format(get_number_of_variables()))\n",
    "with tf.Session() as sess:\n",
    "    init = tf.global_variables_initializer()\n",
    "    sess.run(init)\n",
    "\n",
    "    for step in range(num_epochs*batches_per_epoch):\n",
    "        frames = get_batch()\n",
    "        _, loss_, predictions_, output_frames_ = sess.run([train_step, loss, predictions, output_frames], \n",
    "                            feed_dict={input_frames: frames[:,:,:,:,:num_input_frames],\n",
    "                                       output_frames: frames[:,:,:,:,num_input_frames:]})\n",
    "        if step % batches_per_epoch == 0:\n",
    "            print(\"step {}: {}\".format(step, loss_))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f10f7049fd0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f10eda767d0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\"\"\"Visualize a result.\"\"\"\n",
    "plt.rcParams['figure.figsize'] = (20.0, 10.0)\n",
    "\n",
    "batch_num = 0\n",
    "\n",
    "for i in range(num_output_frames):\n",
    "    plt.subplot(1,num_output_frames,i+1)\n",
    "    plt.imshow(predictions_[batch_num,:,:,0,i], cmap=\"gray\")\n",
    "    plt.axis(\"off\")\n",
    "plt.show()\n",
    "\n",
    "for i in range(num_output_frames):\n",
    "    plt.subplot(1,num_output_frames,i+1)\n",
    "    plt.imshow(output_frames_[batch_num,:,:,0,i], cmap=\"gray\")\n",
    "    plt.axis(\"off\")\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "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.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}