Full Code of lexfridman/mit-deep-learning for AI

Repository: lexfridman/mit-deep-learning
Branch: master
Commit: c5cc240d3482
Files: 10
Total size: 1.7 MB

Directory structure:
gitextract_cpu21i3y/

├── LICENSE.md
├── README.md
├── tutorial_deep_learning_basics/
│   └── deep_learning_basics.ipynb
├── tutorial_driving_scene_segmentation/
│   └── tutorial_driving_scene_segmentation.ipynb
├── tutorial_gans/
│   └── tutorial_gans.ipynb
└── tutorials_previous/
    ├── 1_python_perceptron.ipynb
    ├── 2_tensorflow_intro.ipynb
    ├── 3_tensorflow_simple_neural_network.ipynb
    ├── 4_tensorflow_mnist.ipynb
    └── 5_tensorflow_traffic_light_classification.ipynb

================================================
FILE CONTENTS
================================================

================================================
FILE: LICENSE.md
================================================
MIT License

Copyright (c) 2019 Lex Fridman

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.


================================================
FILE: README.md
================================================
# MIT Deep Learning

<a href="https://deeplearning.mit.edu/"><img src="https://deeplearning.mit.edu/files/images/mit_deep_learning.png"></a>

This repository is a collection of tutorials for [MIT Deep Learning](https://deeplearning.mit.edu/) courses. More added as courses progress.

## Tutorial: Deep Learning Basics

<a href="https://github.com/lexfridman/mit-deep-learning/blob/master/tutorial_deep_learning_basics/deep_learning_basics.ipynb"><img src="https://i.imgur.com/j4FqBuR.gif"></a>

This tutorial accompanies the [lecture on Deep Learning Basics](https://www.youtube.com/watch?list=PLrAXtmErZgOeiKm4sgNOknGvNjby9efdf&v=O5xeyoRL95U). It presents several concepts in deep learning, demonstrating the first two (feed forward and convolutional neural networks) and providing pointers to tutorials on the others. This is a good place to start.

Links: \[ [Jupyter Notebook](https://github.com/lexfridman/mit-deep-learning/blob/master/tutorial_deep_learning_basics/deep_learning_basics.ipynb) \]
\[ [Google Colab](https://colab.research.google.com/github/lexfridman/mit-deep-learning/blob/master/tutorial_deep_learning_basics/deep_learning_basics.ipynb) \]
\[ [Blog Post](https://medium.com/tensorflow/mit-deep-learning-basics-introduction-and-overview-with-tensorflow-355bcd26baf0) \]
\[ [Lecture Video](https://www.youtube.com/watch?list=PLrAXtmErZgOeiKm4sgNOknGvNjby9efdf&v=O5xeyoRL95U) \]


## Tutorial: Driving Scene Segmentation

<a href="https://github.com/lexfridman/mit-deep-learning/blob/master/tutorial_driving_scene_segmentation/tutorial_driving_scene_segmentation.ipynb"><img src="images/thumb_driving_scene_segmentation.gif"></a>

This tutorial demostrates semantic segmentation with a state-of-the-art model (DeepLab) on a sample video from the MIT Driving Scene Segmentation Dataset.

Links: \[ [Jupyter Notebook](https://github.com/lexfridman/mit-deep-learning/blob/master/tutorial_driving_scene_segmentation/tutorial_driving_scene_segmentation.ipynb) \]
\[ [Google Colab](https://colab.research.google.com/github/lexfridman/mit-deep-learning/blob/master/tutorial_driving_scene_segmentation/tutorial_driving_scene_segmentation.ipynb) \]

## Tutorial: Generative Adversarial Networks (GANs)

<a href="https://github.com/lexfridman/mit-deep-learning/blob/master/tutorial_gans/tutorial_gans.ipynb"><img src="images/thumb_mushroom_biggan.gif"></a>

This tutorial explores generative adversarial networks (GANs) starting with BigGAN, the state-of-the-art conditional GAN.

Links: \[ [Jupyter Notebook](https://github.com/lexfridman/mit-deep-learning/blob/master/tutorial_gans/tutorial_gans.ipynb) \]
\[ [Google Colab](https://colab.research.google.com/github/lexfridman/mit-deep-learning/blob/master/tutorial_gans/tutorial_gans.ipynb) \]

## DeepTraffic Deep Reinforcement Learning Competition

<a href="https://selfdrivingcars.mit.edu/deeptraffic"><img src="images/thumb_deeptraffic.gif"></a>

DeepTraffic is a deep reinforcement learning competition. The goal is to create a neural network that drives a vehicle (or multiple vehicles) as fast as possible through dense highway traffic.

Links: \[ [GitHub](https://github.com/lexfridman/deeptraffic) \] \[ [Website](https://selfdrivingcars.mit.edu/deeptraffic) \] \[ [Paper](https://arxiv.org/abs/1801.02805) \]

## Team

- [Lex Fridman](https://lexfridman.com)
- [Li Ding](https://www.mit.edu/~liding/)
- [Jack Terwilliger](https://www.mit.edu/~jterwill/)
- [Michael Glazer](https://www.mit.edu/~glazermi/)
- [Aleksandr Patsekin](https://www.mit.edu/~patsekin/)
- [Aishni Parab](https://www.mit.edu/~aishni/)
- [Dina AlAdawy](https://www.mit.edu/~aladawy/)
- [Henri Schmidt](https://www.mit.edu/~henris/)


================================================
FILE: tutorial_deep_learning_basics/deep_learning_basics.ipynb
================================================
{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![MIT Deep Learning](https://deeplearning.mit.edu/files/images/github/mit_deep_learning.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": ""
   },
   "source": [
    "<table align=\"center\">\n",
    "  <td align=\"center\"><a target=\"_blank\" href=\"https://deeplearning.mit.edu\">\n",
    "        <img src=\"https://deeplearning.mit.edu/files/images/github/icon_mit.png\" style=\"padding-bottom:5px;\" />\n",
    "      Visit MIT Deep Learning</a></td>\n",
    "  <td align=\"center\"><a target=\"_blank\" href=\"http://colab.research.google.com/github/lexfridman/mit-deep-learning/blob/master/tutorial_deep_learning_basics/deep_learning_basics.ipynb\">\n",
    "        <img src=\"https://deeplearning.mit.edu/files/images/github/icon_google_colab.png\" style=\"padding-bottom:5px;\" />Run in Google Colab</a></td>\n",
    "  <td align=\"center\"><a target=\"_blank\" href=\"https://github.com/lexfridman/mit-deep-learning/blob/master/tutorial_deep_learning_basics/deep_learning_basics.ipynb\">\n",
    "        <img src=\"https://deeplearning.mit.edu/files/images/github/icon_github.png\" style=\"padding-bottom:5px;\"  />View Source on GitHub</a></td>\n",
    "  <td align=\"center\"><a target=\"_blank\" align=\"center\" href=\"https://www.youtube.com/watch?v=O5xeyoRL95U&list=PLrAXtmErZgOeiKm4sgNOknGvNjby9efdf\">\n",
    "        <img src=\"https://deeplearning.mit.edu/files/images/github/icon_youtube.png\" style=\"padding-bottom:5px;\" />Watch YouTube Videos</a></td>\n",
    "<!--   <td><a target=\"_blank\" href=\"link\">\n",
    "        <img src=\"image\" />text</a></td> -->\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": ""
   },
   "source": [
    "# Deep Learning Basics\n",
    "\n",
    "This tutorial accompanies the [lecture on Deep Learning Basics](https://www.youtube.com/watch?list=PLrAXtmErZgOeiKm4sgNOknGvNjby9efdf&v=O5xeyoRL95U) given as part of [MIT Deep Learning](https://deeplearning.mit.edu). Acknowledgement to amazing people involved is provided throughout the tutorial and at the end. You can watch the video on YouTube:\n",
    "\n",
    "[![Deep Learning Basics](https://i.imgur.com/FfQVV8q.png)](https://www.youtube.com/watch?list=PLrAXtmErZgOeiKm4sgNOknGvNjby9efdf&v=O5xeyoRL95U)\n",
    "\n",
    "In this tutorial, we mention seven important types/concepts/approaches in deep learning, introducing the first 2 and providing pointers to tutorials on the others. Here is a visual representation of the seven:\n",
    "\n",
    "![Deep learning concepts](https://i.imgur.com/EAl47rp.png)\n",
    "\n",
    "At a high-level, neural networks are either encoders, decoders, or a combination of both. Encoders find patterns in raw data to form compact, useful representations. Decoders generate new data or high-resolution useful infomation from those representations. As the lecture describes, deep learning discovers ways to **represent** the world so that we can reason about it. The rest is clever methods that help use deal effectively with visual information, language, sound (#1-6) and even act in a world based on this information and occasional rewards (#7).\n",
    "\n",
    "1. **Feed Forward Neural Networks (FFNNs)** - classification and regression based on features. See [Part 1](#Part-1:-Boston-Housing-Price-Prediction-with-Feed-Forward-Neural-Networks) of this tutorial for an example.\n",
    "2. **Convolutional Neural Networks (CNNs)** - image classification, object detection, video action recognition, etc. See [Part 2](#Part-2:-Classification-of-MNIST-Dreams-with-Convolution-Neural-Networks) of this tutorial for an example.\n",
    "3. **Recurrent Neural Networks (RNNs)** - language modeling, speech recognition/generation, etc. See [this TF tutorial on text generation](https://www.tensorflow.org/tutorials/sequences/text_generation) for an example.\n",
    "4. **Encoder Decoder Architectures** - semantic segmentation, machine translation, etc. See [our tutorial on semantic segmentation](https://github.com/lexfridman/mit-deep-learning/blob/master/tutorial_driving_scene_segmentation/tutorial_driving_scene_segmentation.ipynb) for an example.\n",
    "5. **Autoencoder** - unsupervised embeddings, denoising, etc.\n",
    "6. **Generative Adversarial Networks (GANs)** - unsupervised generation of realistic images, etc. See [this TF tutorial on DCGANs](https://github.com/tensorflow/tensorflow/blob/r1.11/tensorflow/contrib/eager/python/examples/generative_examples/dcgan.ipynb) for an example.\n",
    "7. **Deep Reinforcement Learning** - game playing, robotics in simulation, self-play, neural arhitecture search, etc. We'll be releasing notebooks on this soon and will link them here.\n",
    "\n",
    "There are selective omissions and simplifications throughout these tutorials, hopefully without losing the essence of the underlying ideas. See Einstein quote..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 0: Prerequisites:\n",
    "\n",
    "We recommend that you run this this notebook in the cloud on Google Colab (see link with icon at the top) if you're not already doing so. It's the simplest way to get started. You can also [install TensorFlow locally](https://www.tensorflow.org/install/). But, again, simple is best (with caveats):\n",
    "\n",
    "![Einstein](https://i.imgur.com/vfPDHGN.png)\n",
    "\n",
    "[tf.keras](https://www.tensorflow.org/guide/keras) is the simplest way to build and train neural network models in TensorFlow. So, that's what we'll stick with in this tutorial, unless the models neccessitate a lower-level API.\n",
    "\n",
    "Note that there's [tf.keras](https://www.tensorflow.org/guide/keras) (comes with TensorFlow) and there's [Keras](https://keras.io/) (standalone). You should be using [tf.keras](https://www.tensorflow.org/guide/keras) because (1) it comes with TensorFlow so you don't need to install anything extra and (2) it comes with powerful TensorFlow-specific features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": ""
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.12.0\n"
     ]
    }
   ],
   "source": [
    "# TensorFlow and tf.keras\n",
    "import tensorflow as tf\n",
    "from tensorflow import keras\n",
    "from tensorflow.keras.layers import Conv2D, MaxPooling2D, Dropout, Flatten, Dense\n",
    "\n",
    "# Commonly used modules\n",
    "import numpy as np\n",
    "import os\n",
    "import sys\n",
    "\n",
    "# Images, plots, display, and visualization\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import cv2\n",
    "import IPython\n",
    "from six.moves import urllib\n",
    "\n",
    "print(tf.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 1: Boston Housing Price Prediction with Feed Forward Neural Networks\n",
    "\n",
    "Let's start with using a fully-connected neural network to do predict housing prices. The following image highlights the difference between regression and classification (see part 2). Given an observation as input, **regression** outputs a continuous value (e.g., exact temperature) and classificaiton outputs a class/category that the observation belongs to.\n",
    "\n",
    "<img src=\"https://i.imgur.com/vvSoAzg.jpg\" alt=\"classification_regression\" width=\"400\"/>\n",
    "\n",
    "For the Boston housing dataset, we get 506 rows of data, with 13 features in each. Our task is to build a regression model that takes these 13 features as input and output a single value prediction of the \"median value of owner-occupied homes (in $1000).\"\n",
    "\n",
    "Now, we load the dataset. Loading the dataset returns four NumPy arrays:\n",
    "\n",
    "* The `train_images` and `train_labels` arrays are the *training set*—the data the model uses to learn.\n",
    "* The model is tested against the *test set*, the `test_images`, and `test_labels` arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "(train_features, train_labels), (test_features, test_labels) = keras.datasets.boston_housing.load_data()\n",
    "\n",
    "# get per-feature statistics (mean, standard deviation) from the training set to normalize by\n",
    "train_mean = np.mean(train_features, axis=0)\n",
    "train_std = np.std(train_features, axis=0)\n",
    "train_features = (train_features - train_mean) / train_std"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": ""
   },
   "source": [
    "### Build the model\n",
    "\n",
    "Building the neural network requires configuring the layers of the model, then compiling the model. First we stack a few layers together using `keras.Sequential`. Next we configure the loss function, optimizer, and metrics to monitor. These are added during the model's compile step:\n",
    "\n",
    "* *Loss function* - measures how accurate the model is during training, we want to minimize this with the optimizer.\n",
    "* *Optimizer* - how the model is updated based on the data it sees and its loss function.\n",
    "* *Metrics* - used to monitor the training and testing steps.\n",
    "\n",
    "Let's build a network with 1 hidden layer of 20 neurons, and use mean squared error (MSE) as the loss function (most common one for regression problems):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": ""
   },
   "outputs": [],
   "source": [
    "def build_model():\n",
    "    model = keras.Sequential([\n",
    "        Dense(20, activation=tf.nn.relu, input_shape=[len(train_features[0])]),\n",
    "        Dense(1)\n",
    "    ])\n",
    "\n",
    "    model.compile(optimizer=tf.train.AdamOptimizer(), \n",
    "                  loss='mse',\n",
    "                  metrics=['mae', 'mse'])\n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": ""
   },
   "source": [
    "### Train the model\n",
    "\n",
    "Training the neural network model requires the following steps:\n",
    "\n",
    "1. Feed the training data to the model—in this example, the `train_features` and `train_labels` arrays.\n",
    "2. The model learns to associate features and labels.\n",
    "3. We ask the model to make predictions about a test set—in this example, the `test_features` array. We verify that the predictions match the labels from the `test_labels` array. \n",
    "\n",
    "To start training,  call the `model.fit` method—the model is \"fit\" to the training data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": ""
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "....................................................................................................\n",
      "....................................................................................................\n",
      "....................................................................................................\n",
      "....................................................................................................\n",
      "....................................................................................................\n",
      "....................................................................................................\n",
      "....................................................................................................\n",
      ".............................................................................................\n",
      "Final Root Mean Square Error on validation set: 2.359\n"
     ]
    }
   ],
   "source": [
    "# this helps makes our output less verbose but still shows progress\n",
    "class PrintDot(keras.callbacks.Callback):\n",
    "    def on_epoch_end(self, epoch, logs):\n",
    "        if epoch % 100 == 0: print('')\n",
    "        print('.', end='')\n",
    "\n",
    "model = build_model()\n",
    "\n",
    "early_stop = keras.callbacks.EarlyStopping(monitor='val_loss', patience=50)\n",
    "history = model.fit(train_features, train_labels, epochs=1000, verbose=0, validation_split = 0.1,\n",
    "                    callbacks=[early_stop, PrintDot()])\n",
    "\n",
    "hist = pd.DataFrame(history.history)\n",
    "hist['epoch'] = history.epoch\n",
    "\n",
    "# show RMSE measure to compare to Kaggle leaderboard on https://www.kaggle.com/c/boston-housing/leaderboard\n",
    "rmse_final = np.sqrt(float(hist['val_mean_squared_error'].tail(1)))\n",
    "print()\n",
    "print('Final Root Mean Square Error on validation set: {}'.format(round(rmse_final, 3)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's plot the loss function measure on the training and validation sets. The validation set is used to prevent overfitting ([learn more about it here](https://www.tensorflow.org/tutorials/keras/overfit_and_underfit)). However, because our network is small, the training convergence without noticeably overfitting the data as the plot shows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_history():\n",
    "    plt.figure()\n",
    "    plt.xlabel('Epoch')\n",
    "    plt.ylabel('Mean Square Error [Thousand Dollars$^2$]')\n",
    "    plt.plot(hist['epoch'], hist['mean_squared_error'], label='Train Error')\n",
    "    plt.plot(hist['epoch'], hist['val_mean_squared_error'], label = 'Val Error')\n",
    "    plt.legend()\n",
    "    plt.ylim([0,50])\n",
    "\n",
    "plot_history()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": ""
   },
   "source": [
    "Next, compare how the model performs on the test dataset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": ""
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "102/102 [==============================] - 0s 44us/step\n",
      "Root Mean Square Error on test set: 4.244\n"
     ]
    }
   ],
   "source": [
    "test_features_norm = (test_features - train_mean) / train_std\n",
    "mse, _, _ = model.evaluate(test_features_norm, test_labels)\n",
    "rmse = np.sqrt(mse)\n",
    "print('Root Mean Square Error on test set: {}'.format(round(rmse, 3)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": ""
   },
   "source": [
    "Compare the RMSE measure you get to the [Kaggle leaderboard](https://www.kaggle.com/c/boston-housing/leaderboard). An RMSE of 2.651 puts us in 5th place."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 2: Classification of MNIST Dreams with Convolutional Neural Networks\n",
    "\n",
    "Next, let's build a convolutional neural network (CNN) classifier to classify images of handwritten digits in the MNIST dataset with a twist where we test our classifier on high-resolution hand-written digits from outside the dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set common constants\n",
    "this_repo_url = 'https://github.com/lexfridman/mit-deep-learning/raw/master/'\n",
    "this_tutorial_url = this_repo_url + 'tutorial_deep_learning_basics'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": ""
   },
   "source": [
    "The MNIST dataset containss 70,000 grayscale images of handwritten digits at a resolution of 28 by 28 pixels. The task is to take one of these images as input and predict the most likely digit contained in the image (along with a relative confidence in this prediction):\n",
    "\n",
    "<img src=\"https://i.imgur.com/ITrm9x4.png\" width=\"500px\">\n",
    "\n",
    "Now, we load the dataset. The images are 28x28 NumPy arrays, with pixel values ranging between 0 and 255. The *labels* are an array of integers, ranging from 0 to 9."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": ""
   },
   "outputs": [],
   "source": [
    "(train_images, train_labels), (test_images, test_labels) = keras.datasets.mnist.load_data()\n",
    "\n",
    "# reshape images to specify that it's a single channel\n",
    "train_images = train_images.reshape(train_images.shape[0], 28, 28, 1)\n",
    "test_images = test_images.reshape(test_images.shape[0], 28, 28, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": ""
   },
   "source": [
    "We scale these values to a range of 0 to 1 before feeding to the neural network model. For this, we divide the values by 255. It's important that the *training set* and the *testing set* are preprocessed in the same way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": ""
   },
   "outputs": [],
   "source": [
    "def preprocess_images(imgs): # should work for both a single image and multiple images\n",
    "    sample_img = imgs if len(imgs.shape) == 2 else imgs[0]\n",
    "    assert sample_img.shape in [(28, 28, 1), (28, 28)], sample_img.shape # make sure images are 28x28 and single-channel (grayscale)\n",
    "    return imgs / 255.0\n",
    "\n",
    "train_images = preprocess_images(train_images)\n",
    "test_images = preprocess_images(test_images)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": ""
   },
   "source": [
    "Display the first 5 images from the *training set* and display the class name below each image. Verify that the data is in the correct format and we're ready to build and train the network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": ""
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x144 with 5 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10,2))\n",
    "for i in range(5):\n",
    "    plt.subplot(1,5,i+1)\n",
    "    plt.xticks([])\n",
    "    plt.yticks([])\n",
    "    plt.grid(False)\n",
    "    plt.imshow(train_images[i].reshape(28, 28), cmap=plt.cm.binary)\n",
    "    plt.xlabel(train_labels[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": ""
   },
   "source": [
    "### Build the model\n",
    "\n",
    "Building the neural network requires configuring the layers of the model, then compiling the model. In many cases, this can be reduced to simply stacking together layers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": ""
   },
   "outputs": [],
   "source": [
    "model = keras.Sequential()\n",
    "# 32 convolution filters used each of size 3x3\n",
    "model.add(Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=(28, 28, 1)))\n",
    "# 64 convolution filters used each of size 3x3\n",
    "model.add(Conv2D(64, (3, 3), activation='relu'))\n",
    "# choose the best features via pooling\n",
    "model.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "# randomly turn neurons on and off to improve convergence\n",
    "model.add(Dropout(0.25))\n",
    "# flatten since too many dimensions, we only want a classification output\n",
    "model.add(Flatten())\n",
    "# fully connected to get all relevant data\n",
    "model.add(Dense(128, activation='relu'))\n",
    "# one more dropout\n",
    "model.add(Dropout(0.5))\n",
    "# output a softmax to squash the matrix into output probabilities\n",
    "model.add(Dense(10, activation='softmax'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": ""
   },
   "source": [
    "Before the model is ready for training, it needs a few more settings. These are added during the model's *compile* step:\n",
    "\n",
    "* *Loss function* - measures how accurate the model is during training, we want to minimize this with the optimizer.\n",
    "* *Optimizer* - how the model is updated based on the data it sees and its loss function.\n",
    "* *Metrics* - used to monitor the training and testing steps. \"accuracy\" is the fraction of images that are correctly classified."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": ""
   },
   "outputs": [],
   "source": [
    "model.compile(optimizer=tf.train.AdamOptimizer(), \n",
    "              loss='sparse_categorical_crossentropy',\n",
    "              metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": ""
   },
   "source": [
    "### Train the model\n",
    "\n",
    "Training the neural network model requires the following steps:\n",
    "\n",
    "1. Feed the training data to the model—in this example, the `train_images` and `train_labels` arrays.\n",
    "2. The model learns to associate images and labels.\n",
    "3. We ask the model to make predictions about a test set—in this example, the `test_images` array. We verify that the predictions match the labels from the `test_labels` array. \n",
    "\n",
    "To start training,  call the `model.fit` method—the model is \"fit\" to the training data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": ""
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/5\n",
      "60000/60000 [==============================] - 7s 121us/step - loss: 0.1953 - acc: 0.9410\n",
      "Epoch 2/5\n",
      "60000/60000 [==============================] - 6s 100us/step - loss: 0.0842 - acc: 0.9753\n",
      "Epoch 3/5\n",
      "60000/60000 [==============================] - 6s 96us/step - loss: 0.0642 - acc: 0.9810\n",
      "Epoch 4/5\n",
      "60000/60000 [==============================] - 6s 94us/step - loss: 0.0526 - acc: 0.9835\n",
      "Epoch 5/5\n",
      "60000/60000 [==============================] - 6s 94us/step - loss: 0.0443 - acc: 0.9861\n"
     ]
    }
   ],
   "source": [
    "history = model.fit(train_images, train_labels, epochs=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": ""
   },
   "source": [
    "As the model trains, the loss and accuracy metrics are displayed. This model reaches an accuracy of about 98.68% on the training data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": ""
   },
   "source": [
    "### Evaluate accuracy\n",
    "\n",
    "Next, compare how the model performs on the test dataset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": ""
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10000, 28, 28, 1)\n",
      "10000/10000 [==============================] - 1s 50us/step\n",
      "Test accuracy: 0.9913\n"
     ]
    }
   ],
   "source": [
    "print(test_images.shape)\n",
    "test_loss, test_acc = model.evaluate(test_images, test_labels)\n",
    "\n",
    "print('Test accuracy:', test_acc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": ""
   },
   "source": [
    "Often times, the accuracy on the test dataset is a little less than the accuracy on the training dataset. This gap between training accuracy and test accuracy is an example of *overfitting*. In our case, the accuracy is better at 99.19%! This is, in part, due to successful regularization accomplished with the Dropout layers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": ""
   },
   "source": [
    "### Make predictions\n",
    "\n",
    "With the model trained, we can use it to make predictions about some images. Let's step outside the MNIST dataset for that and go with the beautiful high-resolution images generated by a mixture of CPPN, GAN, VAE. See [great blog post by hardmaru](http://blog.otoro.net/2016/04/01/generating-large-images-from-latent-vectors/) for the source data and a description of how these morphed animations are generated:\n",
    "\n",
    "![MNIST dream](https://i.imgur.com/OrUJs9V.gif)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": ""
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "mnist_dream_path = 'images/mnist_dream.mp4'\n",
    "mnist_prediction_path = 'images/mnist_dream_predicted.mp4'\n",
    "\n",
    "# download the video if running in Colab\n",
    "if not os.path.isfile(mnist_dream_path): \n",
    "    print('downloading the sample video...')\n",
    "    vid_url = this_tutorial_url + '/' + mnist_dream_path\n",
    "    \n",
    "    mnist_dream_path = urllib.request.urlretrieve(vid_url)[0]\n",
    "                                                                                                  \n",
    "def cv2_imshow(img):\n",
    "    ret = cv2.imencode('.png', img)[1].tobytes() \n",
    "    img_ip = IPython.display.Image(data=ret)\n",
    "    IPython.display.display(img_ip)\n",
    "\n",
    "cap = cv2.VideoCapture(mnist_dream_path) \n",
    "vw = None\n",
    "frame = -1 # counter for debugging (mostly), 0-indexed\n",
    "\n",
    "# go through all the frames and run our classifier on the high res MNIST images as they morph from number to number\n",
    "while True: # should 481 frames\n",
    "    frame += 1\n",
    "    ret, img = cap.read()\n",
    "    if not ret: break\n",
    "               \n",
    "    assert img.shape[0] == img.shape[1] # should be a square\n",
    "    if img.shape[0] != 720:\n",
    "        img = cv2.resize(img, (720, 720))\n",
    "       \n",
    "    #preprocess the image for prediction\n",
    "    img_proc = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n",
    "    img_proc = cv2.resize(img_proc, (28, 28))\n",
    "    img_proc = preprocess_images(img_proc)\n",
    "    img_proc = 1 - img_proc # inverse since training dataset is white text with black background\n",
    "\n",
    "    net_in = np.expand_dims(img_proc, axis=0) # expand dimension to specify batch size of 1\n",
    "    net_in = np.expand_dims(net_in, axis=3) # expand dimension to specify number of channels\n",
    "    \n",
    "    preds = model.predict(net_in)[0]\n",
    "    guess = np.argmax(preds)\n",
    "    perc = np.rint(preds * 100).astype(int)\n",
    "    \n",
    "    img = 255 - img\n",
    "    pad_color = 0\n",
    "    img = np.pad(img, ((0,0), (0,1280-720), (0,0)), mode='constant', constant_values=(pad_color))  \n",
    "    \n",
    "    line_type = cv2.LINE_AA\n",
    "    font_face = cv2.FONT_HERSHEY_SIMPLEX\n",
    "    font_scale = 1.3        \n",
    "    thickness = 2\n",
    "    x, y = 740, 60\n",
    "    color = (255, 255, 255)\n",
    "    \n",
    "    text = \"Neural Network Output:\"\n",
    "    cv2.putText(img, text=text, org=(x, y), fontScale=font_scale, fontFace=font_face, thickness=thickness,\n",
    "                    color=color, lineType=line_type)\n",
    "    \n",
    "    text = \"Input:\"\n",
    "    cv2.putText(img, text=text, org=(30, y), fontScale=font_scale, fontFace=font_face, thickness=thickness,\n",
    "                    color=color, lineType=line_type)   \n",
    "        \n",
    "    y = 130\n",
    "    for i, p in enumerate(perc):\n",
    "        if i == guess: color = (255, 218, 158)\n",
    "        else: color = (100, 100, 100)\n",
    "            \n",
    "        rect_width = 0\n",
    "        if p > 0: rect_width = int(p * 3.3)\n",
    "        \n",
    "        rect_start = 180\n",
    "        cv2.rectangle(img, (x+rect_start, y-5), (x+rect_start+rect_width, y-20), color, -1)\n",
    "\n",
    "        text = '{}: {:>3}%'.format(i, int(p))\n",
    "        cv2.putText(img, text=text, org=(x, y), fontScale=font_scale, fontFace=font_face, thickness=thickness,\n",
    "                    color=color, lineType=line_type)\n",
    "        y += 60\n",
    "    \n",
    "    # if you don't want to save the output as a video, set this to False\n",
    "    save_video = True\n",
    "    \n",
    "    if save_video:\n",
    "        if vw is None:\n",
    "            codec = cv2.VideoWriter_fourcc(*'DIVX')\n",
    "            vid_width_height = img.shape[1], img.shape[0]\n",
    "            vw = cv2.VideoWriter(mnist_prediction_path, codec, 30, vid_width_height)\n",
    "        # 15 fps above doesn't work robustly so we right frame twice at 30 fps\n",
    "        vw.write(img)\n",
    "        vw.write(img)\n",
    "    \n",
    "    # scale down image for display\n",
    "    img_disp = cv2.resize(img, (0,0), fx=0.5, fy=0.5)\n",
    "    cv2_imshow(img_disp)\n",
    "    IPython.display.clear_output(wait=True)\n",
    "        \n",
    "cap.release()\n",
    "if vw is not None:\n",
    "    vw.release()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": ""
   },
   "source": [
    "The above shows the prediction of the network by choosing the neuron with the highest output. While the output layer values add 1 to one, these do not reflect well-calibrated measures of \"uncertainty\". Often, the network is overly confident about the top choice that does not reflect a learned measure of probability. If everything ran correctly you should get an animation like this:\n",
    "\n",
    "![MNIST dream predictions](https://i.imgur.com/eMF9FOG.gif)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Acknowledgements\n",
    "\n",
    "The contents of this tutorial is based on and inspired by the work of [TensorFlow team](https://www.tensorflow.org) (see their [Colab notebooks](https://www.tensorflow.org/tutorials/)), our [MIT Human-Centered AI team](https://hcai.mit.edu), and individual pieces referenced in the [MIT Deep Learning](https://deeplearning.mit.edu) course slides."
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "tutorial_deep_learning_basics.ipynb",
   "provenance": [],
   "toc_visible": true,
   "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}


================================================
FILE: tutorial_driving_scene_segmentation/tutorial_driving_scene_segmentation.ipynb
================================================
{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "dvefM1LtKLST"
   },
   "source": [
    "![MIT Deep Learning](https://deeplearning.mit.edu/files/images/github/mit_deep_learning.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Mv9KQHwAKLSV"
   },
   "source": [
    "<table align=\"center\">\n",
    "  <td align=\"center\"><a target=\"_blank\" href=\"https://deeplearning.mit.edu\">\n",
    "        <img src=\"https://deeplearning.mit.edu/files/images/github/icon_mit.png\" style=\"height:40px; padding-bottom:5px;\" />\n",
    "      Visit MIT Deep Learning</a></td>\n",
    "  <td align=\"center\"><a target=\"_blank\" href=\"https://colab.research.google.com/github/lexfridman/mit-deep-learning/blob/master/tutorial_driving_scene_segmentation/tutorial_driving_scene_segmentation.ipynb\">\n",
    "        <img src=\"https://deeplearning.mit.edu/files/images/github/icon_google_colab.png\" style=\"height:40px; padding-bottom:5px;\" />Run in Google Colab</a></td>\n",
    "  <td align=\"center\"><a target=\"_blank\" href=\"https://github.com/lexfridman/mit-deep-learning/blob/master/tutorial_driving_scene_segmentation/tutorial_driving_scene_segmentation.ipynb\">\n",
    "        <img src=\"https://deeplearning.mit.edu/files/images/github/icon_github.png\" style=\"height:40px; padding-bottom:5px;\"  />View Source on GitHub</a></td>\n",
    "  <td align=\"center\"><a target=\"_blank\" href=\"https://www.youtube.com/playlist?list=PLrAXtmErZgOeiKm4sgNOknGvNjby9efdf\">\n",
    "        <img src=\"https://deeplearning.mit.edu/files/images/github/icon_youtube.png\" style=\"height:40px; padding-bottom:5px;\" />Watch Videos</a></td>\n",
    "<!--   <td><a target=\"_blank\" href=\"link\">\n",
    "        <img src=\"image\" />text</a></td> -->\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "KFPcBuVFw61h"
   },
   "source": [
    "# MIT Driving Scene Segmentation\n",
    "\n",
    "This tutorial demostrates the steps to run DeepLab semantic scene segmentation model on a sample video from MIT Driving Scene Segmentation Dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "cellView": "code",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "kAbdmRmvq0Je",
    "outputId": "f82ca270-f776-41b7-c542-dbf02116015c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.12.0\n"
     ]
    }
   ],
   "source": [
    "# Tensorflow\n",
    "import tensorflow as tf\n",
    "print(tf.__version__)\n",
    "\n",
    "# I/O libraries\n",
    "import os\n",
    "from io import BytesIO\n",
    "import tarfile\n",
    "import tempfile\n",
    "from six.moves import urllib\n",
    "\n",
    "# Helper libraries\n",
    "import matplotlib\n",
    "from matplotlib import gridspec\n",
    "from matplotlib import pyplot as plt\n",
    "import numpy as np\n",
    "from PIL import Image\n",
    "import cv2 as cv\n",
    "from tqdm import tqdm\n",
    "import IPython\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from tabulate import tabulate\n",
    "\n",
    "# Comment this out if you want to see Deprecation warnings\n",
    "import warnings\n",
    "warnings.simplefilter(\"ignore\", DeprecationWarning)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "OQ4WfdFGKLSc"
   },
   "source": [
    "### Build the model\n",
    "\n",
    "**[DeepLab](https://github.com/tensorflow/models/tree/master/research/deeplab)** is a state-of-art deep learning model for semantic image segmentation, where the goal is to assign semantic labels (e.g., person, dog, cat and so on) to every pixel in the input image. Some segmentation results on Flickr images:\n",
    "\n",
    "<p align=\"center\">\n",
    "    <img src=\"https://github.com/tensorflow/models/blob/master/research/deeplab/g3doc/img/vis1.png?raw=true\" width=600></br>\n",
    "    <img src=\"https://github.com/tensorflow/models/blob/master/research/deeplab/g3doc/img/vis2.png?raw=true\" width=600></br>\n",
    "</p>\n",
    "\n",
    "In the driving context, we aim to obtain a semantic understanding of the front driving scene throught the camera input. This is important for driving safety and an essential requirement for all levels of autonomous driving. The first step is to build the model and load the pre-trained weights. In this demo, we use the model checkpoint trained on [Cityscapes](https://www.cityscapes-dataset.com/) dataset.\n",
    "\n",
    "<p align=\"center\">\n",
    "    <img src=\"https://www.cityscapes-dataset.com/wordpress/wp-content/uploads/2015/07/muenster00.png\" width=600></br>\n",
    "    <img src=\"https://www.cityscapes-dataset.com/wordpress/wp-content/uploads/2015/07/zuerich00.png\" width=600></br>\n",
    "</p>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ixa_Cty2KLSc"
   },
   "outputs": [],
   "source": [
    "class DeepLabModel(object):\n",
    "    \"\"\"Class to load deeplab model and run inference.\"\"\"\n",
    "\n",
    "    FROZEN_GRAPH_NAME = 'frozen_inference_graph'\n",
    "\n",
    "    def __init__(self, tarball_path):\n",
    "        \"\"\"Creates and loads pretrained deeplab model.\"\"\"\n",
    "        self.graph = tf.Graph()\n",
    "        graph_def = None\n",
    "\n",
    "        # Extract frozen graph from tar archive.\n",
    "        tar_file = tarfile.open(tarball_path)\n",
    "        for tar_info in tar_file.getmembers():\n",
    "            if self.FROZEN_GRAPH_NAME in os.path.basename(tar_info.name):\n",
    "                file_handle = tar_file.extractfile(tar_info)\n",
    "                graph_def = tf.GraphDef.FromString(file_handle.read())\n",
    "                break\n",
    "        tar_file.close()\n",
    "\n",
    "        if graph_def is None:\n",
    "            raise RuntimeError('Cannot find inference graph in tar archive.')\n",
    "\n",
    "        with self.graph.as_default():\n",
    "            tf.import_graph_def(graph_def, name='')\n",
    "        self.sess = tf.Session(graph=self.graph)\n",
    "\n",
    "    def run(self, image, INPUT_TENSOR_NAME = 'ImageTensor:0', OUTPUT_TENSOR_NAME = 'SemanticPredictions:0'):\n",
    "        \"\"\"Runs inference on a single image.\n",
    "\n",
    "        Args:\n",
    "            image: A PIL.Image object, raw input image.\n",
    "            INPUT_TENSOR_NAME: The name of input tensor, default to ImageTensor.\n",
    "            OUTPUT_TENSOR_NAME: The name of output tensor, default to SemanticPredictions.\n",
    "\n",
    "        Returns:\n",
    "            resized_image: RGB image resized from original input image.\n",
    "            seg_map: Segmentation map of `resized_image`.\n",
    "        \"\"\"\n",
    "        width, height = image.size\n",
    "        target_size = (2049,1025)  # size of Cityscapes images\n",
    "        resized_image = image.convert('RGB').resize(target_size, Image.ANTIALIAS)\n",
    "        batch_seg_map = self.sess.run(\n",
    "            OUTPUT_TENSOR_NAME,\n",
    "            feed_dict={INPUT_TENSOR_NAME: [np.asarray(resized_image)]})\n",
    "        seg_map = batch_seg_map[0]  # expected batch size = 1\n",
    "        if len(seg_map.shape) == 2:\n",
    "            seg_map = np.expand_dims(seg_map,-1)  # need an extra dimension for cv.resize\n",
    "        seg_map = cv.resize(seg_map, (width,height), interpolation=cv.INTER_NEAREST)\n",
    "        return seg_map"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "q0QhB_7SKLSf"
   },
   "source": [
    "### Visualization\n",
    "Now let's create some helper functions for decoding and visualizing the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "cellView": "code",
    "colab": {},
    "colab_type": "code",
    "id": "vN0kU6NJ1Ye5"
   },
   "outputs": [],
   "source": [
    "def create_label_colormap():\n",
    "    \"\"\"Creates a label colormap used in Cityscapes segmentation benchmark.\n",
    "\n",
    "    Returns:\n",
    "        A Colormap for visualizing segmentation results.\n",
    "    \"\"\"\n",
    "    colormap = np.array([\n",
    "        [128,  64, 128],\n",
    "        [244,  35, 232],\n",
    "        [ 70,  70,  70],\n",
    "        [102, 102, 156],\n",
    "        [190, 153, 153],\n",
    "        [153, 153, 153],\n",
    "        [250, 170,  30],\n",
    "        [220, 220,   0],\n",
    "        [107, 142,  35],\n",
    "        [152, 251, 152],\n",
    "        [ 70, 130, 180],\n",
    "        [220,  20,  60],\n",
    "        [255,   0,   0],\n",
    "        [  0,   0, 142],\n",
    "        [  0,   0,  70],\n",
    "        [  0,  60, 100],\n",
    "        [  0,  80, 100],\n",
    "        [  0,   0, 230],\n",
    "        [119,  11,  32],\n",
    "        [  0,   0,   0]], dtype=np.uint8)\n",
    "    return colormap\n",
    "\n",
    "\n",
    "def label_to_color_image(label):\n",
    "    \"\"\"Adds color defined by the dataset colormap to the label.\n",
    "\n",
    "    Args:\n",
    "        label: A 2D array with integer type, storing the segmentation label.\n",
    "\n",
    "    Returns:\n",
    "        result: A 2D array with floating type. The element of the array\n",
    "            is the color indexed by the corresponding element in the input label\n",
    "            to the PASCAL color map.\n",
    "\n",
    "    Raises:\n",
    "        ValueError: If label is not of rank 2 or its value is larger than color\n",
    "            map maximum entry.\n",
    "    \"\"\"\n",
    "    if label.ndim != 2:\n",
    "        raise ValueError('Expect 2-D input label')\n",
    "\n",
    "    colormap = create_label_colormap()\n",
    "\n",
    "    if np.max(label) >= len(colormap):\n",
    "        raise ValueError('label value too large.')\n",
    "\n",
    "    return colormap[label]\n",
    "\n",
    "\n",
    "def vis_segmentation(image, seg_map):\n",
    "    \"\"\"Visualizes input image, segmentation map and overlay view.\"\"\"\n",
    "    plt.figure(figsize=(20, 4))\n",
    "    grid_spec = gridspec.GridSpec(1, 4, width_ratios=[6, 6, 6, 1])\n",
    "\n",
    "    plt.subplot(grid_spec[0])\n",
    "    plt.imshow(image)\n",
    "    plt.axis('off')\n",
    "    plt.title('input image')\n",
    "\n",
    "    plt.subplot(grid_spec[1])\n",
    "    seg_image = label_to_color_image(seg_map).astype(np.uint8)\n",
    "    plt.imshow(seg_image)\n",
    "    plt.axis('off')\n",
    "    plt.title('segmentation map')\n",
    "\n",
    "    plt.subplot(grid_spec[2])\n",
    "    plt.imshow(image)\n",
    "    plt.imshow(seg_image, alpha=0.7)\n",
    "    plt.axis('off')\n",
    "    plt.title('segmentation overlay')\n",
    "\n",
    "    unique_labels = np.unique(seg_map)\n",
    "    ax = plt.subplot(grid_spec[3])\n",
    "    plt.imshow(FULL_COLOR_MAP[unique_labels].astype(np.uint8), interpolation='nearest')\n",
    "    ax.yaxis.tick_right()\n",
    "    plt.yticks(range(len(unique_labels)), LABEL_NAMES[unique_labels])\n",
    "    plt.xticks([], [])\n",
    "    ax.tick_params(width=0.0)\n",
    "    plt.grid('off')\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "LABEL_NAMES = np.asarray([\n",
    "    'road', 'sidewalk', 'building', 'wall', 'fence', 'pole', 'traffic light',\n",
    "    'traffic sign', 'vegetation', 'terrain', 'sky', 'person', 'rider', 'car', 'truck',\n",
    "    'bus', 'train', 'motorcycle', 'bicycle', 'void'])\n",
    "\n",
    "FULL_LABEL_MAP = np.arange(len(LABEL_NAMES)).reshape(len(LABEL_NAMES), 1)\n",
    "FULL_COLOR_MAP = label_to_color_image(FULL_LABEL_MAP)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "pzxbIveNKLSi"
   },
   "source": [
    "### Load the model from a frozen graph\n",
    "There are two model checkpoints pre-trained on Cityscapes with different network backbones: MobileNetV2 and Xception65. We default to use MobileNetV2 for faster inference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 70
    },
    "colab_type": "code",
    "id": "c4oXKmnjw6i_",
    "outputId": "19f93d51-1e69-4b7d-b9b5-16affad308b2",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "downloading model, this might take a while...\n",
      "download completed! loading DeepLab model...\n",
      "model loaded successfully!\n"
     ]
    }
   ],
   "source": [
    "MODEL_NAME = 'mobilenetv2_coco_cityscapes_trainfine'\n",
    "#MODEL_NAME = 'xception65_cityscapes_trainfine'\n",
    "\n",
    "_DOWNLOAD_URL_PREFIX = 'http://download.tensorflow.org/models/'\n",
    "_MODEL_URLS = {\n",
    "    'mobilenetv2_coco_cityscapes_trainfine':\n",
    "        'deeplabv3_mnv2_cityscapes_train_2018_02_05.tar.gz',\n",
    "    'xception65_cityscapes_trainfine':\n",
    "        'deeplabv3_cityscapes_train_2018_02_06.tar.gz',\n",
    "}\n",
    "_TARBALL_NAME = 'deeplab_model.tar.gz'\n",
    "\n",
    "model_dir = tempfile.mkdtemp()\n",
    "tf.gfile.MakeDirs(model_dir)\n",
    "\n",
    "download_path = os.path.join(model_dir, _TARBALL_NAME)\n",
    "print('downloading model, this might take a while...')\n",
    "urllib.request.urlretrieve(_DOWNLOAD_URL_PREFIX + _MODEL_URLS[MODEL_NAME], download_path)\n",
    "print('download completed! loading DeepLab model...')\n",
    "\n",
    "MODEL = DeepLabModel(download_path)\n",
    "print('model loaded successfully!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "SZst78N-4OKO"
   },
   "source": [
    "### Run on the sample image\n",
    "The sample image is frame #0 in the MIT Driving Scene Segmentation (DriveSeg) Dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 304
    },
    "colab_type": "code",
    "id": "edGukUHXyymr",
    "outputId": "68858de4-7d6f-464c-bfed-b576a2843ea3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "downloading the sample image...\n",
      "running deeplab on the sample image...\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABKwAAADnCAYAAAAzd871AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBo\ndHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzsnXmYFNW5uN+q6n32fWOGGZB9GRQQ\nQUVARXBJiBpRRIkkmhjXeDUa4q4xatQIuVFvjLlPbvD+EqOYxCVRjArRKyCCqGwCsszG7DM9vXdV\nnd8f1d3TM9MDAy6AOe/z1NPdVadOfefU6XNOfef7vlKEEAKJRCKRSCQSiUQikUgkEonkKEE90gJI\nJBKJRCKRSCQSiUQikUgkyUiFlUQikUgkEolEIpFIJBKJ5KhCKqwkEolEIpFIJBKJRCKRSCRHFVJh\nJZFIJBKJRCKRSCQSiUQiOaqQCiuJRCKRSCQSiUQikUgkEslRhe1ICyCRSCQSiUQikUgkEolE8nXn\nnpn3HNZ5d7111xcsybGBtLCSSCQSiUQikUgkEolEIpEcVUiFlUQikUgkEolEIpFIJBKJ5KhCKqwk\nEolEIpFIJBKJRCKRSCRHFVJhJZFIJBKJRCKRSCQSiUTyb8z5559PbW3tkRajB1JhJZFIJBKJRCKR\nSCQSiUQiOaqQbwmUSCQSiUQikUgkEolEIjlGWbFiBatXr6apqYlp06bxr3/9C4DTTz+dq666im3b\ntnHPPfdgs9lQVZWlS5eSnZ3N/fffz8aNG6mqqiIajR7hUvRFKqwkEolEIpFIJBKJRCKRSI5hGhoa\neOSRR7juuut4/vnnAfj2t7/NnDlzaG1t5Y477mD06NEsXbqUl156ialTp7Jhwwaef/55GhsbOfPM\nM49wCfoiFVYSiUQikUgkEolEIpFIJMcw48aNY+vWrVRXV2OzWaqeE044gW3btlFRUcEjjzxCKBSi\nqamJ8847j507d1JdXY2qqpSUlFBeXn6ES9AXGcNKcsT46KOP+O53v/ul5N3S0sI///nPlMcWLVrE\n5s2bv5TrSiQSiaQnB+qPk4lEIvzlL38BoLGxkXPPPffLFk0ikUi+Vnzd+9sVK1bwne9850iLIZEc\ntdjtdhRFQQiR2BeNRlFVlZ/97GdcfvnlLF++nPnz5wMghEBVu1VCpml+5TIfDKmwkhwx