Simple Image Classifier.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Simple Image Classifier Using Tensorflow\n",
    "\n",
    "Here, we will create an image classifier with Tensorflow that will be able to classify images of your choice. This example utilizes the [Inception v3](https://github.com/tensorflow/models/tree/master/inception) architecure model. Inception is a pretrained [convolutional neural network](https://en.wikipedia.org/wiki/Convolutional_neural_network) model trained on over a hundred thousand of [ImageNet](http://www.image-net.org/) images, classifying them into 1000 categories.\n",
    "\n",
    "In order to get the model to be able to identify a custom image, we must apply [transfer learning](https://en.wikipedia.org/wiki/Transfer_learning). This is where we apply the learning from a previous training session to a new training session.\n",
    "\n",
    "The magic of transfer learning is that lower layers that have been trained to distinguish between some objects can be reused for many recognition tasks without any alteration."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "To do the transfer learning, run the retrain script included in the Tensorflow repository.\n",
    "\n",
    "````\n",
    "python tensorflow/examples/image_retraining/retrain.py \\\n",
    "--bottleneck_dir=/tf_demo/bottlenecks \\\n",
    "--how_many_training_steps 1000 \\\n",
    "--model_dir=/tf_demo/inception \\\n",
    "--output_graph=/tf_demo/retrained_graph.pb \\\n",
    "--output_labels=/tf_demo/retrained_labels.txt \\\n",
    "--image_dir /tf_demo/data\n",
    "````\n",
    "\n",
    "The ***bottleneck_dir*** will be used to cache the outputs of the lower layers on disk so they don’t have to repeatedly be recalculated. 'Bottleneck' is an informal term often used for the layer just before the final output layer that actually does the classification.\n",
    "\n",
    "We will run this example for 1000 iterations. This amount can be experimented as the improvement in accuracy has diminishing returns the longer you train for.\n",
    "\n",
    "The ***model_dir*** flag asks us where to store the trained model.\n",
    "\n",
    "The ***output_graph*** option is where the script will write out a version of the Inception v3 neural network with a final layer retrained to our categories. \n",
    "\n",
    "The ***output_labels*** will be the file where the labels are stored. These labels are the same as the image folder names.\n",
    "\n",
    "This will take a while, but when it is complete, you will now have a retrained model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Detector Script\n",
    "\n",
    "We will now write a script that will use the retrained model to detect if an image contains the subject we trained it on. Also, the repo of this notebook contains a simple python script where you can pass in your image and model directory to classify your own image using the retrained model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Change these to match your paths\n",
    "# The image we want to test\n",
    "image_path = '/Users/paulvaneck/tensorflow-demo/test-images/batman1.jpg'\n",
    "\n",
    "# Directory containing graph file and labels file\n",
    "model = '/Users/paulvaneck/tensorflow-demo/hero-model/'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Read in the image_data\n",
    "image_data = tf.gfile.FastGFile(image_path, 'rb').read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Loads label file to get all labels\n",
    "label_list = [line.rstrip() for line \n",
    "                   in tf.gfile.GFile(model + \"retrained_labels.txt\")]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Get the retrained model from the saved graph file.\n",
    "with tf.gfile.FastGFile(model + \"retrained_graph.pb\", 'rb') as f:\n",
    "    graph_def = tf.GraphDef()\n",
    "\n",
    "    # Parse the graph.\n",
    "    graph_def.ParseFromString(f.read())\n",
    "    _ = tf.import_graph_def(graph_def, name='')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "batman (score = 0.99923)\n",
      "superman (score = 0.00077)\n"
     ]
    }
   ],
   "source": [
    "with tf.Session() as sess:\n",
    "    # Get the softmax tensor from the last layer of our model.\n",
    "    softmax_tensor = sess.graph.get_tensor_by_name('final_result:0')\n",
    "\n",
    "    # Feed the image_data as input to the graph\n",
    "    # Map input data into probabilites with softmax\n",
    "    predictions = sess.run(softmax_tensor, \\\n",
    "             {'DecodeJpeg/contents:0': image_data})\n",
    "\n",
    "    # Sort to show labels of predictions by confidence\n",
    "    sorted_nodes = predictions[0].argsort()[-len(predictions[0]):][::-1]\n",
    "\n",
    "    # For every prediction, print out the label and score.\n",
    "    for node in sorted_nodes:\n",
    "        label = label_list[node]\n",
    "        score = predictions[0][node]\n",
    "        print('%s (score = %.5f)' % (label, score))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "#### Additional Information\n",
    "\n",
    "https://www.tensorflow.org/tutorials/image_retraining\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}