Traffic_Light_Classifier.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Traffic Light Classifier\n",
    "---\n",
    "\n",
    "In this project, you’ll use your knowledge of computer vision techniques to build a classifier for images of traffic lights! You'll be given a dataset of traffic light images in which one of three lights is illuminated: red, yellow, or green.\n",
    "\n",
    "In this notebook, you'll pre-process these images, extract features that will help us distinguish the different types of images, and use those features to classify the traffic light images into three classes: red, yellow, or green. The tasks will be broken down into a few sections:\n",
    "\n",
    "1. **Loading and visualizing the data**. \n",
    "      The first step in any classification task is to be familiar with your data; you'll need to load in the images of traffic lights and visualize them!\n",
    "\n",
    "2. **Pre-processing**. \n",
    "    The input images and output labels need to be standardized. This way, you can analyze all the input images using the same classification pipeline, and you know what output to expect when you eventually classify a *new* image.\n",
    "    \n",
    "3. **Feature extraction**. \n",
    "    Next, you'll extract some features from each image that will help distinguish and eventually classify these images.\n",
    "   \n",
    "4. **Classification and visualizing error**. \n",
    "    Finally, you'll write one function that uses your features to classify *any* traffic light image. This function will take in an image and output a label. You'll also be given code to determine the accuracy of your classification model.    \n",
    "    \n",
    "5. **Evaluate your model**.\n",
    "    To pass this project, your classifier must be >90% accurate and never classify any red lights as green; it's likely that you'll need to improve the accuracy of your classifier by changing existing features or adding new features. I'd also encourage you to try to get as close to 100% accuracy as possible!\n",
    "    \n",
    "Here are some sample images from the dataset (from left to right: red, green, and yellow traffic lights):\n",
    "<img src=\"images/all_lights.png\" width=\"50%\" height=\"50%\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### *Here's what you need to know to complete the project:*\n",
    "\n",
    "Some template code has already been provided for you, but you'll need to implement additional code steps to successfully complete this project. Any code that is required to pass this project is marked with **'(IMPLEMENTATION)'** in the header. There are also a couple of questions about your thoughts as you work through this project, which are marked with **'(QUESTION)'** in the header. Make sure to answer all questions and to check your work against the [project rubric](https://review.udacity.com/#!/rubrics/1213/view) to make sure you complete the necessary classification steps!\n",
    "\n",
    "Your project submission will be evaluated based on the code implementations you provide, and on two main classification criteria.\n",
    "Your complete traffic light classifier should have:\n",
    "1. **Greater than 90% accuracy**\n",
    "2. ***Never* classify red lights as green**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Loading and Visualizing the Traffic Light Dataset\n",
    "\n",
    "This traffic light dataset consists of 1484 number of color images in 3 categories - red, yellow, and green. As with most human-sourced data, the data is not evenly distributed among the types. There are:\n",
    "* 904 red traffic light images\n",
    "* 536 green traffic light images\n",
    "* 44 yellow traffic light images\n",
    "\n",
    "*Note: All images come from this [MIT self-driving car course](https://selfdrivingcars.mit.edu/) and are licensed under a [Creative Commons Attribution-ShareAlike 4.0 International License](https://creativecommons.org/licenses/by-sa/4.0/).*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import resources\n",
    "\n",
    "Before you get started on the project code, import the libraries and resources that you'll need."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2 # computer vision library\n",
    "import helpers # helper functions\n",
    "\n",
    "import random\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.image as mpimg # for loading in images\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training and Testing Data\n",
    "\n",
    "All 1484 of the traffic light images are separated into training and testing datasets. \n",
    "\n",
    "* 80% of these images are training images, for you to use as you create a classifier.\n",
    "* 20% are test images, which will be used to test the accuracy of your classifier.\n",
    "* All images are pictures of 3-light traffic lights with one light illuminated.\n",
    "\n",
    "## Define the image directories\n",
    "\n",
    "First, we set some variables to keep track of some where our images are stored:\n",
    "\n",
    "    IMAGE_DIR_TRAINING: the directory where our training image data is stored\n",
    "    IMAGE_DIR_TEST: the directory where our test image data is stored"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Image data directories\n",
    "IMAGE_DIR_TRAINING = \"traffic_light_images/training/\"\n",
    "IMAGE_DIR_TEST = \"traffic_light_images/test/\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load the datasets\n",
    "\n",
    "These first few lines of code will load the training traffic light images and store all of them in a variable, `IMAGE_LIST`. This list contains the images and their associated label (\"red\", \"yellow\", \"green\"). \n",
    "\n",
    "You are encouraged to take a look at the `load_dataset` function in the helpers.py file. This will give you a good idea about how lots of image files can be read in from a directory using the [glob library](https://pymotw.com/2/glob/). The `load_dataset` function takes in the name of an image directory and returns a list of images and their associated labels. \n",
    "\n",
    "For example, the first image-label pair in `IMAGE_LIST` can be accessed by index: \n",
    "``` IMAGE_LIST[0][:]```.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Using the load_dataset function in helpers.py\n",
    "# Load training data\n",
    "IMAGE_LIST = helpers.load_dataset(IMAGE_DIR_TRAINING)\n",
    "#print(IMAGE_LIST[0][0][81]) #SW: only for demonstration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualize the Data\n",
    "\n",
    "The first steps in analyzing any dataset are to 1. load the data and 2. look at the data. Seeing what it looks like will give you an idea of what to look for in the images, what kind of noise or inconsistencies you have to deal with, and so on. This will help you understand the image dataset, and **understanding a dataset is part of making predictions about the data**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### Visualize the input images\n",
    "\n",
    "Visualize and explore the image data! Write code to display an image in `IMAGE_LIST`:\n",
    "* Display the image\n",
    "* Print out the shape of the image \n",
    "* Print out its corresponding label\n",
    "\n",
    "See if you can display at least one of each type of traffic light image – red, green, and yellow — and look at their similarities and differences."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape: (83, 53, 3)\n",
      "Label (=color): yellow\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fba91fd7ac8>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "## TODO: Write code to display an image in IMAGE_LIST (try finding a yellow traffic light!)\n",
    "## TODO: Print out 1. The shape of the image and 2. The image's label\n",
    "\n",
    "image_number = 750 # hier kann man ein anderes Bild aus dem Trainingsset auswählen von 0 ... 1186 (= 0,80 * 1484)\n",
    "selected_image = IMAGE_LIST[image_number][0]\n",
    "selected_image_label = IMAGE_LIST[image_number][1]\n",
    "plt.imshow(selected_image)\n",
    "print(\"Shape: \"+str(selected_image.shape))\n",
    "print(\"Label (=color): \" + str(selected_image_label))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Pre-process the Data\n",
    "\n",
    "After loading in each image, you have to standardize the input and output!\n",
    "\n",
    "### Input\n",
    "\n",
    "This means that every input image should be in the same format, of the same size, and so on. We'll be creating features by performing the same analysis on every picture, and for a classification task like this, it's important that **similar images create similar features**! \n",
    "\n",
    "### Output\n",
    "\n",
    "We also need the output to be a label that is easy to read and easy to compare with other labels. It is good practice to convert categorical data like \"red\" and \"green\" to numerical data.\n",
    "\n",
    "A very common classification output is a 1D list that is the length of the number of classes - three in the case of red, yellow, and green lights - with the values 0 or 1 indicating which class a certain image is. For example, since we have three classes (red, yellow, and green), we can make a list with the order: [red value, yellow value, green value]. In general, order does not matter, we choose the order [red value, yellow value, green value] in this case to reflect the position of each light in descending vertical order.\n",
    "\n",
    "A red light should have the  label: [1, 0, 0]. Yellow should be: [0, 1, 0]. Green should be: [0, 0, 1]. These labels are called **one-hot encoded labels**.\n",
    "\n",
    "*(Note: one-hot encoding will be especially important when you work with [machine learning algorithms](https://machinelearningmastery.com/how-to-one-hot-encode-sequence-data-in-python/)).*\n",
    "\n",
    "<img src=\"images/processing_steps.png\" width=\"80%\" height=\"80%\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<a id='task2'></a>\n",
    "### (IMPLEMENTATION): Standardize the input images\n",
    "\n",
    "* Resize each image to the desired input size: 32x32px.\n",
    "* (Optional) You may choose to crop, shift, or rotate the images in this step as well.\n",
    "\n",
    "It's very common to have square input sizes that can be rotated (and remain the same size), and analyzed in smaller, square patches. It's also important to make all your images the same size so that they can be sent through the same pipeline of classification steps!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This function should take in an RGB image and return a new, standardized version\n",
    "def standardize_input(image):\n",
    "    \n",
    "    ## TODO: Resize image and pre-process so that all \"standard\" images are the same size  \n",
    "    standard_im = cv2.resize(np.copy(image),(32, 32))\n",
    "        \n",
    "    return standard_im"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Standardize the output\n",
    "\n",
    "With each loaded image, we also specify the expected output. For this, we use **one-hot encoding**.\n",
    "\n",
    "* One-hot encode the labels. To do this, create an array of zeros representing each class of traffic light (red, yellow, green), and set the index of the expected class number to 1. \n",
    "\n",
    "Since we have three classes (red, yellow, and green), we have imposed an order of: [red value, yellow value, green value]. To one-hot encode, say, a yellow light, we would first initialize an array to [0, 0, 0] and change the middle value (the yellow value) to 1: [0, 1, 0].\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<a id='task3'></a>\n",
    "### (IMPLEMENTATION): Implement one-hot encoding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "## TODO: One hot encode an image label\n",
    "## Given a label - \"red\", \"green\", or \"yellow\" - return a one-hot encoded label\n",
    "\n",
    "# Examples: \n",
    "# one_hot_encode(\"red\") should return: [1, 0, 0]\n",
    "# one_hot_encode(\"yellow\") should return: [0, 1, 0]\n",
    "# one_hot_encode(\"green\") should return: [0, 0, 1]\n",
    "\n",
    "def one_hot_encode(label):\n",
    "    \n",
    "    ## TODO: Create a one-hot encoded label that works for all classes of traffic lights\n",
    "    one_hot_encoded = []\n",
    "    \n",
    "    if label == \"red\":\n",
    "        one_hot_encoded = [1, 0, 0]\n",
    "        \n",
    "    if label == \"yellow\":\n",
    "        one_hot_encoded = [0, 1, 0]\n",
    "        \n",
    "    if label == \"green\":\n",
    "        one_hot_encoded = [0, 0, 1]\n",
    "        \n",
    "    return one_hot_encoded"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Testing as you Code\n",
    "\n",
    "After programming a function like this, it's a good idea to test it, and see if it produces the expected output. **In general, it's good practice to test code in small, functional pieces, after you write it**. This way, you can make sure that your code is correct as you continue to build a classifier, and you can identify any errors early on so that they don't compound.\n",
    "\n",
    "All test code can be found in the file `test_functions.py`. You are encouraged to look through that code and add your own testing code if you find it useful!\n",
    "\n",
    "One test function you'll find is: `test_one_hot(self, one_hot_function)` which takes in one argument, a one_hot_encode function, and tests its functionality. If your one_hot_label code does not work as expected, this test will print ot an error message that will tell you a bit about why your code failed. Once your code works, this should print out TEST PASSED."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "**<span style=\"color: green;\">TEST PASSED</span>**"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Importing the tests\n",
    "import test_functions\n",
    "tests = test_functions.Tests()\n",
    "\n",
    "# Test for one_hot_encode function\n",
    "tests.test_one_hot(one_hot_encode)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Construct a `STANDARDIZED_LIST` of input images and output labels.\n",
    "\n",
    "This function takes in a list of image-label pairs and outputs a **standardized** list of resized images and one-hot encoded labels.\n",
    "\n",
    "This uses the functions you defined above to standardize the input and output, so those functions must be complete for this standardization to work!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "def standardize(image_list):\n",
    "    \n",
    "    # Empty image data array\n",
    "    standard_list = []\n",
    "\n",
    "    # Iterate through all the image-label pairs\n",
    "    for item in image_list:\n",
    "        image = item[0]\n",
    "        label = item[1]\n",
    "\n",
    "        # Standardize the image\n",
    "        standardized_im = standardize_input(image)\n",
    "\n",
    "        # One-hot encode the label\n",
    "        one_hot_label = one_hot_encode(label)    \n",
    "\n",
    "        # Append the image, and it's one hot encoded label to the full, processed list of image data \n",
    "        standard_list.append((standardized_im, one_hot_label))\n",
    "        \n",
    "    return standard_list\n",
    "\n",
    "# Standardize all training images\n",
    "STANDARDIZED_LIST = standardize(IMAGE_LIST)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualize the standardized data\n",
    "\n",
    "Display a standardized image from STANDARDIZED_LIST and compare it with a non-standardized image from IMAGE_LIST. Note that their sizes and appearance are different!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Standardized Label: [0, 1, 0]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fba8f35f7f0>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "## TODO: Display a standardized image and its label\n",
    "\n",
    "selected_standardized_image = STANDARDIZED_LIST[image_number][0]\n",
    "selected_standardized_image_label = STANDARDIZED_LIST[image_number][1]\n",
    "plt.imshow(selected_standardized_image)\n",
    "print(\"Standardized Label: \" + str(selected_standardized_image_label))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Feature Extraction\n",
    "\n",
    "You'll be using what you now about color spaces, shape analysis, and feature construction to create features that help distinguish and classify the three types of traffic light images.\n",
    "\n",
    "You'll be tasked with creating **one feature** at a minimum (with the option to create more). The required feature is **a brightness feature using HSV color space**:\n",
    "\n",
    "1. A brightness feature.\n",
    "    - Using HSV color space, create a feature that helps you identify the 3 different classes of traffic light.\n",
    "    - You'll be asked some questions about what methods you tried to locate this traffic light, so, as you progress through this notebook, always be thinking about your approach: what works and what doesn't?\n",
    "\n",
    "2. (Optional): Create more features! \n",
    "\n",
    "Any more features that you create are up to you and should improve the accuracy of your traffic light classification algorithm! One thing to note is that, to pass this project you must **never classify a red light as a green light** because this creates a serious safety risk for a self-driving car. To avoid this misclassification, you might consider adding another feature that specifically distinguishes between red and green lights.\n",
    "\n",
    "These features will be combined near the end of his notebook to form a complete classification algorithm."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating a brightness feature \n",
    "\n",
    "There are a number of ways to create a brightness feature that will help you characterize images of traffic lights, and it will be up to you to decide on the best procedure to complete this step. You should visualize and test your code as you go.\n",
    "\n",
    "Pictured below is a sample pipeline for creating a brightness feature (from left to right: standardized image, HSV color-masked image, cropped image, brightness feature):\n",
    "\n",
    "<img src=\"images/feature_ext_steps.png\" width=\"70%\" height=\"70%\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## RGB to HSV conversion\n",
    "\n",
    "Below, a test image is converted from RGB to HSV colorspace and each component is displayed in an image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Label [red, yellow, green]: [1, 0, 0]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fba8f1fff28>"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fba8f4adba8>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Convert and image to HSV colorspace\n",
    "# Visualize the individual color channels\n",
    "\n",
    "image_num = 500 # gelbe Ampeln sind von 723 bis 757, also 35 Stück\n",
    "test_im = STANDARDIZED_LIST[image_num][0]\n",
    "test_label = STANDARDIZED_LIST[image_num][1]\n",
    "\n",
    "# Convert to HSV\n",
    "hsv = cv2.cvtColor(test_im, cv2.COLOR_RGB2HSV)\n",
    "\n",
    "# Print image label\n",
    "print('Label [red, yellow, green]: ' + str(test_label))\n",
    "\n",
    "# HSV channels\n",
    "h = hsv[:,:,0]\n",
    "s = hsv[:,:,1]\n",
    "v = hsv[:,:,2]\n",
    "\n",
    "# Plot the original image and the three channels\n",
    "f, (ax1, ax2, ax3, ax4) = plt.subplots(1, 4, figsize=(20,10))\n",
    "ax1.set_title('Standardized image')\n",
    "ax1.imshow(test_im)\n",
    "ax2.set_title('H channel')\n",
    "ax2.imshow(h, cmap='gray')\n",
    "ax3.set_title('S channel')\n",
    "ax3.imshow(s, cmap='gray')\n",
    "ax4.set_title('V channel')\n",
    "ax4.imshow(v, cmap='gray')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<a id='task7'></a>\n",
    "### (IMPLEMENTATION): Create a brightness feature that uses HSV color space\n",
    "\n",
    "Write a function that takes in an RGB image and returns a 1D feature vector and/or single value that will help classify an image of a traffic light. The only requirement is that this function should apply an HSV colorspace transformation, the rest is up to you. \n",
    "\n",
    "From this feature, you should be able to estimate an image's label and classify it as either a red, green, or yellow traffic light. You may also define helper functions if they simplify your code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {},
   "outputs": [],
   "source": [
    "## TODO: Create a brightness feature that takes in an RGB image and outputs a feature vector and/or value\n",
    "## This feature should use HSV colorspace values\n",
    "def create_feature(rgb_image):\n",
    "    \n",
    "    ## TODO: Convert image to HSV color space\n",
    "    hsv = cv2.cvtColor((np.copy(rgb_image)), cv2.COLOR_RGB2HSV)\n",
    "    \n",
    "    ## TODO: Create and return a feature value and/or vector\n",
    "    feature = [] # one-hot encoded label\n",
    "    \n",
    "    # keep the v-channel and throw away the rest\n",
    "    v = hsv[:,:,2]\n",
    "    \n",
    "    # identify three regions >> this is the biggest challenge. Regions can overlap\n",
    "    redRegion = v[1:10, 12:18] # from row 4 ... 12 and column 12 ... 22\n",
    "    yellowRegion = v[12:22, 12:18]\n",
    "    greenRegion = v[23:32, 12:18]\n",
    "    \n",
    "    # sum of brightness per region. You can use numpy.sum(array) to sum all the values of the region.\n",
    "    sum_brightness_redRegion = np.sum(redRegion)\n",
    "    sum_brightness_yellowRegion = np.sum(yellowRegion)\n",
    "    sum_brightness_greenRegion = np.sum(greenRegion)\n",
    "    \n",
    "    # classify based on sum_brightnesses per region. Numpy's argmax function might help.\n",
    "    max_value = max(sum_brightness_redRegion, sum_brightness_yellowRegion, sum_brightness_greenRegion)\n",
    "    \n",
    "    if max_value == sum_brightness_redRegion:\n",
    "        feature = [1,0,0]\n",
    "        \n",
    "    if max_value == sum_brightness_yellowRegion:\n",
    "        feature = [0,1,0]\n",
    "        \n",
    "    if max_value == sum_brightness_greenRegion:\n",
    "        feature = [0,0,1]\n",
    "    \n",
    "    return feature"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## (Optional) Create more features to help accurately label the traffic light images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [],
   "source": [
    "# (Optional) Add more image analysis and create more features."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## (QUESTION 1): How do the features you made help you distinguish between the 3 classes of traffic light images?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Answer:**\n",
    "First the RGB image is converted to HSV color space because then you can use the V(alue)-Channel (brightness) to create a brightness feature. An image can be separated into three regions top-down: Red region, yellow region and green region. These regions are slightly same-sized but the first region (red region) is slightly smaller than the other two regions because testing showed that first, too many green or yellow images were classified red. \n",
    "\n",
    "Only because of the standard, that a traffic light has its red color in the topmost part, yellow in the middle and green in the bottommost part, you can create a feature like this that works with brightness. Otherwise you would have to create a feature with the H(ue)-Channel."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# 4. Classification and Visualizing Error\n",
    "\n",
    "Using all of your features, write a function that takes in an RGB image and, using your extracted features, outputs whether a light is red, green or yellow as a one-hot encoded label. This classification function should be able to classify any image of a traffic light!\n",
    "\n",
    "You are encouraged to write any helper functions or visualization code that you may need, but for testing the accuracy, make sure that this `estimate_label` function returns a one-hot encoded label."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<a id='task8'></a>\n",
    "### (IMPLEMENTATION): Build a complete classifier "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This function should take in RGB image input\n",
    "# Analyze that image using your feature creation code and output a one-hot encoded label\n",
    "def estimate_label(rgb_image):\n",
    "    \n",
    "    ## TODO: Extract feature(s) from the RGB image and use those features to classify the image and output a one-hot encoded label\n",
    "    predicted_label = create_feature(rgb_image)\n",
    "    \n",
    "    return predicted_label"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing the classifier\n",
    "\n",
    "Here is where we test your classification algorithm using our test set of data that we set aside at the beginning of the notebook! This project will be complete once you've pogrammed a \"good\" classifier.\n",
    "\n",
    "A \"good\" classifier in this case should meet the following criteria (and once it does, feel free to submit your project):\n",
    "1. Get above 90% classification accuracy.\n",
    "2. Never classify a red light as a green light. \n",
    "\n",
    "### Test dataset\n",
    "\n",
    "Below, we load in the test dataset, standardize it using the `standardize` function you defined above, and then **shuffle** it; this ensures that order will not play a role in testing accuracy.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Using the load_dataset function in helpers.py\n",
    "# Load test data\n",
    "TEST_IMAGE_LIST = helpers.load_dataset(IMAGE_DIR_TEST)\n",
    "\n",
    "# Standardize the test data\n",
    "STANDARDIZED_TEST_LIST = standardize(TEST_IMAGE_LIST)\n",
    "\n",
    "# Shuffle the standardized test data\n",
    "random.shuffle(STANDARDIZED_TEST_LIST)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Determine the Accuracy\n",
    "\n",
    "Compare the output of your classification algorithm (a.k.a. your \"model\") with the true labels and determine the accuracy.\n",
    "\n",
    "This code stores all the misclassified images, their predicted labels, and their true labels, in a list called `MISCLASSIFIED`. This code is used for testing and *should not be changed*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.9629629629629629\n",
      "Number of misclassified images = 11 out of 297\n"
     ]
    }
   ],
   "source": [
    "# Constructs a list of misclassified images given a list of test images and their labels\n",
    "# This will throw an AssertionError if labels are not standardized (one-hot encoded)\n",
    "\n",
    "def get_misclassified_images(test_images):\n",
    "    # Track misclassified images by placing them into a list\n",
    "    misclassified_images_labels = []\n",
    "\n",
    "    # Iterate through all the test images\n",
    "    # Classify each image and compare to the true label\n",
    "    for image in test_images:\n",
    "\n",
    "        # Get true data\n",
    "        im = image[0]\n",
    "        true_label = image[1]\n",
    "        assert(len(true_label) == 3), \"The true_label is not the expected length (3).\"\n",
    "\n",
    "        # Get predicted label from your classifier\n",
    "        predicted_label = estimate_label(im)\n",
    "        assert(len(predicted_label) == 3), \"The predicted_label is not the expected length (3).\"\n",
    "\n",
    "        # Compare true and predicted labels \n",
    "        if(predicted_label != true_label):\n",
    "            # If these labels are not equal, the image has been misclassified\n",
    "            misclassified_images_labels.append((im, predicted_label, true_label))\n",
    "            \n",
    "    # Return the list of misclassified [image, predicted_label, true_label] values\n",
    "    return misclassified_images_labels\n",
    "\n",
    "\n",
    "# Find all misclassified images in a given test set\n",
    "MISCLASSIFIED = get_misclassified_images(STANDARDIZED_TEST_LIST)\n",
    "\n",
    "# Accuracy calculations\n",
    "total = len(STANDARDIZED_TEST_LIST)\n",
    "num_correct = total - len(MISCLASSIFIED)\n",
    "accuracy = num_correct/total\n",
    "\n",
    "print('Accuracy: ' + str(accuracy))\n",
    "print(\"Number of misclassified images = \" + str(len(MISCLASSIFIED)) +' out of '+ str(total))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<a id='task9'></a>\n",
    "### Visualize the misclassified images\n",
    "\n",
    "Visualize some of the images you classified wrong (in the `MISCLASSIFIED` list) and note any qualities that make them difficult to classify. This will help you identify any weaknesses in your classification algorithm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predictetd Label: [0, 1, 0]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fba8be2b5f8>"
      ]
     },
     "execution_count": 216,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fba8bf60be0>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize misclassified example(s)\n",
    "## TODO: Display an image in the `MISCLASSIFIED` list \n",
    "## TODO: Print out its predicted label - to see what the image *was* incorrectly classified as\n",
    "\n",
    "num = 8\n",
    "test_mis_im = MISCLASSIFIED[num][0]\n",
    "print(\"Predictetd Label: \" + str(MISCLASSIFIED[num][1]))\n",
    "\n",
    "# Convert to HSV\n",
    "hsv_misclassified = cv2.cvtColor(test_mis_im, cv2.COLOR_RGB2HSV)\n",
    "\n",
    "# Visualize the individual v-channel\n",
    "v_mis = hsv_misclassified[:,:,2]\n",
    "\n",
    "# Plot the original misclassified image and the h-channel\n",
    "f, (ax1, ax2) = plt.subplots(1, 2, figsize=(20,10))\n",
    "ax1.set_title('Standardized image')\n",
    "ax1.imshow(test_mis_im)\n",
    "ax2.set_title('V channel')\n",
    "ax2.imshow(v_mis, cmap='gray')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<a id='question2'></a>\n",
    "## (Question 2): After visualizing these misclassifications, what weaknesses do you think your classification algorithm has? Please note at least two."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Answer:*\n",
    "\n",
    "- some green lights are still classified red\n",
    "- when there is blue sky or other bright background visible above the traffic lights, a green traffic light can be classified as red because brightness is high in the topmost region\n",
    "- no color detection with H(ue)-Channel wich could be an additional feature and give additional certainty about the right color\n",
    "- region-based classification is vulnerable because lights are not always in the same position.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test if you classify any red lights as green\n",
    "\n",
    "**To pass this project, you must not classify any red lights as green!** Classifying red lights as green would cause a car to drive through a red traffic light, so this red-as-green error is very dangerous in the real world. \n",
    "\n",
    "The code below lets you test to see if you've misclassified any red lights as green in the test set. **This test assumes that `MISCLASSIFIED` is a list of tuples with the order: [misclassified_image, predicted_label, true_label].**\n",
    "\n",
    "Note: this is not an all encompassing test, but its a good indicator that, if you pass, you are on the right track! This iterates through your list of misclassified examples and checks to see if any red traffic lights have been mistakenly labelled [0, 1, 0] (green)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "**<span style=\"color: green;\">TEST PASSED</span>**"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Importing the tests\n",
    "import test_functions\n",
    "tests = test_functions.Tests()\n",
    "\n",
    "if(len(MISCLASSIFIED) > 0):\n",
    "    # Test code for one_hot_encode function\n",
    "    tests.test_red_as_green(MISCLASSIFIED)\n",
    "else:\n",
    "    print(\"MISCLASSIFIED may not have been populated with images.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. Improve your algorithm!\n",
    "\n",
    "**Submit your project after you have completed all implementations, answered all questions, AND when you've met the two criteria:**\n",
    "1. Greater than 90% accuracy classification\n",
    "2. No red lights classified as green\n",
    "\n",
    "If you did not meet these requirements (which is common on the first attempt!), revisit your algorithm and tweak it to improve light recognition -- this could mean changing the brightness feature, performing some background subtraction, or adding another feature!\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Going Further (Optional Challenges)\n",
    "\n",
    "If you found this challenge easy, I suggest you go above and beyond! Here are a couple **optional** (meaning you do not need to implement these to submit and pass the project) suggestions:\n",
    "* (Optional) Aim for >95% classification accuracy.\n",
    "* (Optional) Some lights are in the shape of arrows; further classify the lights as round or arrow-shaped.\n",
    "* (Optional) Add another feature and aim for as close to 100% accuracy as you can get!"
   ]
  },
  {
   "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}