Traffic_Sign_Classifier.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Self-Driving Car Engineer Nanodegree\n",
    "\n",
    "## Deep Learning\n",
    "\n",
    "## Project: Build a Traffic Sign Recognition Classifier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Step 0: Load The Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded data.\n"
     ]
    }
   ],
   "source": [
    "import pickle\n",
    "import os\n",
    "\n",
    "data_dir = \"./traffic-signs-data/\"\n",
    "training_file = os.path.join(data_dir, \"train.p\")\n",
    "validation_file= os.path.join(data_dir, \"valid.p\")\n",
    "testing_file = os.path.join(data_dir, \"test.p\")\n",
    "\n",
    "with open(training_file, mode='rb') as f:\n",
    "    train = pickle.load(f)\n",
    "with open(validation_file, mode='rb') as f:\n",
    "    valid = pickle.load(f)\n",
    "with open(testing_file, mode='rb') as f:\n",
    "    test = pickle.load(f)\n",
    "\n",
    "X_train, y_train = train['features'], train['labels']\n",
    "X_valid, y_valid = valid['features'], valid['labels']\n",
    "X_test, y_test = test['features'], test['labels']\n",
    "print(\"Loaded data.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Step 1: Dataset Summary & Exploration\n",
    "\n",
    "The pickled data is a dictionary with 4 key/value pairs:\n",
    "\n",
    "- `'features'` is a 4D array containing raw pixel data of the traffic sign images, (num examples, width, height, channels).\n",
    "- `'labels'` is a 1D array containing the label/class id of the traffic sign. The file `signnames.csv` contains id -> name mappings for each id.\n",
    "- `'sizes'` is a list containing tuples, (width, height) representing the original width and height the image.\n",
    "- `'coords'` is a list containing tuples, (x1, y1, x2, y2) representing coordinates of a bounding box around the sign in the image. **THESE COORDINATES ASSUME THE ORIGINAL IMAGE. THE PICKLED DATA CONTAINS RESIZED VERSIONS (32 by 32) OF THESE IMAGES**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Provide a Basic Summary of the Data Set Using Python, Numpy and/or Pandas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of training examples = 34799\n",
      "Number of validation examples = 4410\n",
      "Number of testing examples = 12630\n",
      "Image data shape = (32, 32, 3)\n",
      "Number of classes = 43\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "n_train = len(X_train)\n",
    "\n",
    "n_validation = len(X_valid)\n",
    "n_test = len(X_test)\n",
    "image_shape = X_train[0].shape\n",
    "\n",
    "classes = sorted(np.unique(y_train))\n",
    "n_classes = len(classes)\n",
    "\n",
    "print(\"Number of training examples =\", n_train)\n",
    "print(\"Number of validation examples =\", n_validation)\n",
    "print(\"Number of testing examples =\", n_test)\n",
    "print(\"Image data shape =\", image_shape)\n",
    "print(\"Number of classes =\", n_classes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Build Class Mapping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/jamesfulford/miniconda3/envs/carnd-term1/lib/python3.5/site-packages/ipykernel_launcher.py:3: FutureWarning: from_csv is deprecated. Please use read_csv(...) instead. Note that some of the default arguments are different, so please refer to the documentation for from_csv when changing your function calls\n",
      "  This is separate from the ipykernel package so we can avoid doing imports until\n"
     ]
    }
   ],
   "source": [
    "import pandas\n",
    "\n",
    "class_to_description = pandas.DataFrame.from_csv(\"./traffic-signs-data/signnames.csv\").to_dict('index')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exploratory Visualization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Visualize the German Traffic Signs Dataset using the pickled file(s)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 2: 2010 (Speed limit (50km/h))\n",
      " 1: 1980 (Speed limit (30km/h))\n",
      "13: 1920 (Yield)\n",
      "12: 1890 (Priority road)\n",
      "38: 1860 (Keep right)\n",
      "10: 1800 (No passing for vehicles over 3.5 metric tons)\n",
      " 4: 1770 (Speed limit (70km/h))\n",
      " 5: 1650 (Speed limit (80km/h))\n",
      "25: 1350 (Road work)\n",
      " 9: 1320 (No passing)\n",
      " 7: 1290 (Speed limit (100km/h))\n",
      " 8: 1260 (Speed limit (120km/h))\n",
      " 3: 1260 (Speed limit (60km/h))\n",
      "11: 1170 (Right-of-way at the next intersection)\n",
      "35: 1080 (Ahead only)\n",
      "18: 1080 (General caution)\n",
      "17:  990 (No entry)\n",
      "31:  690 (Wild animals crossing)\n",
      "14:  690 (Stop)\n",
      "33:  599 (Turn right ahead)\n",
      "26:  540 (Traffic signals)\n",
      "15:  540 (No vehicles)\n",
      "28:  480 (Children crossing)\n",
      "23:  450 (Slippery road)\n",
      "41:  420 (End of no passing)\n",
      "30:  390 (Beware of ice/snow)\n",
      "34:  360 (Turn left ahead)\n",
      "16:  360 (Vehicles over 3.5 metric tons prohibited)\n",
      " 6:  360 (End of speed limit (80km/h))\n",
      "36:  330 (Go straight or right)\n",
      "22:  330 (Bumpy road)\n",
      "40:  300 (Roundabout mandatory)\n",
      "20:  300 (Dangerous curve to the right)\n",
      "39:  270 (Keep left)\n",
      "21:  270 (Double curve)\n",
      "29:  240 (Bicycles crossing)\n",
      "24:  240 (Road narrows on the right)\n",
      "32:  210 (End of all speed and passing limits)\n",
      "27:  210 (Pedestrians)\n",
      "37:  180 (Go straight or left)\n",
      "19:  180 (Dangerous curve to the left)\n",
      " 0:  180 (Speed limit (20km/h))\n"
     ]
    },
    {
     "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": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "frequencies, classes, *_ = plt.hist(y_train, bins=np.arange(y_train.min(), y_train.max() + 1))\n",
    "for (freq, cls) in reversed(sorted(zip(frequencies, classes))):\n",
    "    print(\"{}: {} ({})\".format(\n",
    "        str(cls).rjust(2, \" \"), \n",
    "        str(int(freq)).rjust(4, \" \"),\n",
    "        class_to_description[cls][\"SignName\"],\n",
    "    ))\n",
    "\n",
    "plt.savefig(\"./artifacts/training_data_distribution.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13:  240 (Yield)\n",
      " 2:  240 (Speed limit (50km/h))\n",
      " 1:  240 (Speed limit (30km/h))\n",
      "38:  210 (Keep right)\n",
      "12:  210 (Priority road)\n",
      "10:  210 (No passing for vehicles over 3.5 metric tons)\n",
      " 5:  210 (Speed limit (80km/h))\n",
      " 4:  210 (Speed limit (70km/h))\n",
      "25:  150 (Road work)\n",
      "11:  150 (Right-of-way at the next intersection)\n",
      " 9:  150 (No passing)\n",
      " 8:  150 (Speed limit (120km/h))\n",
      " 7:  150 (Speed limit (100km/h))\n",
      " 3:  150 (Speed limit (60km/h))\n",
      "35:  120 (Ahead only)\n",
      "18:  120 (General caution)\n",
      "17:  120 (No entry)\n",
      "33:   90 (Turn right ahead)\n",
      "31:   90 (Wild animals crossing)\n",
      "15:   90 (No vehicles)\n",
      "14:   90 (Stop)\n",
      "41:   60 (End of no passing)\n",
      "40:   60 (Roundabout mandatory)\n",
      "36:   60 (Go straight or right)\n",
      "34:   60 (Turn left ahead)\n",
      "30:   60 (Beware of ice/snow)\n",
      "28:   60 (Children crossing)\n",
      "26:   60 (Traffic signals)\n",
      "23:   60 (Slippery road)\n",
      "22:   60 (Bumpy road)\n",
      "21:   60 (Double curve)\n",
      "20:   60 (Dangerous curve to the right)\n",
      "16:   60 (Vehicles over 3.5 metric tons prohibited)\n",
      " 6:   60 (End of speed limit (80km/h))\n",
      "39:   30 (Keep left)\n",
      "37:   30 (Go straight or left)\n",
      "32:   30 (End of all speed and passing limits)\n",
      "29:   30 (Bicycles crossing)\n",
      "27:   30 (Pedestrians)\n",
      "24:   30 (Road narrows on the right)\n",
      "19:   30 (Dangerous curve to the left)\n",
      " 0:   30 (Speed limit (20km/h))\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD8CAYAAAB5Pm/hAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAADklJREFUeJzt3X+o3fV9x/Hna+rasXZY51Wy/Nh1JQMdrGm5iOD+cO1Y1ZTFwizKVkMR0j8sWHCMtP+0GwgprLYUNiGd0hScbVjbGRbZ5jJHV5jaG+uqNhOzNrNpQpKutioFR+x7f5xv6lm8Oefcc+7Jvfdznw84nO/3cz+f833fz819nW8+55zvTVUhSWrXLyx3AZKk6TLoJalxBr0kNc6gl6TGGfSS1DiDXpIaZ9BLUuOGBn2SjUkeTXIoybNJ7uzaP5nkB0me6m439o35WJLDSZ5L8t5pfgOSpMEy7ANTSdYB66rqySRvBQ4CNwEfAF6pqr84q/9VwIPA1cCvAf8M/GZVvTaF+iVJQ1w4rENVHQeOd9svJzkErB8wZBvwpap6FfheksP0Qv/fzzXg0ksvrdnZ2cXULUlr3sGDB39YVTPD+g0N+n5JZoF3Ao8D1wIfSXIbMA/cVVUv0nsSeKxv2FEGPzEwOzvL/Pz8YkqRpDUvyX+P0m/kF2OTvAX4CvDRqnoJuBd4O7CF3hn/p890XWD4G9aHkuxIMp9k/tSpU6OWIUlapJGCPslF9EL+gar6KkBVnaiq16rqZ8Dn6S3PQO8MfmPf8A3AsbMfs6p2V9VcVc3NzAz9n4ckaUyjvOsmwH3Aoaq6p699XV+39wPPdNv7gFuSvCnJFcBm4ImlK1mStBijrNFfC3wQeDrJU13bx4Fbk2yhtyxzBPgwQFU9m2Qv8B3gNHCH77iRpOUzyrtuvsHC6+4PDxhzN3D3BHVJkpaIn4yVpMYZ9JLUOINekhpn0EtS4xb1ydjVaHbn/rHGHdm1dYkrac+guXX+pJXDM3pJapxBL0mNM+glqXEGvSQ1zqCXpMYZ9JLUOINekhpn0EtS4wx6SWqcQS9JjTPoJalxBr0kNc6gl6TGGfSS1DiDXpIaZ9BLUuMMeklqnEEvSY0z6CWpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJatyFy13AajS7c//YY4/s2rqElYxmUL2D6pnk+5RWo3F/V1Y6z+glqXEGvSQ1zqCXpMYZ9JLUuKFBn2RjkkeTHErybJI7u/ZLkjyS5Pnu/m1de5J8LsnhJN9O8q5pfxOSpHMb5Yz+NHBXVV0JXAPckeQqYCdwoKo2Awe6fYAbgM3dbQdw75JXLUka2dCgr6rjVfVkt/0ycAhYD2wD9nTd9gA3ddvbgC9Wz2PAxUnWLXnlkqSRLGqNPsks8E7gceDyqjoOvScD4LKu23rg+33DjnZtZz/WjiTzSeZPnTq1+MolSSMZOeiTvAX4CvDRqnppUNcF2uoNDVW7q2ququZmZmZGLUOStEgjBX2Si+iF/ANV9dWu+cSZJZnu/mTXfhTY2Dd8A3BsacqVJC3WKO+6CXAfcKiq7un70j5ge7e9HXior/227t031wA/ObPEI0k6/0a51s21wAeBp5M81bV9HNgF7E1yO/ACcHP3tYeBG4HDwE+BDy1pxZKkRRka9FX1DRZedwd4zwL9C7hjwrokSUvET8ZKUuMMeklqnEEvSY0z6CWpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJapxBL0mNM+glqXEGvSQ1zqCXpMYZ9JLUOINekhpn0EtS4wx6SWqcQS9JjTPoJalxBr0kNc6gl6TGGfSS1DiDXpIaZ9BLUuMMeklqnEEvSY0z6CWpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJatzQoE9yf5KTSZ7pa/tkkh8keaq73dj3tY8lOZzkuSTvnVbhkqTRjHJG/wXg+gXaP1NVW7rbwwBJrgJuAX6rG/NXSS5YqmIlSYs3NOir6uvAj0Z8vG3Al6rq1ar6HnAYuHqC+iRJE7pwgrEfSXIbMA/cVVUvAuuBx/r6HO3a3iDJDmAHwKZNmyYoYzpmd+73mFo2g34uR3ZtPY+VqAXjvhh7L/B2YAtwHPh0154F+tZCD1BVu6tqrqrmZmZmxixDkjTMWEFfVSeq6rWq+hnweV5fnjkKbOzrugE4NlmJkqRJjBX0Sdb17b4fOPOOnH3ALUnelOQKYDPwxGQlSpImMXSNPsmDwHXApUmOAp8Arkuyhd6yzBHgwwBV9WySvcB3gNPAHVX12nRKlySNYmjQV9WtCzTfN6D/3cDdkxQlSVo6fjJWkhpn0EtS4wx6SWqcQS9JjTPoJalxBr0kNc6gl6TGGfSS1DiDXpIaZ9BLUuMMeklqnEEvSY0z6CWpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJapxBL0mNG/rHwaWVZHbn/rHGHdm1dYkr0XIa9O/An/UbeUYvSY0z6CWpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJapxBL0mNM+glqXEGvSQ1zqCXpMYZ9JLUuKFBn+T+JCeTPNPXdkmSR5I8392/rWtPks8lOZzk20neNc3iJUnDjXJG/wXg+rPadgIHqmozcKDbB7gB2NzddgD3Lk2ZkqRxDQ36qvo68KOzmrcBe7rtPcBNfe1frJ7HgIuTrFuqYiVJizfuGv3lVXUcoLu/rGtfD3y/r9/Rrk2StEyW+sXYLNBWC3ZMdiSZTzJ/6tSpJS5DknTGuEF/4sySTHd/sms/Cmzs67cBOLbQA1TV7qqaq6q5mZmZMcuQJA0zbtDvA7Z329uBh/rab+vefXMN8JMzSzySpOUx9I+DJ3kQuA64NMlR4BPALmBvktuBF4Cbu+4PAzcCh4GfAh+aQs2SpEUYGvRVdes5vvSeBfoWcMekRUmSlo6fjJWkxhn0ktQ4g16SGjd0jV4ax+zO/WONO7Jr6xJXomkb9LMe9vOcZKxG5xm9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJapxBL0mNM+glqXEGvSQ1zqCXpMYZ9JLUOINekhpn0EtS4wx6SWqcQS9JjTPoJalxBr0kNc6gl6TGGfSS1DiDXpIaZ9BLUuMMeklqnEEvSY0z6CWpcQa9JDXuwuUuYK2Z3bl/uUtY0ZZjfpbjmEd2bR177KB6Bz3usO9zkrHTMO4xJ/k+xzXJ/EyjnrN5Ri9JjTPoJalxBr0kNc6gl6TGTfRibJIjwMvAa8DpqppLcgnwZWAWOAJ8oKpenKxMSdK4luKM/neraktVzXX7O4EDVbUZONDtS5KWyTSWbrYBe7rtPcBNUziGJGlEkwZ9Af+U5GCSHV3b5VV1HKC7v2zCY0iSJjDpB6aurapjSS4DHknyn6MO7J4YdgBs2rRpwjIkSecy0Rl9VR3r7k8CXwOuBk4kWQfQ3Z88x9jdVTVXVXMzMzOTlCFJGmDsoE/yy0neemYb+H3gGWAfsL3rth14aNIiJUnjm2Tp5nLga0nOPM7fVNU/JPkmsDfJ7cALwM2TlylJGtfYQV9V3wXesUD7/wDvmaQoSdLS8ZOxktQ4g16SGmfQS1LjDHpJapxBL0mNM+glqXEGvSQ1zqCXpMYZ9JLUOINekhpn0EtS4wx6SWpcqmq5a2Bubq7m5+fHGju7c/8SVyNJ58+RXVvHHpvkYN/f6z4nz+glqXEGvSQ1zqCXpMYZ9JLUOINekhpn0EtS4wx6SWqcQS9JjTPoJalxBr0kNc6gl6TGGfSS1DiDXpIaZ9BLUuMMeklqnEEvSY0z6CWpcQa9JDXOoJekxhn0ktQ4g16SGje1oE9yfZLnkhxOsnNax5EkDTaVoE9yAfCXwA3AVcCtSa6axrEkSYNN64z+auBwVX23qv4X+BKwbUrHkiQNMK2gXw98v2//aNcmSTrPLpzS42aBtvp/HZIdwI5u95Ukz415rEuBH445dq1wjgZzfoZzjgYbe37yqYmO++ujdJpW0B8FNvbtbwCO9Xeoqt3A7kkPlGS+quYmfZyWOUeDOT/DOUeDrfT5mdbSzTeBzUmuSPKLwC3AvikdS5I0wFTO6KvqdJKPAP8IXADcX1XPTuNYkqTBprV0Q1U9DDw8rcfvM/HyzxrgHA3m/AznHA22oucnVTW8lyRp1fISCJLUuFUd9F5m4Y2S3J/kZJJn+touSfJIkue7+7ctZ43LKcnGJI8mOZTk2SR3du3OEZDkzUmeSPIf3fz8Wdd+RZLHu/n5cvcmizUryQVJvpXk77v9FT0/qzbovczCOX0BuP6stp3AgaraDBzo9teq08BdVXUlcA1wR/fvxjnqeRV4d1W9A9gCXJ/kGuBTwGe6+XkRuH0Za1wJ7gQO9e2v6PlZtUGPl1lYUFV9HfjRWc3bgD3d9h7gpvNa1ApSVcer6slu+2V6v6zrcY4AqJ5Xut2LulsB7wb+tmtfs/MDkGQDsBX4624/rPD5Wc1B72UWRnd5VR2HXtABly1zPStCklngncDjOEc/1y1LPAWcBB4B/gv4cVWd7rqs9d+1zwJ/Cvys2/9VVvj8rOagH3qZBelckrwF+Arw0ap6abnrWUmq6rWq2kLvE+1XA1cu1O38VrUyJHkfcLKqDvY3L9B1Rc3P1N5Hfx4MvcyCfu5EknVVdTzJOnpnamtWkovohfwDVfXVrtk5OktV/TjJv9J7LePiJBd2Z61r+XftWuAPktwIvBn4FXpn+Ct6flbzGb2XWRjdPmB7t70deGgZa1lW3XrqfcChqrqn70vOEZBkJsnF3fYvAb9H73WMR4E/7Lqt2fmpqo9V1YaqmqWXOf9SVX/ECp+fVf2Bqe5Z9bO8fpmFu5e5pGWX5EHgOnpX0zsBfAL4O2AvsAl4Abi5qs5+wXZNSPI7wL8BT/P6GuvH6a3Tr/k5SvLb9F5MvIDeieDeqvrzJL9B7w0PlwDfAv64ql5dvkqXX5LrgD+pqvet9PlZ1UEvSRpuNS/dSJJGYNBLUuMMeklqnEEvSY0z6CWpcQa9JDXOoJekxhn0ktS4/wPuBL7yKUp2tgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "frequencies, classes, *_ = plt.hist(y_valid, bins=np.arange(y_valid.min(), y_valid.max() + 1))\n",
    "for (freq, cls) in reversed(sorted(zip(frequencies, classes))):\n",
    "    print(\"{}: {} ({})\".format(\n",
    "        str(cls).rjust(2, \" \"), \n",
    "        str(int(freq)).rjust(4, \" \"),\n",
    "        class_to_description[cls][\"SignName\"],\n",
    "    ))\n",
    "\n",
    "plt.savefig(\"./artifacts/validation_data_distribution.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 2:  750 (Speed limit (50km/h))\n",
      "13:  720 (Yield)\n",
      " 1:  720 (Speed limit (30km/h))\n",
      "38:  690 (Keep right)\n",
      "12:  690 (Priority road)\n",
      "10:  660 (No passing for vehicles over 3.5 metric tons)\n",
      " 4:  660 (Speed limit (70km/h))\n",
      " 5:  630 (Speed limit (80km/h))\n",
      "25:  480 (Road work)\n",
      " 9:  480 (No passing)\n",
      " 8:  450 (Speed limit (120km/h))\n",
      " 7:  450 (Speed limit (100km/h))\n",
      " 3:  450 (Speed limit (60km/h))\n",
      "11:  420 (Right-of-way at the next intersection)\n",
      "35:  390 (Ahead only)\n",
      "18:  390 (General caution)\n",
      "17:  360 (No entry)\n",
      "31:  270 (Wild animals crossing)\n",
      "14:  270 (Stop)\n",
      "33:  210 (Turn right ahead)\n",
      "15:  210 (No vehicles)\n",
      "26:  180 (Traffic signals)\n",
      "41:  150 (End of no passing)\n",
      "30:  150 (Beware of ice/snow)\n",
      "28:  150 (Children crossing)\n",
      "23:  150 (Slippery road)\n",
      "16:  150 (Vehicles over 3.5 metric tons prohibited)\n",
      " 6:  150 (End of speed limit (80km/h))\n",
      "36:  120 (Go straight or right)\n",
      "34:  120 (Turn left ahead)\n",
      "22:  120 (Bumpy road)\n",
      "40:   90 (Roundabout mandatory)\n",
      "39:   90 (Keep left)\n",
      "29:   90 (Bicycles crossing)\n",
      "24:   90 (Road narrows on the right)\n",
      "21:   90 (Double curve)\n",
      "20:   90 (Dangerous curve to the right)\n",
      "37:   60 (Go straight or left)\n",
      "32:   60 (End of all speed and passing limits)\n",
      "27:   60 (Pedestrians)\n",
      "19:   60 (Dangerous curve to the left)\n",
      " 0:   60 (Speed limit (20km/h))\n"
     ]
    },
    {
     "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": [
    "frequencies, classes, *_ = plt.hist(y_test, bins=np.arange(y_test.min(), y_test.max() + 1))\n",
    "for (freq, cls) in reversed(sorted(zip(frequencies, classes))):\n",
    "    print(\"{}: {} ({})\".format(\n",
    "        str(cls).rjust(2, \" \"), \n",
    "        str(int(freq)).rjust(4, \" \"),\n",
    "        class_to_description[cls][\"SignName\"],\n",
    "    ))\n",
    "\n",
    "plt.savefig(\"./artifacts/test_data_distribution.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "\n",
    "## Step 2: Design and Test a Model Architecture\n",
    "\n",
    "Design and implement a deep learning model that learns to recognize traffic signs. Train and test your model on the [German Traffic Sign Dataset](http://benchmark.ini.rub.de/?section=gtsrb&subsection=dataset).\n",
    "\n",
    "The LeNet-5 implementation is my starting point.\n",
    "\n",
    "There are various aspects to consider when thinking about this problem:\n",
    "\n",
    "- Neural network architecture (is the network over or underfitting?)\n",
    "- Play around preprocessing techniques (normalization, rgb to grayscale, etc)\n",
    "- Number of examples per label (some have more than others).\n",
    "- Generate fake data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pre-process"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.utils import shuffle\n",
    "\n",
    "def preprocess(X, y):\n",
    "    \"\"\"\n",
    "    Pipeline for pre-processing images along with their labels\n",
    "    \"\"\"\n",
    "    # Normalizing values to be [-1, 1]\n",
    "    X_ret = np.subtract(X, 128.) / 128\n",
    "    \n",
    "    # Shuffling data\n",
    "    return X_ret, y\n",
    "\n",
    "X_train, y_train = preprocess(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model Architecture"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow.contrib.layers import flatten\n",
    "\n",
    "\n",
    "def Model(x, dropout_rate: \"tensor\", initial_shape, n_classes=43, mu=0, sigma=0.1):\n",
    "    # Layer 1: Convolutional.\n",
    "    in_x, in_y, in_depth = initial_shape\n",
    "    conv1_W = tf.Variable(tf.truncated_normal(\n",
    "        shape=(5, 5, in_depth, 10), \n",
    "        mean=mu, \n",
    "        stddev=sigma,\n",
    "    ))\n",
    "    conv1_b = tf.Variable(tf.zeros(10))\n",
    "    conv1 = tf.nn.conv2d(\n",
    "        x, \n",
    "        conv1_W, \n",
    "        strides=[1, 1, 1, 1], \n",
    "        padding='VALID'\n",
    "    ) + conv1_b\n",
    "    conv1 = tf.nn.relu(conv1)\n",
    "    conv1 = tf.nn.max_pool(\n",
    "        conv1, \n",
    "        ksize=[1, 2, 2, 1], \n",
    "        strides=[1, 2, 2, 1], \n",
    "        padding='VALID',\n",
    "    )\n",
    "\n",
    "    # Layer 2: Convolutional.\n",
    "    conv2_W = tf.Variable(tf.truncated_normal(\n",
    "        shape=(5, 5, 10, 16), \n",
    "        mean=mu, \n",
    "        stddev=sigma,\n",
    "    ))\n",
    "    conv2_b = tf.Variable(tf.zeros(16))\n",
    "    conv2 = tf.nn.conv2d(\n",
    "        conv1,\n",
    "        conv2_W,\n",
    "        strides=[1, 1, 1, 1], \n",
    "        padding='VALID',\n",
    "    ) + conv2_b\n",
    "    conv2 = tf.nn.relu(conv2)\n",
    "    conv2 = tf.nn.max_pool(\n",
    "        conv2, \n",
    "        ksize=[1, 2, 2, 1], \n",
    "        strides=[1, 2, 2, 1], \n",
    "        padding='VALID',\n",
    "    )\n",
    "\n",
    "    # Flatten.\n",
    "    fc0 = flatten(conv2)\n",
    "\n",
    "    # Layer 3: Fully Connected.\n",
    "    fc1_W = tf.Variable(tf.truncated_normal(\n",
    "        shape=(400, 190), \n",
    "        mean=mu, \n",
    "        stddev=sigma,\n",
    "    ))\n",
    "    fc1_b = tf.Variable(tf.zeros(190))\n",
    "    fc1 = tf.matmul(fc0, fc1_W) + fc1_b\n",
    "    fc1 = tf.nn.relu(fc1)\n",
    "    fc1 = tf.nn.dropout(fc1, dropout_rate)\n",
    "\n",
    "    # Layer 4: Fully Connected.\n",
    "    fc2_W = tf.Variable(tf.truncated_normal(\n",
    "        shape=(190, 90), \n",
    "        mean=mu, \n",
    "        stddev=sigma,\n",
    "    ))\n",
    "    fc2_b = tf.Variable(tf.zeros(90))\n",
    "    fc2 = tf.matmul(fc1, fc2_W) + fc2_b\n",
    "    fc2 = tf.nn.relu(fc2)\n",
    "    fc2 = tf.nn.dropout(fc2, dropout_rate)\n",
    "\n",
    "    # Layer 5: Fully Connected.\n",
    "    fc3_W = tf.Variable(tf.truncated_normal(\n",
    "        shape=(90, n_classes), \n",
    "        mean=mu, \n",
    "        stddev=sigma,\n",
    "    ))\n",
    "    fc3_b = tf.Variable(tf.zeros(n_classes))\n",
    "    logits = tf.matmul(fc2, fc3_W) + fc3_b\n",
    "\n",
    "    return logits\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train and Validate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ready.\n"
     ]
    }
   ],
   "source": [
    "rate = 0.001\n",
    "initial_shape = (32, 32, 3)\n",
    "\n",
    "x = tf.placeholder(tf.float32, (None, *initial_shape))\n",
    "y = tf.placeholder(tf.int32, (None))\n",
    "one_hot_y = tf.one_hot(y, n_classes)\n",
    "keep_prob = tf.placeholder(tf.float32)\n",
    "logits = Model(x, keep_prob, initial_shape, n_classes=n_classes)\n",
    "\n",
    "cross_entropy = tf.nn.softmax_cross_entropy_with_logits(labels=one_hot_y, logits=logits)\n",
    "loss_operation = tf.reduce_mean(cross_entropy)\n",
    "optimizer = tf.train.AdamOptimizer(learning_rate = rate)\n",
    "training_operation = optimizer.minimize(loss_operation)\n",
    "\n",
    "correct_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(one_hot_y, 1))\n",
    "accuracy_operation = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\n",
    "saver = tf.train.Saver()\n",
    "\n",
    "def evaluate(X_data, y_data, kp, batch_size=128):\n",
    "    \"\"\"Run inside a session\"\"\"\n",
    "    num_examples = len(X_data)\n",
    "    total_accuracy = 0\n",
    "    sess = tf.get_default_session()\n",
    "    for offset in range(0, num_examples, batch_size):\n",
    "        batch_x, batch_y = X_data[offset:offset + batch_size], y_data[offset:offset + batch_size]\n",
    "        accuracy = sess.run(accuracy_operation, feed_dict={x: batch_x, y: batch_y, keep_prob: kp})\n",
    "        total_accuracy += (accuracy * len(batch_x))\n",
    "    return total_accuracy / num_examples\n",
    "\n",
    "print(\"Ready.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training...\n",
      "\n",
      "EPOCH 1 ...\n",
      "Validation Accuracy = 0.348\n",
      "\n",
      "EPOCH 2 ...\n",
      "Validation Accuracy = 0.622\n",
      "\n",
      "EPOCH 3 ...\n",
      "Validation Accuracy = 0.749\n",
      "\n",
      "EPOCH 4 ...\n",
      "Validation Accuracy = 0.806\n",
      "\n",
      "EPOCH 5 ...\n",
      "Validation Accuracy = 0.831\n",
      "\n",
      "EPOCH 6 ...\n",
      "Validation Accuracy = 0.849\n",
      "\n",
      "EPOCH 7 ...\n",
      "Validation Accuracy = 0.880\n",
      "\n",
      "EPOCH 8 ...\n",
      "Validation Accuracy = 0.881\n",
      "\n",
      "EPOCH 9 ...\n",
      "Validation Accuracy = 0.896\n",
      "\n",
      "EPOCH 10 ...\n",
      "Validation Accuracy = 0.898\n",
      "\n",
      "EPOCH 11 ...\n",
      "Validation Accuracy = 0.909\n",
      "\n",
      "EPOCH 12 ...\n",
      "Validation Accuracy = 0.913\n",
      "\n",
      "EPOCH 13 ...\n",
      "Validation Accuracy = 0.916\n",
      "\n",
      "EPOCH 14 ...\n",
      "Validation Accuracy = 0.926\n",
      "\n",
      "EPOCH 15 ...\n",
      "Validation Accuracy = 0.930\n",
      "\n",
      "EPOCH 16 ...\n",
      "Validation Accuracy = 0.929\n",
      "\n",
      "EPOCH 17 ...\n",
      "Validation Accuracy = 0.931\n",
      "\n",
      "Model saved\n",
      "EPOCH 18 ...\n",
      "Validation Accuracy = 0.931\n",
      "\n",
      "Model saved\n",
      "EPOCH 19 ...\n",
      "Validation Accuracy = 0.931\n",
      "\n",
      "Model saved\n",
      "EPOCH 20 ...\n",
      "Validation Accuracy = 0.935\n",
      "\n",
      "Model saved\n",
      "EPOCH 21 ...\n",
      "Validation Accuracy = 0.938\n",
      "\n",
      "Model saved\n",
      "EPOCH 22 ...\n",
      "Validation Accuracy = 0.937\n",
      "\n",
      "Model saved\n",
      "EPOCH 23 ...\n",
      "Validation Accuracy = 0.937\n",
      "\n",
      "Model saved\n",
      "EPOCH 24 ...\n",
      "Validation Accuracy = 0.943\n",
      "\n",
      "Model saved\n",
      "EPOCH 25 ...\n",
      "Validation Accuracy = 0.939\n",
      "\n",
      "Model saved\n",
      "EPOCH 26 ...\n",
      "Validation Accuracy = 0.938\n",
      "\n",
      "Model saved\n",
      "EPOCH 27 ...\n",
      "Validation Accuracy = 0.942\n",
      "\n",
      "Model saved\n",
      "EPOCH 28 ...\n",
      "Validation Accuracy = 0.944\n",
      "\n",
      "Model saved\n",
      "EPOCH 29 ...\n",
      "Validation Accuracy = 0.938\n",
      "\n",
      "Model saved\n",
      "EPOCH 30 ...\n",
      "Validation Accuracy = 0.943\n",
      "\n",
      "Model saved\n",
      "EPOCH 31 ...\n",
      "Validation Accuracy = 0.943\n",
      "\n",
      "Model saved\n",
      "EPOCH 32 ...\n",
      "Validation Accuracy = 0.945\n",
      "\n",
      "Model saved\n",
      "EPOCH 33 ...\n",
      "Validation Accuracy = 0.946\n",
      "\n",
      "Model saved\n",
      "EPOCH 34 ...\n",
      "Validation Accuracy = 0.950\n",
      "\n",
      "Model saved\n",
      "EPOCH 35 ...\n",
      "Validation Accuracy = 0.949\n",
      "\n",
      "Model saved\n",
      "EPOCH 36 ...\n",
      "Validation Accuracy = 0.949\n",
      "\n",
      "Model saved\n",
      "EPOCH 37 ...\n",
      "Validation Accuracy = 0.944\n",
      "\n",
      "Model saved\n",
      "EPOCH 38 ...\n",
      "Validation Accuracy = 0.947\n",
      "\n",
      "Model saved\n",
      "EPOCH 39 ...\n",
      "Validation Accuracy = 0.945\n",
      "\n",
      "Model saved\n",
      "EPOCH 40 ...\n",
      "Validation Accuracy = 0.947\n",
      "\n",
      "Model saved\n"
     ]
    }
   ],
   "source": [
    "EPOCHS = 40\n",
    "BATCH_SIZE = 512\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    num_examples = len(X_train)\n",
    "    \n",
    "    print(\"Training...\")\n",
    "    print()\n",
    "    for i in range(EPOCHS):\n",
    "        X_train, y_train = shuffle(X_train, y_train)\n",
    "        for offset in range(0, num_examples, BATCH_SIZE):\n",
    "            end = offset + BATCH_SIZE\n",
    "            batch_x, batch_y = X_train[offset:end], y_train[offset:end]\n",
    "            sess.run(training_operation, feed_dict={x: batch_x, y: batch_y, keep_prob: 0.5})\n",
    "            \n",
    "        validation_accuracy = evaluate(X_valid, y_valid, 1.0, batch_size=BATCH_SIZE)\n",
    "        print(\"EPOCH {} ...\".format(i+1))\n",
    "        print(\"Validation Accuracy = {:.3f}\".format(validation_accuracy))\n",
    "        print()\n",
    "        if (validation_accuracy > .93):\n",
    "            saver.save(sess, \"./models/model.{:.3f}.model\".format(validation_accuracy))\n",
    "            print(\"Model saved\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test and Retrieve Accuracies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Restoring parameters from ./models/model.0.950.model\n",
      "Training Data Accuracy: 99.7\n",
      "Validation Data Accuracy: 95.0\n",
      "Test Data Accuracy: 92.7\n"
     ]
    }
   ],
   "source": [
    "from matplotlib import image as mpimg\n",
    "\n",
    "training_accuracy = 0.\n",
    "validation_accuracy = 0.\n",
    "test_accuracy = 0.\n",
    "with tf.Session() as sess:\n",
    "    saver.restore(sess, \"./models/model.0.950.model\")  # manually selected\n",
    "\n",
    "    training_accuracy = evaluate(X_train, y_train, 1.0, batch_size=BATCH_SIZE)\n",
    "    validation_accuracy = evaluate(X_valid, y_valid, 1.0, batch_size=BATCH_SIZE)\n",
    "    test_accuracy = evaluate(X_test, y_test, 1.0, batch_size=BATCH_SIZE)\n",
    "    \n",
    "    print(\"Training Data Accuracy: {:.1f}\".format(training_accuracy * 100.))\n",
    "    print(\"Validation Data Accuracy: {:.1f}\".format(validation_accuracy * 100.))\n",
    "    print(\"Test Data Accuracy: {:.1f}\".format(test_accuracy * 100.))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Step 3: Test a Model on New Images\n",
    "\n",
    "New images are from the internet, downloaded from here: http://benchmark.ini.rub.de/?section=gtsdb&subsection=dataset (had to manually edit the images to focus on a sign and be 32x32 before feeding into my classifier). The website's full dataset download also includes a csv mapping signs in images to classifications, so I can compare the answers (looks like the same class-to-sign-name mapping is used - talk about consistency).\n",
    "\n",
    "The file `signnames.csv` is useful here because it contains mappings from the class id to the actual sign name. I built the mapping near the beginning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Restoring parameters from ./models/model.0.950.model\n"
     ]
    }
   ],
   "source": [
    "from matplotlib import image as mpimg\n",
    "from glob import glob\n",
    "\n",
    "image_files = sorted(glob(\"./sample_images/*\"))\n",
    "images = list(map(mpimg.imread, image_files))\n",
    "\n",
    "soft = tf.nn.softmax(logits)\n",
    "top_k = tf.nn.top_k(soft, 5)\n",
    "\n",
    "top_k_value = None\n",
    "with tf.Session() as sess:\n",
    "    saver.restore(sess, \"./models/model.0.950.model\")  # manually selected\n",
    "    # `0.941` indicates 94.1% accuracy on the validation set\n",
    "\n",
    "    top_k_value = sess.run(\n",
    "        top_k,\n",
    "        feed_dict={x: images, keep_prob: 1.0}\n",
    "    )\n",
    "\n",
    "ranking_assuredness = top_k_value[0]\n",
    "ranking_indexes = top_k_value[1]\n",
    "\n",
    "correct = [11, 40, 39, 4, 21]  # obtained from downloaded csv with classifications\n",
    "\n",
    "def show_image(index):\n",
    "    plt.imshow(images[index])\n",
    "    print(\"Actual: {} ({})\".format(correct[index], class_to_description[correct[index]][\"SignName\"]))\n",
    "    for (cls, assuredness) in zip(ranking_indexes[index], ranking_assuredness[index]):\n",
    "        print(\"{0} (class: {1}) {2:.2f} {3}\".format(class_to_description[cls][\"SignName\"], cls, assuredness, \"(correct)\" if correct[index] == cls else \"\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Actual: 11 (Right-of-way at the next intersection)\n",
      "Speed limit (30km/h) (class: 1) 1.00 \n",
      "Speed limit (20km/h) (class: 0) 0.00 \n",
      "Speed limit (50km/h) (class: 2) 0.00 \n",
      "Speed limit (60km/h) (class: 3) 0.00 \n",
      "Speed limit (70km/h) (class: 4) 0.00 \n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP8AAAD8CAYAAAC4nHJkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJztnXmQXNWV5r+TS2Xtu1QqLWgHgw2SRbVsEDsYA8Yj427T0G7M9LitDjdMtGc80cEwDpuJmO6wHbbBMTPtGbEYdRuzGIwNNrbBLIMxm4QkxCIJLWgpSlJpKUm1Vy5n/qhUhBD3e1VQqizh9/0iFJW6X573br58J1/mPe+cY+4OIUT8SEz0BIQQE4OcX4iYIucXIqbI+YWIKXJ+IWKKnF+ImCLnFyKmyPmFiClyfiFiSmosxmZ2GYAfAkgCuMPdvx31/IrKjNfVVQW1ZCJJ7Qq5PNk/31chX6BaNpejmoNvNJEsC44fOHCI2sybN59qtbXhYzE8ET7/iCkC7I5N45/z7hEbNH4HaCF6IsHRqKtNfqCfars7OqhWW1tNterqsNa5bx+fSILPsn+InzvZfPg8BYBUxCtPshM54tjnyfnR29uPwcGhqDfmqM1/wNt7zSwJ4C0AnwLQDmAlgGvd/U1mM6W10a/795cEtfqqOrqvHuJc5cY/MPp6eqjWsW8v1XJWQbXy2unB8Xt/+mtq86tHf0O1Sy76BNXyWT7/ZDmVUMhliVEl31c+zTeY4h9C/RHO78T5K8Ed5OD69VT73i3foNrFl5xLtSXnnR0c/5c77qQ2+XL+ofxGRyfV9nR1U60xwc+rOnJRQZIfq8P5vuD47574Iw4cODQq5x/L1/7FADa7+1Z3HwJwH4ClY9ieEKKEjMX5pwHYedT/24tjQogPAWNx/tBXi/d81zOzZWa2ysxW9fUNjmF3QojjyVicvx3AjKP+Px3Ae1Zl3H25u7e5e1tlZWYMuxNCHE/G4vwrAcw3s9lmVgbgGgCPHJ9pCSHGmw8c6nP3nJndCOB3GA713eXub0TZ5HN5dB04HNQyEavRvQPhnwudXTzE1tzYRLW6Wq5t2LKTaugKr77msuGVVwBIRayWR8VZkuV8Sd+dh8RY8CY5RKIAAHr28uiH79hMtcz8OVQbqAtHb5JlfNW7qraWaj1D/BhPO3kG1apawvNw5yG7NF9kRybP37Uy8Pc6EbFy3z8U9ol8xPa8fOy36Iwpzu/ujwF4bMyzEEKUHN3hJ0RMkfMLEVPk/ELEFDm/EDFFzi9ETBnTav/7JZvNYc/urqBWcJ5c0tfTGxwf7BugNunMENX27d5PtZ7DPIzWMq05LBT4nYtD/QeoVgAPv/VFZLglIpJjqjIkSaSHz7F/yyaq/eGWm6l23t9/lWqTP3NlcNwtInyVJnMHUD1tMtVe3LCaatNOCd9xni7juS/VEfOojEhmSmb5OWcZ7mplleEEtWxEZmcOJFQZkQl4LLryCxFT5PxCxBQ5vxAxRc4vREyR8wsRU0q62l8oAH294ZXq6ppGaldGSny1b9tObbZHlFtK5Xn5r7YFi6hWUx9OPHky+TS1yWQiskSMr/Yny/mKc1nU2zZAyn/t5zXr3nr6CaqdXsZXj1+46w6qXTJpanC86szF1MbS/H3pj3jJm3fxZKyBfPgYp8p4dKmyiicfTWri5ea6hnjptYFBruUK4XOkLMNT4MvIsRpV/a4iuvILEVPk/ELEFDm/EDFFzi9ETJHzCxFT5PxCxJSShvpyuQK6DoRrsT3/0lpuSKIyZSkeDvM+HkZDL9dOnnsy1U47Odx669KL2/i+nNeeSyR44kZ3bziZCQAyEW9bfSp8sPaseoXa2B4eFq1u4K2wTsvwsNemx34XHF849SRqUzmPt32oaGigWibF6/FlSAem6tp6ajMQEYJN1fIQ4YxMK9W6u3m9ye79JNmNtKkDgHwfec0FJfYIIUZAzi9ETJHzCxFT5PxCxBQ5vxAxRc4vREwZU6jPzLYB6AaQB5Bz94iYFwAYCoXwLvsjaszlkuGQmOd5OKzc+Usrz/Pcp62bt1CtqjwcRvnUpedTm0w539dQgWd61VRUUa08y7PfcLA7ONyxkdfpa67m4byqeTzLsXfLbqp1b9saFtp5JiYm8Wy6Xdv5vv762muo1lA3KzhuCR6y29/Pw3Lb9rdTLZvlodvqND/GTY0twfFUgW9vsDccQk4lI86NY5876mdyLnR3ni8qhDgh0dd+IWLKWJ3fATxuZq+Y2bLjMSEhRGkY69f+Je7eYWaTATxhZhvc/dmjn1D8UFgGAOk0/50lhCgtY7ryu3tH8W8ngIcBvKdGk7svd/c2d29LpUqaSiCEiOADO7+ZVZlZzZHHAC4F8PrxmpgQYnwZy6W4BcDDZnZkOz91999GGbgDOZKMlKngYR7WDmvIefaVRYQ8kmn+mXe4JyLMs21bcLwvd5jaoIJnHp7+Z2dRrSrDQ0Po4628drzwcnB89ao11ObCRQuoVv/ZK6iWXrOOaq/eeXdw/IVfPkBtzprK23/91aevolpzFc8G7O0OZ8Z5opza1NTzLEHfx7WODh6OrEs3UW16w5TgeGtzOAQIADWzwqHgXzy5itocywd2fnffCoCfNUKIExqF+oSIKXJ+IWKKnF+ImCLnFyKmyPmFiCknzl03WV54MNc/FByvb6ihNpbg28sORBTVzPCQY/9QOOT48ipefLSmZTLVCgPh1zVMhLZ3P5XWPP1McLyphYfD5iz9At/XjBlUqmriBSvbusNFKZ9+8OfUpuzBh6k25wze4y9Vzfs8pivD58jhwzw8W13Hz52KPM+0S0R0yitEFNbct/dAcDzfN0BtJk0OFyDN5iIK1x6DrvxCxBQ5vxAxRc4vREyR8wsRU+T8QsSUEq/2OwqkLlnS+edQQ0U4yaUyYmU+m+A1AQd5FyTsP7yXakkLrypHdFVCZQVvaVVpEYf/QHgFGAD6Nmyk2v4dHcHxs6+4nO+rJZxYAgDZTC3V0mX8PZt9+SXB8Z6ItlXta3j9xDmn8vKQDTN5JKM7H65pWF7Bj/30Ol4/Mdc6k2odO3gUJpPhtSxSpK5lXRNvKZasDCeMWWL013Nd+YWIKXJ+IWKKnF+ImCLnFyKmyPmFiClyfiFiSskTexKJcKgvHfE5VF9RGRzP5XmMbSjPExySERXEZ8yZRbWasnDIsbqf7+sPv/8j1b7+pa9QrbDtHardf8dyqtVUNwfHZy/gbbdQyUNKeV6yDl4Wfl8AoGzqrPCuTppLbdp/8wLVOt7ktWEbFp9KtZq6cLLNwgXz+b42bqDaGbO53eZN/D2zan6M93SGG17lEjy5q+DhRCEHTzw6Fl35hYgpcn4hYoqcX4iYIucXIqbI+YWIKXJ+IWLKiKE+M7sLwJUAOt39Y8WxRgD3A5gFYBuAq909XLTtKBIJQznLbsrysN3ll10WHK+fxDPOBtM8qy9Rxuup7dzyNtVeee6VsJDntdteX/sq1bavW8/n8Uce9nrjFV4z8Ib/+s3geGb2LGpzKOIa8OZq3v5pyjRen3B2a1ibvehcarNkaQ/VHv3xHVRrnMZbb7V+dklwvKEqop3b/DlUc9L+CwDmtZ7E7ap5WNRIR7euQzzDdCicrIh89vjW8LsbwLHedxOAJ919PoAni/8XQnyIGNH53f1ZAMcmly8FsKL4eAWAzx3neQkhxpkP+pu/xd13AUDxL//+J4Q4IRn323vNbBmAZQBQVhZxX60QoqR80Cv/HjNrBYDi3072RHdf7u5t7t6WSp04PUKEiDsf1PkfAXB98fH1AH55fKYjhCgVown13QvgAgDNZtYO4FsAvg3gATP7MoAdACL6Pb2bJImK9fTw9kmLFi0Mjp97xaeoTd/QQart2c+zr9pnb6Pa3KnhjLRf3f8LavONG/4T1d54YTXVtrxIwooA9ka0mqqZSopxpvlb/fizT1Ptx3d+h2r5Lp51dts/3xYcP3XRAmoza8k5VFuwkYc3n7n/J1T7QnP4+nbypWdTm75+nsr46D2/otoba9dRLdXEw9JoChcMravj7egaPByqTCV5CPM9zx3pCe5+LZEuHvVehBAnHLrDT4iYIucXIqbI+YWIKXJ+IWKKnF+ImFLSu24MhnQyvMud7+ykdjn6EcWz6Xbv4hlR997/M6p96a9YcAM4d/H5wfGTKsI9/ACgc/0mqu18nffce3Xtm1T7/H/4W6qVt7YGx9e+ysOK//LDH1Bt3daXqda7hYdTb/3nW4Pj/2sFz86rPPlkqi35zGeo9tRmfqy63toeHJ80fza1Wb+f99zbsWs31YYKPFv0wD5+Pg72hfsytjZNojZzWmYFx1OJ0bu0rvxCxBQ5vxAxRc4vREyR8wsRU+T8QsQUOb8QMaWkob6EGcrT4WqFfUO8MOKB/nC1wo7dHdTm/z3De+QN9fKsrcnNJCsOAAbDWWzzpvCQTPdqnunV3b6Lak0tU6k25aOnUy3ZEp7L9pd4QdAXn/gN39eZM/i+6nhoK5cKh2H7uQlSEb3/auaeQrXG2R+h2pNPPB8c/9zH+DGcP30a1TY0t1DtTecFWSvreTh4MD8QHO/q6qc2u1PhYqfZnHr1CSFGQM4vREyR8wsRU+T8QsQUOb8QMaW0iT1myJDV/oVnnkHt9vUcCo4/+yJfwX744Ueo9tnLrqBaIarbUSbcFmpqfT01eaGTJ3TsiEj6Oefqv6Ra7UyelLL1UDhJZO9enpAyr4WvRO8/HF6JBoCKSQ1Uu+/3jwbHFz/yELU5bd5Mqp0xiR/jBVd+nmrbl4df973/+x5q8zf/+J+pdtVFn6ba8yt58lSP8dp66WR1cDxR4O65qT1cMHvgOLfrEkL8CSLnFyKmyPmFiClyfiFiipxfiJgi5xcipoymXdddAK4E0OnuHyuO3QLgKwCOxLFudvfHRtpWLpdF5549Qa1QGQ4BAsCLr6wMjvf38sSHSz/Na761tX2CahUVEW2VBsM1615fy1trPfUYb+80fTIP2Z17/oVUe+twONEJAL74lS8Fx3t3tVObU5p5qC+Z46dIX4InkUw+JRy2++5t36M2Xdt5HccH71hOtYsv5G2+zm0Ph/p+ffePqc3Lj/yeamd8/jKqzT2FJxg99OSTfJsfXRQcP7yfv885CydOeURdy2MZzZX/bgChV3yruy8s/hvR8YUQJxYjOr+7PwsgfOeIEOJDy1h+899oZuvM7C4z47d6CSFOSD6o8/8IwFwACwHsAvB99kQzW2Zmq8xsVS7HC3YIIUrLB3J+d9/j7nl3LwC4HcDiiOcud/c2d29LpUbfO1wIMb58IOc3s6PbwlwF4PXjMx0hRKkYTajvXgAXAGg2s3YA3wJwgZktBOAAtgH4u9HsrIAE+pEJTyTNlw06O8I/F2oK4W0BwDWf/XOq1UznYcXDiXAoEgBqB8IZbm+v4223CuChw5kXXky13Nxw2y0AqDh0mGr/95ZvB8d37+Vrtj/5xc+pVrljA9UaKiuo9torYbubvvldanPhhTw821TB6/shz0OVU2bMD45nKvn2Xnr+JaotXsrnePnis6n2xDM8fLhjyxvB8dYqfg4k+8PfopOjL+E3svO7e6h53Z2j34UQ4kREd/gJEVPk/ELEFDm/EDFFzi9ETJHzCxFTSlrAM5U0NDWGi2BaGc9G2rn1zeD4l66+htokkuHWWgCQHOR3GtZWRBRNfC5cMHT1Sy9Sm6oaHlI6Z8lZVGss53ZJUkgUAD4279Tg+OZNb1ObB+65n2rZwzxz8tABnnWWQriQ5EnTmqnNtKm8SGdtRAHMA+/w19bYFA4hLzybH/sVt99OtXuW82zAL/7jjVT7hy/+NdX+513hjMXuAveJFMJh1oLzVnTHoiu/EDFFzi9ETJHzCxFT5PxCxBQ5vxAxRc4vREwpaagvkQDKSSLe0CAPKTXXhMMa+7p4H7yK2iqqpXyQaoNreBbb0/f8Iji+YSPvubfsq7zvW+usOVTriQhH5sr427a3ry84Xj95CrUpN56dt3jxBVSrn8Kz6e7+2b3B8V17tlGbbK6Hap09/PyoKfD30wvhkO/pF1xKbS7o6KLag/eFXxcAlJXxEOxZly2h2sULFgTHO/v5a95zKHysIiKi70FXfiFiipxfiJgi5xcipsj5hYgpcn4hYkpJV/sLDgzkwokHuV6ekFBJVu6/e9tt1Oac83jixpUXnE+1Lc/yWqRrnlodHJ/5kfBqLQC0LmqjWndEgk6+nEcrvIrXIMyXh7e5d1sntWloCbfWAoCl1/JaiDNPPYlqVTPC0YWKWp6wlM+GayQCQEUFj0hYnh+PvkLYbsD5SnrL6fzcOWMjr/HY8Wa4NRgAbCwPnzsAML86XKvPjdddbJoWPvZPvMgjT8eiK78QMUXOL0RMkfMLEVPk/ELEFDm/EDFFzi9ETBlNu64ZAP4VwBQABQDL3f2HZtYI4H4AszDcsutqd+cZEQAK7ujPhxNWyisiwl6kBVEiyae/8vlVVDurehK3+90fqTawP5w0c+XfXEZtZpwWrqkHAIkUD3v19PFkFfTz+oQ5hOu++RAPpf7Hv7+Baq2tLVTL1PEskr+9+i+D43v38lBZeQ9P7KmKaPKazzvVBoldf45v72Cavy9LrlhKtd1rXqbahjXhOpQAsOjicDj4zd08dLh5d7hu4eBAxHlzDKO58ucAfN3dTwXwSQA3mNlpAG4C8KS7zwfwZPH/QogPCSM6v7vvcvfVxcfdANYDmAZgKYAVxaetAPC58ZqkEOL4875+85vZLAAfB/ASgBZ33wUMf0AAmHy8JyeEGD9G7fxmVg3gIQBfc3feI/q9dsvMbJWZrcqRW3uFEKVnVM5vZmkMO/497n6kmfseM2st6q0AgjePu/tyd29z97ZUqqSpBEKICEZ0fjMzAHcCWO/uPzhKegTA9cXH1wP45fGfnhBivBjNpXgJgOsAvGZma4tjNwP4NoAHzOzLAHYA+MJIGyqggL58b1Dr7eWtnxIeDgFNaaqjNod3bqfaI3evoNr2V1+l2kdOmh4cX3zqydTGIuoMDmUj2oYl+FtTIHX6AKBQCIe95mV4K6xsRP3E3pVbuFYRbskFAIMWfs/Kh3iYcu8BHg7bfpD/ZCyr5eeBTQ636zocceZPmzONatURobT2t/m58/ofNlKtdke4hdnUmTOozaY311NttIzo/O7+HECCx8DFY56BEGJC0B1+QsQUOb8QMUXOL0RMkfMLEVPk/ELElNLedeMFWC5cpLGQ5J9DmWQ42DC3qYnafLSRa3h7B5UmNfLCmVVV4WKQj6xYTm0OOg9R5Yd4qCzbdZBquT5e6HJwMBxK6+vnYcWBCK0JPPutl4TzAGCoMrzN/og2ZBjihTjTSR7Oa50/n2of+dR5wfFJZ/JsywO9HVRr37ePajsGeFh3cw8voPrOU78Njl9x3RepzbzTTguOZ154jdoci678QsQUOb8QMUXOL0RMkfMLEVPk/ELEFDm/EDGlpKE+KzhS/eHQVzKiaGKuN5x1dsb8hdRmYPd+qm1ay7OvDne+QzVLhCuJTp/Je9bljIe2amp4/7naeh5iq6zmdg2ZcI+8XIKH0bIRPQPrBvj89w7weq3VJ4Uz1SoawuMAkErUUK1rXzgbFACM9CcEgAwJOdbWpKnN1gM8LDfnZB5WbGqspdp5n+b9IXfvDRfqtFq+vTkt4fe58v5fU5tj0ZVfiJgi5xcipsj5hYgpcn4hYoqcX4iYUtLV/gQSyOTDK9V9ef45lPTwSnXnHr7avPhMXlfv88v+jmqTpvPV6F2728Pz2LGT2vQP8NqEuTRP+inPUAk1rH8ZgDoLR02SVbyGXydJBgKAkxp5Hbk5DXyVfXt3OMnlrIsuoTb10/l7hj4+x2ce/w3V3t4ffs+6t2+mNv/u2uupVhvR6i1RYNXuACR4SzHvC1fC7+rnEY539h8KjqfL+HvynimN+plCiD8p5PxCxBQ5vxAxRc4vREyR8wsRU+T8QsSUEUN9ZjYDwL8CmAKgAGC5u//QzG4B8BUAR2I6N7v7YyNsDMl0OGznOZ5AYpmwzbYuXk9tcx8PA16xlNdGazqZh7am7won/aQGeBjq8EGeYBRVA6+xhSd1rF+5mmprn1kZHH9nwwZqc3CQhxxfreC1BC+76nKqNc6ZHRzPTp5KbdDKw2jo53ULt+fDYS8AeGrN88HxQoon9nz689dQLRGRcFXgnbxAcsIAAFYVTmhqqOfh2bqp4dZxFRU86etYRhPnzwH4uruvNrMaAK+Y2RNF7VZ3/96o9yaEOGEYTa++XQB2FR93m9l6ALyToRDiQ8H7+s1vZrMAfBzAS8WhG81snZndZWbhdqhCiBOSUTu/mVUDeAjA19z9MIAfAZgLYCGGvxl8n9gtM7NVZrYqG/G7XghRWkbl/GaWxrDj3+PuPwcAd9/j7nl3LwC4HcDikK27L3f3NndvS6f4YokQorSM6PxmZgDuBLDe3X9w1HjrUU+7CsDrx396QojxYjSr/UsAXAfgNTNbWxy7GcC1ZrYQgAPYBoCnyhWxpCFVH95lY5rXb3MLh2V279zFbU7iobLM/MlUG4rIpque3hIcT/TztluV83h9PxTC2VwA4MZDW5O75lDN1mwKju9cybPYBvt4xlnTkj+j2mvtPIx57rxwrbvmyeEQ1fBE+HGMipWV1/D6hJX14Te0opKH0dIRreMQEbLziKS+XIRhik6fh5AHc+G4YsFH/9N6NKv9zwEIvazomL4Q4oRGd/gJEVPk/ELEFDm/EDFFzi9ETJHzCxFTSlvAM5lEdUN1UOvt4aGtZCJ8c1A+w0NUHz//k3we5VVU68/1Ua2iEJ5HWQXfHvI8XIMcv+nJUjzmOH0Gbxl1znnh8eXf+Sm3OeNcPo8mnoW34BPcbuv27cHxebNPoTblDTzcizwPYVWW8WOVI8VJK5p5e7hIIu5TS0Zo2SwP9WWz4XZ0ySQ/v8tI6NMiwo3Hoiu/EDFFzi9ETJHzCxFT5PxCxBQ5vxAxRc4vREwpaagvO5RF+/bdQa2hmhcC6ukN97v7p2/8E7W55GJeXDLqM68qxedheRJ6Mb69XJbHXlJlvIgkjIeG0inej23jlheC44kkL47Z1BDRI6+Zh/oyU3iG3pJFZwTHewd4/7nyQsTxSIZDxABQU8fn2N0XPv5T0jzr0yOObzYi8bAQkfGXSPBzJJ0iRTdzfGeJZPhY2fu4nuvKL0RMkfMLEVPk/ELEFDm/EDFFzi9ETJHzCxFTShrqmzd3Ph59+IGgVm48vJJGOKzRQPqVAYBHVFPsj4jXJNL8kORIKCcf8RGarOAhqsEB3quvMMCzHNMJ3o/tuZXrguOLzv0UtXll4w6qLa68iGqVLU1U2z0YLk46qZ6H2HoiUtKqI8Kig8azAXsHwnZntvGMxIoKvj3SanIYnoQH5CPS7Tx8zuUH+AZz2fBJ57nRp/Xpyi9ETJHzCxFT5PxCxBQ5vxAxRc4vREwZcbXfzMoBPAsgU3z+g+7+LTObDeA+AI0AVgO4zt0jCtYB6bIUJs+YEtQy4HXYjGm5HLcZ4iullWX8ZWejkinS4ZXjiFyPyE/X7p6DVNvz9haq5Xr4Yc73hmsQJhJ8tbxrIJw4BQA40EGlJh6gQZ+HX3l5RUTdQr45DEQc5IqIiEqOtFIb6uYJRs89/TjVamp5tMIilvu3beft0g4fCtfw6+/jxyqXD/tE57591OZYRnPlHwRwkbsvwHA77svM7JMAvgPgVnefD6ALwJdHvVchxIQzovP7MEcC0uniPwdwEYAHi+MrAHxuXGYohBgXRvWb38ySxQ69nQCeALAFwEF3P/K9ux3AtPGZohBiPBiV87t73t0XApgOYDGAU0NPC9ma2TIzW2Vmq/bu4y2dhRCl5X2t9rv7QQDPAPgkgHozO7JyNh1AcGXI3Ze7e5u7t01q5reDCiFKy4jOb2aTzKy++LgCwCUA1gN4GsBfFJ92PYBfjtckhRDHn9Ek9rQCWGFmSQx/WDzg7r8yszcB3Gdm/wPAGgB3jrglMyAVDuj05cLhDgCoSpIgUFT8J8NDh4hoyeUR4ZoswqFFi+jhNDDEk3ee+u0jVPv5v62g2qxmntBU6A7PsSoVDrECwCnzZlLNdofbbgHAvg2rqTZzwZzgeB48rDiU5adjfZonMyHHQ58+ED6vfvaTH1Objt08vLnnQCfVyiLCmA3NjVSrrW0Jjnf38SyiAsLJR10Hefj4WEZ0fndfB+DjgfGtGP79L4T4EKI7/ISIKXJ+IWKKnF+ImCLnFyKmyPmFiCnmHlV47DjvzGwvgCOxo2YAo09BGj80j3ejebybD9s8Zro77812FCV1/nft2GyVu7dNyM41D81D89DXfiHiipxfiJgykc6/fAL3fTSax7vRPN7Nn+w8Juw3vxBiYtHXfiFiyoQ4v5ldZmYbzWyzmd00EXMozmObmb1mZmvNbFUJ93uXmXWa2etHjTWa2RNmtqn4t2GC5nGLmb1TPCZrzeyKEsxjhpk9bWbrzewNM/uH4nhJj0nEPEp6TMys3MxeNrNXi/P478Xx2Wb2UvF43G9mUc3DRsbdS/oPQBLDZcDmACgD8CqA00o9j+JctgFonoD9ngdgEYDXjxr7LoCbio9vAvCdCZrHLQD+S4mPRyuARcXHNQDeAnBaqY9JxDxKekwwXMi4uvg4DeAlDBfQeQDANcXx/wPgq2PZz0Rc+RcD2OzuW3241Pd9AJZOwDwmDHd/FsCBY4aXYrgQKlCigqhkHiXH3Xe5++ri424MF4uZhhIfk4h5lBQfZtyL5k6E808DsPOo/09k8U8H8LiZvWJmyyZoDkdocfddwPBJCGDyBM7lRjNbV/xZMO4/P47GzGZhuH7ES5jAY3LMPIASH5NSFM2dCOcPleWZqJDDEndfBOByADeY2XkTNI8TiR8BmIvhHg27AHy/VDs2s2oADwH4mruHe3xPzDxKfkx8DEVzR8tEOH87gBlH/Z8W/xxv3L2j+LcTwMOY2MpEe8ysFQCKf3m9qHHE3fcUT7wCgNtRomNiZmkMO9w97v7z4nDJj0loHhN1TIr7ft9Fc0fLRDj/SgDziyuXZQCuAcCL2Y0TZlZlZjVHHgNzGQ9bAAAA0klEQVS4FMDr0VbjyiMYLoQKTGBB1CPOVuQqlOCYmJlhuAbkenf/wVFSSY8Jm0epj0nJiuaWagXzmNXMKzC8kroFwH+boDnMwXCk4VUAb5RyHgDuxfDXxyyGvwl9GUATgCcBbCr+bZygefwbgNcArMOw87WWYB7nYPgr7DoAa4v/rij1MYmYR0mPCYAzMFwUdx2GP2i+edQ5+zKAzQB+BiAzlv3oDj8hYoru8BMipsj5hYgpcn4hYoqcX4iYIucXIqbI+YWIKXJ+IWKKnF+ImPL/AesgMEngqdqlAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_image(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Actual: 40 (Roundabout mandatory)\n",
      "Turn left ahead (class: 34) 1.00 \n",
      "Speed limit (20km/h) (class: 0) 0.00 \n",
      "Speed limit (30km/h) (class: 1) 0.00 \n",
      "Speed limit (50km/h) (class: 2) 0.00 \n",
      "Speed limit (60km/h) (class: 3) 0.00 \n"
     ]
    },
    {
     "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": [
    "show_image(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Actual: 39 (Keep left)\n",
      "Keep left (class: 39) 1.00 (correct)\n",
      "Speed limit (20km/h) (class: 0) 0.00 \n",
      "Speed limit (30km/h) (class: 1) 0.00 \n",
      "Speed limit (50km/h) (class: 2) 0.00 \n",
      "Speed limit (60km/h) (class: 3) 0.00 \n"
     ]
    },
    {
     "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": [
    "show_image(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Actual: 4 (Speed limit (70km/h))\n",
      "Speed limit (70km/h) (class: 4) 1.00 (correct)\n",
      "Speed limit (20km/h) (class: 0) 0.00 \n",
      "Speed limit (30km/h) (class: 1) 0.00 \n",
      "Speed limit (50km/h) (class: 2) 0.00 \n",
      "Speed limit (60km/h) (class: 3) 0.00 \n"
     ]
    },
    {
     "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": [
    "show_image(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Actual: 21 (Double curve)\n",
      "Double curve (class: 21) 1.00 (correct)\n",
      "Speed limit (20km/h) (class: 0) 0.00 \n",
      "Speed limit (30km/h) (class: 1) 0.00 \n",
      "Speed limit (50km/h) (class: 2) 0.00 \n",
      "Speed limit (60km/h) (class: 3) 0.00 \n"
     ]
    },
    {
     "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": [
    "show_image(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6\n"
     ]
    }
   ],
   "source": [
    "# Accuracy on 5 images:\n",
    "picks = list(map(lambda r: r[0], ranking_indexes))\n",
    "matches = list(map(lambda m: m[0] == m[1], zip(picks, correct)))\n",
    "print(len(list(filter(lambda x: x, matches))) / float(len(matches)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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"
  },
  "widgets": {
   "state": {},
   "version": "1.1.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}