06 Inception Viewer.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Viewing Pre-Defined Models in TensorFlow\n",
    "\n",
    "TensorFlow has some nifty features that make it easy to export and import models into your code. This can be useful to quickly retrain models, explore other people's work, and chain together separate models. To load in a saved graph, we can use a `tf.GraphDef` to help us out.\n",
    "\n",
    "## What is a GraphDef?\n",
    "\n",
    "A `GraphDef` is a TensorFlow class dedicated to storing a serialized form of a TensorFlow `Graph`. Once a `GraphDef` is loaded (either from disk or from the `Graph.as_graph_def()` function), you can transfer its data into a graph by using the `tf.import_graph_def()` function.\n",
    "\n",
    "In order to read/write `GraphDef` objects from disk, you use a compiled protocol buffer file. To read in the file, you use the `GraphDef.ParseFromString()` method, which takes in a byte string object. For example:\n",
    "\n",
    "```python\n",
    "with open('my_graph.pb', 'rb') as f:\n",
    "    graph_def = tf.GraphDef()\n",
    "    graph_def.ParseFromString(f.read())\n",
    "```\n",
    " \n",
    "To write the file to disk, you use the `GraphDef.SerializeToString()` method:\n",
    "\n",
    "```python\n",
    "with open('new_graph.pb', 'wb') as f:\n",
    "    graph_def = my_existing_graph.as_graph_def()\n",
    "    f.write(graph_def.SerializeToString())\n",
    "```\n",
    "\n",
    "\n",
    "### ...and what is a Protocol Buffer?\n",
    "\n",
    "[Protocol Buffers](https://developers.google.com/protocol-buffers/), sometimes shortened to protobufs, are an extensible, structured way of communicating data. They're in the same family as XML or JSON, but with some extra features. One such feature is the ability to compile it to binary and read it back with included open source software. It's backed by Google, who are planning on using it for all of their APIs in the near future.\n",
    "\n",
    "---\n",
    "\n",
    "# Inspecting Inception\n",
    "\n",
    "Google's \"Inception\" models are a family of _very_ deep convolutional neural networks, designed to be competitors in the [ImageNet Large Scale Visual Recognition Challenge competition](http://image-net.org/challenges/LSVRC/). You can read more about their history with these brief papers:\n",
    "\n",
    "* [Inception v1: GoogLeNet](http://www.cs.unc.edu/~wliu/papers/GoogLeNet.pdf)\n",
    "* [Inception v2 & v3](https://arxiv.org/pdf/1512.00567v3.pdf)\n",
    "\n",
    "The architecture of this Inception v3 is shown below:\n",
    "\n",
    "[![Inception Architecture](images/inception_architecture.png)](images/inception_architecture.png)\n",
    "\n",
    "You can see that it's a long series of various convolutions and pools before getting to the final few steps. Google's been kind enough to provide a pre-trained version of Inception v3 in TensorFlow, so we're going to load it up and visualize the graph using TensorFlow's built-in TensorBoard utility."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Downloading and Extracting the Graph Definition\n",
    "\n",
    "First we need to download the graph definition protocol buffer file. To do so, we're using a nifty function that downloads and extracts a zip file for you if it doesn't already exist."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Python > 3, TensorFlow > 1.0\n",
    "import os.path\n",
    "from six.moves import urllib\n",
    "import tarfile\n",
    "import sys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Modified function from here\n",
    "# https://github.com/tensorflow/tensorflow/blob/master/tensorflow/examples/image_retraining/retrain.py\n",
    "\n",
    "def maybe_download_and_extract(data_url, dest_directory):\n",
    "    \"\"\"Download and extract model tar file.\n",
    "    If the pretrained model we're using doesn't already exist, this function\n",
    "    downloads it from the TensorFlow.org website and unpacks it into a directory.\n",
    "    \"\"\"\n",
    "    if not os.path.exists(dest_directory):\n",
    "        os.makedirs(dest_directory)\n",
    "    filename = data_url.split('/')[-1]\n",
    "    filepath = os.path.join(dest_directory, filename)\n",
    "    if not os.path.exists(filepath):\n",
    "\n",
    "        def _progress(count, block_size, total_size):\n",
    "            sys.stdout.write('\\r>> Downloading %s %.1f%%' %\n",
    "                            (filename,\n",
    "                             float(count * block_size) / float(total_size) * 100.0))\n",
    "        sys.stdout.flush()\n",
    "\n",
    "        filepath, _ = urllib.request.urlretrieve(data_url,\n",
    "                                             filepath,\n",
    "                                             _progress)\n",
    "        print()\n",
    "        statinfo = os.stat(filepath)\n",
    "        print('Successfully downloaded', filename, statinfo.st_size, 'bytes.')\n",
    "    tarfile.open(filepath, 'r:gz').extractall(dest_directory)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Specify where to download from\n",
    "imagenet_url = 'http://download.tensorflow.org/models/image/imagenet/inception-2015-12-05.tgz'\n",
    "# Specify where to save and extract to\n",
    "dest_directory = './saved_models'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Actually download/extract the file!\n",
    "maybe_download_and_extract(imagenet_url, dest_directory)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loading in the GraphDef\n",
    "\n",
    "Now that we've got the graph definition protobuf saved to disk (by default, it's in `inception/classify_image_graph_def.pb`), we can open the file and import it to a `tf.Graph` object.\n",
    "\n",
    "_Note: we're using a `gfile.FastGFile()` utility here instead of Python's built in `open()` function, but the code would work the same if you swapped in `open()`._"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os.path\n",
    "import tensorflow as tf\n",
    "from tensorflow.python.platform import gfile\n",
    "\n",
    "graph_filename = os.path.join(dest_directory, 'classify_image_graph_def.pb')\n",
    "graph = tf.Graph()\n",
    "with graph.as_default():\n",
    "    with gfile.FastGFile(graph_filename, 'rb') as f:\n",
    "        graph_def = tf.GraphDef()\n",
    "        graph_def.ParseFromString(f.read())\n",
    "        tf.import_graph_def(graph_def, name='')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Saving the Graph to TensorBoard\n",
    "\n",
    "Now that we've got the Inception graph saved in a Python variable, we can export it by using the `tf.train.SummaryWriter` class, which writes out data to disk for use by TensorBoard. We're not doing much other than saving the graph, so we'll just open up the writer and immediately close it. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Directory to save TensorBoard data\n",
    "logdir = 'tensorboard/inception'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "writer = tf.summary.FileWriter(logdir, graph=graph)\n",
    "writer.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In a console, run the following command:\n",
    "\n",
    "```bash\n",
    "$ tensorboard --logdir='tensorboard/inception' --port=6006\n",
    "```\n",
    "\n",
    "By default, this command will start a TensorBoard server on `localhost:6006`. Once it's running, open up `localhost:6006` in your browser.\n",
    "\n",
    "If you get an error stating that the port is in use, simply change the port number in the command."
   ]
  },
  {
   "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": 1
}