fully_convolutional_networks.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1x1 Convolution Quiz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dense Output =\n",
      " [[[[-0.07008168  0.36948475]\n",
      "   [-0.31007883  1.63479805]]\n",
      "\n",
      "  [[-0.16896337  0.89080894]\n",
      "   [-0.13168478  0.69426876]]]] \n",
      "\n",
      "Conv 1x1 Output =\n",
      " [[[[-0.07008168  0.36948475]\n",
      "   [-0.31007883  1.63479805]]\n",
      "\n",
      "  [[-0.16896337  0.89080894]\n",
      "   [-0.13168478  0.69426876]]]] \n",
      "\n",
      "Same output? = True\n"
     ]
    }
   ],
   "source": [
    "# custom init with the seed set to 0 by default \n",
    "def custom_init(shape, dtype=tf.float32, partition_info=None, seed=0): \n",
    "    return tf.random_normal(shape, dtype=dtype, seed=seed) \n",
    " \n",
    "# TODO: Use `tf.layers.conv2d` to reproduce the result of \n",
    "#       `tf.layers.dense`. \n",
    "# Set the `kernel_size` and `stride`. \n",
    "def conv_1x1(x, num_outputs): \n",
    "    kernel_size = 1 \n",
    "    stride = 1 \n",
    "    return tf.layers.conv2d(x, num_outputs, kernel_size, stride, \n",
    "                            kernel_initializer=custom_init) \n",
    "  \n",
    "num_outputs = 2 \n",
    "x = tf.constant(np.random.randn(1, 2, 2, 1), dtype=tf.float32) \n",
    " \n",
    "# `tf.layers.dense` flattens the input tensor if the rank > 2  \n",
    "# and reshapes it back to the original rank as the output. \n",
    "dense_out = tf.layers.dense(x, num_outputs, \n",
    "                            kernel_initializer=custom_init) \n",
    "\n",
    "conv_out = conv_1x1(x, num_outputs) \n",
    " \n",
    "with tf.Session() as sess: \n",
    "    sess.run(tf.global_variables_initializer()) \n",
    "    a = sess.run(dense_out) \n",
    "    b = sess.run(conv_out) \n",
    "    print(\"Dense Output =\\n\", a, \"\\n\") \n",
    "    print(\"Conv 1x1 Output =\\n\", b, \"\\n\") \n",
    "    print(\"Same output? =\", np.allclose(a, b, atol=1.e-5)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Transposed Convolution Quiz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input Shape: (1, 4, 4, 3)\n",
      "Output Shape: (1, 8, 8, 3)\n"
     ]
    }
   ],
   "source": [
    "def upsample(x): \n",
    "    \"\"\" \n",
    "    Apply a two times upsample on x and return the result. \n",
    "    :x: 4-Rank Tensor \n",
    "    :return: TF Operation \n",
    "    \"\"\" \n",
    "    # TODO: Use `tf.layers.conv2d_transpose` \n",
    "    return tf.layers.conv2d_transpose(x, 3, (2, 2), (2, 2)) \n",
    "  \n",
    "x = tf.constant(np.random.randn(1, 4, 4, 3), dtype=tf.float32) \n",
    "conv = upsample(x) \n",
    "  \n",
    "with tf.Session() as sess: \n",
    "    sess.run(tf.global_variables_initializer()) \n",
    "    result = sess.run(conv) \n",
    "    print('Input Shape: {}'.format(x.get_shape())) \n",
    "    print('Output Shape: {}'.format(result.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Intersection over Union (IoU)  Quiz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean IoU = 0.53869\n"
     ]
    }
   ],
   "source": [
    "def mean_iou(ground_truth, prediction, num_classes): \n",
    "    # TODO: Use `tf.metrics.mean_iou` to compute the mean IoU. \n",
    "    iou, iou_op = tf.metrics.mean_iou(ground_truth, \n",
    "                                      prediction, \n",
    "                                      num_classes) \n",
    "    return iou, iou_op \n",
    "  \n",
    "ground_truth = tf.constant([ \n",
    "    [0, 0, 0, 0], \n",
    "    [1, 1, 1, 1], \n",
    "    [2, 2, 2, 2], \n",
    "    [3, 3, 3, 3]], dtype=tf.float32) \n",
    "  \n",
    "prediction = tf.constant([ \n",
    "    [0, 0, 0, 0], \n",
    "    [1, 0, 0, 1], \n",
    "    [1, 2, 2, 1], \n",
    "    [3, 3, 0, 3]], dtype=tf.float32) \n",
    "  \n",
    "# TODO: use `mean_iou` to compute the mean IoU \n",
    "iou, iou_op = mean_iou(ground_truth, prediction, 4) \n",
    "  \n",
    "with tf.Session() as sess: \n",
    "    sess.run(tf.global_variables_initializer()) \n",
    "    # need to initialize local variables for this to run \n",
    "    # `tf.metrics.mean_iou` \n",
    "    sess.run(tf.local_variables_initializer()) \n",
    "  \n",
    "    sess.run(iou_op) \n",
    "    # should be 0.53869 \n",
    "    print(\"Mean IoU =\", sess.run(iou))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}