{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LEARNING\n",
    "\n",
    "This notebook serves as supporting material for topics covered in **Chapter 18 - Learning from Examples** , **Chapter 19 - Knowledge in Learning**, **Chapter 20 - Learning Probabilistic Models** from the book *Artificial Intelligence: A Modern Approach*. This notebook uses implementations from [learning.py](https://github.com/aimacode/aima-python/blob/master/learning.py). Let's start by importing everything from the module:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "from learning import *\n",
    "from notebook import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CONTENTS\n",
    "\n",
    "* Machine Learning Overview\n",
    "* Datasets\n",
    "* Iris Visualization\n",
    "* Distance Functions\n",
    "* Plurality Learner\n",
    "* k-Nearest Neighbours\n",
    "* Decision Tree Learner\n",
    "* Random Forest Learner\n",
    "* Naive Bayes Learner\n",
    "* Perceptron\n",
    "* Learner Evaluation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MACHINE LEARNING OVERVIEW\n",
    "\n",
    "In this notebook, we learn about agents that can improve their behavior through diligent study of their own experiences.\n",
    "\n",
    "An agent is **learning** if it improves its performance on future tasks after making observations about the world.\n",
    "\n",
    "There are three types of feedback that determine the three main types of learning:\n",
    "\n",
    "* **Supervised Learning**:\n",
    "\n",
    "In Supervised Learning the agent observes some example input-output pairs and learns a function that maps from input to output.\n",
    "\n",
    "**Example**: Let's think of an agent to classify images containing cats or dogs. If we provide an image containing a cat or a dog, this agent should output a string \"cat\" or \"dog\" for that particular image. To teach this agent, we will give a lot of input-output pairs like {cat image-\"cat\"}, {dog image-\"dog\"} to the agent. The agent then learns a function that maps from an input image to one of those strings.\n",
    "\n",
    "* **Unsupervised Learning**:\n",
    "\n",
    "In Unsupervised Learning the agent learns patterns in the input even though no explicit feedback is supplied. The most common type is **clustering**: detecting potential useful clusters of input examples.\n",
    "\n",
    "**Example**: A taxi agent would develop a concept of *good traffic days* and *bad traffic days* without ever being given labeled examples.\n",
    "\n",
    "* **Reinforcement Learning**:\n",
    "\n",
    "In Reinforcement Learning the agent learns from a series of reinforcements—rewards or punishments.\n",
    "\n",
    "**Example**: Let's talk about an agent to play the popular Atari game—[Pong](http://www.ponggame.org). We will reward a point for every correct move and deduct a point for every wrong move from the agent. Eventually, the agent will figure out its actions prior to reinforcement were most responsible for it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DATASETS\n",
    "\n",
    "For the following tutorials we will use a range of datasets, to better showcase the strengths and weaknesses of the algorithms. The datasests are the following:\n",
    "\n",
    "* [Fisher's Iris](https://github.com/aimacode/aima-data/blob/a21fc108f52ad551344e947b0eb97df82f8d2b2b/iris.csv): Each item represents a flower, with four measurements: the length and the width of the sepals and petals. Each item/flower is categorized into one of three species: Setosa, Versicolor and Virginica.\n",
    "\n",
    "* [Zoo](https://github.com/aimacode/aima-data/blob/a21fc108f52ad551344e947b0eb97df82f8d2b2b/zoo.csv): The dataset holds different animals and their classification as \"mammal\", \"fish\", etc. The new animal we want to classify has the following measurements: 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 4, 1, 0, 1 (don't concern yourself with what the measurements mean)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To make using the datasets easier, we have written a class, `DataSet`, in `learning.py`. The tutorials found here make use of this class.\n",
    "\n",
    "Let's have a look at how it works before we get started with the algorithms."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Intro\n",
    "\n",
    "A lot of the datasets we will work with are .csv files (although other formats are supported too). We have a collection of sample datasets ready to use [on aima-data](https://github.com/aimacode/aima-data/tree/a21fc108f52ad551344e947b0eb97df82f8d2b2b). Two examples are the datasets mentioned above (*iris.csv* and *zoo.csv*). You can find plenty datasets online, and a good repository of such datasets is [UCI Machine Learning Repository](https://archive.ics.uci.edu/ml/datasets.html).\n",
    "\n",
    "In such files, each line corresponds to one item/measurement. Each individual value in a line represents a *feature* and usually there is a value denoting the *class* of the item.\n",
    "\n",
    "You can find the code for the dataset here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "%psource DataSet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Class Attributes\n",
    "\n",
    "* **examples**: Holds the items of the dataset. Each item is a list of values.\n",
    "\n",
    "* **attrs**: The indexes of the features (by default in the range of [0,f), where *f* is the number of features). For example, `item[i]` returns the feature at index *i* of *item*.\n",
    "\n",
    "* **attrnames**: An optional list with attribute names. For example, `item[s]`, where *s* is a feature name, returns the feature of name *s* in *item*.\n",
    "\n",
    "* **target**: The attribute a learning algorithm will try to predict. By default the last attribute.\n",
    "\n",
    "* **inputs**: This is the list of attributes without the target.\n",
    "\n",
    "* **values**: A list of lists which holds the set of possible values for the corresponding attribute/feature. If initially `None`, it gets computed (by the function `setproblem`) from the examples.\n",
    "\n",
    "* **distance**: The distance function used in the learner to calculate the distance between two items. By default `mean_boolean_error`.\n",
    "\n",
    "* **name**: Name of the dataset.\n",
    "\n",
    "* **source**: The source of the dataset (url or other). Not used in the code.\n",
    "\n",
    "* **exclude**: A list of indexes to exclude from `inputs`. The list can include either attribute indexes (attrs) or names (attrnames)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Class Helper Functions\n",
    "\n",
    "These functions help modify a `DataSet` object to your needs.\n",
    "\n",
    "* **sanitize**: Takes as input an example and returns it with non-input (target) attributes replaced by `None`. Useful for testing. Keep in mind that the example given is not itself sanitized, but instead a sanitized copy is returned.\n",
    "\n",
    "* **classes_to_numbers**: Maps the class names of a dataset to numbers. If the class names are not given, they are computed from the dataset values. Useful for classifiers that return a numerical value instead of a string.\n",
    "\n",
    "* **remove_examples**: Removes examples containing a given value. Useful for removing examples with missing values, or for removing classes (needed for binary classifiers)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importing a Dataset\n",
    "\n",
    "#### Importing from aima-data\n",
    "\n",
    "Datasets uploaded on aima-data can be imported with the following line:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris = DataSet(name=\"iris\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To check that we imported the correct dataset, we can do the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5.1, 3.5, 1.4, 0.2, 'setosa']\n",
      "[0, 1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "print(iris.examples[0])\n",
    "print(iris.inputs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Which correctly prints the first line in the csv file and the list of attribute indexes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When importing a dataset, we can specify to exclude an attribute (for example, at index 1) by setting the parameter `exclude` to the attribute index or name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "iris2 = DataSet(name=\"iris\",exclude=[1])\n",
    "print(iris2.inputs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Attributes\n",
    "\n",
    "Here we showcase the attributes.\n",
    "\n",
    "First we will print the first three items/examples in the dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[5.1, 3.5, 1.4, 0.2, 'setosa'], [4.9, 3.0, 1.4, 0.2, 'setosa'], [4.7, 3.2, 1.3, 0.2, 'setosa']]\n"
     ]
    }
   ],
   "source": [
    "print(iris.examples[:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we will print `attrs`, `attrnames`, `target`, `input`. Notice how `attrs` holds values in [0,4], but since the fourth attribute is the target, `inputs` holds values in [0,3]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "attrs: [0, 1, 2, 3, 4]\n",
      "attrnames (by default same as attrs): [0, 1, 2, 3, 4]\n",
      "target: 4\n",
      "inputs: [0, 1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "print(\"attrs:\", iris.attrs)\n",
    "print(\"attrnames (by default same as attrs):\", iris.attrnames)\n",
    "print(\"target:\", iris.target)\n",
    "print(\"inputs:\", iris.inputs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will print all the possible values for the first feature/attribute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4.7, 5.5, 5.0, 4.9, 5.1, 4.6, 5.4, 4.4, 4.8, 4.3, 5.8, 7.0, 7.1, 4.5, 5.9, 5.6, 6.9, 6.5, 6.4, 6.6, 6.0, 6.1, 7.6, 7.4, 7.9, 5.7, 5.3, 5.2, 6.3, 6.7, 6.2, 6.8, 7.3, 7.2, 7.7]\n"
     ]
    }
   ],
   "source": [
    "print(iris.values[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally we will print the dataset's name and source. Keep in mind that we have not set a source for the dataset, so in this case it is empty."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name: iris\n",
      "source: \n"
     ]
    }
   ],
   "source": [
    "print(\"name:\", iris.name)\n",
    "print(\"source:\", iris.source)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A useful combination of the above is `dataset.values[dataset.target]` which returns the possible values of the target. For classification problems, this will return all the possible classes. Let's try it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['versicolor', 'virginica', 'setosa']\n"
     ]
    }
   ],
   "source": [
    "print(iris.values[iris.target])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Helper Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will now take a look at the auxiliary functions found in the class.\n",
    "\n",
    "First we will take a look at the `sanitize` function, which sets the non-input values of the given example to `None`.\n",
    "\n",
    "In this case we want to hide the class of the first example, so we will sanitize it.\n",
    "\n",
    "Note that the function doesn't actually change the given example; it returns a sanitized *copy* of it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sanitized: [5.1, 3.5, 1.4, 0.2, None]\n",
      "Original: [5.1, 3.5, 1.4, 0.2, 'setosa']\n"
     ]
    }
   ],
   "source": [
    "print(\"Sanitized:\",iris.sanitize(iris.examples[0]))\n",
    "print(\"Original:\",iris.examples[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Currently the `iris` dataset has three classes, setosa, virginica and versicolor. We want though to convert it to a binary class dataset (a dataset with two classes). The class we want to remove is \"virginica\". To accomplish that we will utilize the helper function `remove_examples`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['versicolor', 'setosa']\n"
     ]
    }
   ],
   "source": [
    "iris2 = DataSet(name=\"iris\")\n",
    "\n",
    "iris2.remove_examples(\"virginica\")\n",
    "print(iris2.values[iris2.target])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We also have `classes_to_numbers`. For a lot of the classifiers in the module (like the Neural Network), classes should have numerical values. With this function we map string class names to numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Class of first example: setosa\n",
      "Class of first example: 0\n"
     ]
    }
   ],
   "source": [
    "print(\"Class of first example:\",iris2.examples[0][iris2.target])\n",
    "iris2.classes_to_numbers()\n",
    "print(\"Class of first example:\",iris2.examples[0][iris2.target])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see \"setosa\" was mapped to 0."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we take a look at `find_means_and_deviations`. It finds the means and standard deviations of the features for each class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Setosa feature means: [5.006, 3.418, 1.464, 0.244]\n",
      "Versicolor mean for first feature: 5.936\n",
      "Setosa feature deviations: [0.3524896872134513, 0.38102439795469095, 0.17351115943644546, 0.10720950308167838]\n",
      "Virginica deviation for second feature: 0.32249663817263746\n"
     ]
    }
   ],
   "source": [
    "means, deviations = iris.find_means_and_deviations()\n",
    "\n",
    "print(\"Setosa feature means:\", means[\"setosa\"])\n",
    "print(\"Versicolor mean for first feature:\", means[\"versicolor\"][0])\n",
    "\n",
    "print(\"Setosa feature deviations:\", deviations[\"setosa\"])\n",
    "print(\"Virginica deviation for second feature:\",deviations[\"virginica\"][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## IRIS VISUALIZATION\n",
    "\n",
    "Since we will use the iris dataset extensively in this notebook, below we provide a visualization tool that helps in comprehending the dataset and thus how the algorithms work.\n",
    "\n",
    "We plot the dataset in a 3D space using `matplotlib` and the function `show_iris` from `notebook.py`. The function takes as input three parameters, *i*, *j* and *k*, which are indicises to the iris features, \"Sepal Length\", \"Sepal Width\", \"Petal Length\" and \"Petal Width\" (0 to 3). By default we show the first three features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "iris = DataSet(name=\"iris\")\n",
    "\n",
    "show_iris()\n",
    "show_iris(0, 1, 3)\n",
    "show_iris(1, 2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can play around with the values to get a good look at the dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DISTANCE FUNCTIONS\n",
    "\n",
    "In a lot of algorithms (like the *k-Nearest Neighbors* algorithm), there is a need to compare items, finding how *similar* or *close* they are. For that we have many different functions at our disposal. Below are the functions implemented in the module:\n",
    "\n",
    "### Manhattan Distance (`manhattan_distance`)\n",
    "\n",
    "One of the simplest distance functions. It calculates the difference between the coordinates/features of two items. To understand how it works, imagine a 2D grid with coordinates *x* and *y*. In that grid we have two items, at the squares positioned at `(1,2)` and `(3,4)`. The difference between their two coordinates is `3-1=2` and `4-2=2`. If we sum these up we get `4`. That means to get from `(1,2)` to `(3,4)` we need four moves; two to the right and two more up. The function works similarly for n-dimensional grids."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Manhattan Distance between (1,2) and (3,4) is 4\n"
     ]
    }
   ],
   "source": [
    "def manhattan_distance(X, Y):\n",
    "    return sum([abs(x - y) for x, y in zip(X, Y)])\n",
    "\n",
    "\n",
    "distance = manhattan_distance([1,2], [3,4])\n",
    "print(\"Manhattan Distance between (1,2) and (3,4) is\", distance)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Euclidean Distance (`euclidean_distance`)\n",
    "\n",
    "Probably the most popular distance function. It returns the square root of the sum of the squared differences between individual elements of two items."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Euclidean Distance between (1,2) and (3,4) is 2.8284271247461903\n"
     ]
    }
   ],
   "source": [
    "def euclidean_distance(X, Y):\n",
    "    return math.sqrt(sum([(x - y)**2 for x, y in zip(X,Y)]))\n",
    "\n",
    "\n",
    "distance = euclidean_distance([1,2], [3,4])\n",
    "print(\"Euclidean Distance between (1,2) and (3,4) is\", distance)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hamming Distance (`hamming_distance`)\n",
    "\n",
    "This function counts the number of differences between single elements in two items. For example, if we have two binary strings \"111\" and \"011\" the function will return 1, since the two strings only differ at the first element. The function works the same way for non-binary strings too."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hamming Distance between 'abc' and 'abb' is 1\n"
     ]
    }
   ],
   "source": [
    "def hamming_distance(X, Y):\n",
    "    return sum(x != y for x, y in zip(X, Y))\n",
    "\n",
    "\n",
    "distance = hamming_distance(['a','b','c'], ['a','b','b'])\n",
    "print(\"Hamming Distance between 'abc' and 'abb' is\", distance)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mean Boolean Error (`mean_boolean_error`)\n",
    "\n",
    "To calculate this distance, we find the ratio of different elements over all elements of two items. For example, if the two items are `(1,2,3)` and `(1,4,5)`, the ration of different/all elements is 2/3, since they differ in two out of three elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean Boolean Error Distance between (1,2,3) and (1,4,5) is 0.6666666666666666\n"
     ]
    }
   ],
   "source": [
    "def mean_boolean_error(X, Y):\n",
    "    return mean(int(x != y) for x, y in zip(X, Y))\n",
    "\n",
    "\n",
    "distance = mean_boolean_error([1,2,3], [1,4,5])\n",
    "print(\"Mean Boolean Error Distance between (1,2,3) and (1,4,5) is\", distance)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mean Error (`mean_error`)\n",
    "\n",
    "This function finds the mean difference of single elements between two items. For example, if the two items are `(1,0,5)` and `(3,10,5)`, their error distance is `(3-1) + (10-0) + (5-5) = 2 + 10 + 0 = 12`. The mean error distance therefore is `12/3=4`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean Error Distance between (1,0,5) and (3,10,5) is 4\n"
     ]
    }
   ],
   "source": [
    "def mean_error(X, Y):\n",
    "    return mean([abs(x - y) for x, y in zip(X, Y)])\n",
    "\n",
    "\n",
    "distance = mean_error([1,0,5], [3,10,5])\n",
    "print(\"Mean Error Distance between (1,0,5) and (3,10,5) is\", distance)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mean Square Error (`ms_error`)\n",
    "\n",
    "This is very similar to the `Mean Error`, but instead of calculating the difference between elements, we are calculating the *square* of the differences."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean Square Distance between (1,0,5) and (3,10,5) is 34.666666666666664\n"
     ]
    }
   ],
   "source": [
    "def ms_error(X, Y):\n",
    "    return mean([(x - y)**2 for x, y in zip(X, Y)])\n",
    "\n",
    "\n",
    "distance = ms_error([1,0,5], [3,10,5])\n",
    "print(\"Mean Square Distance between (1,0,5) and (3,10,5) is\", distance)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Root of Mean Square Error (`rms_error`)\n",
    "\n",
    "This is the square root of `Mean Square Error`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Root of Mean Error Distance between (1,0,5) and (3,10,5) is 5.887840577551898\n"
     ]
    }
   ],
   "source": [
    "def rms_error(X, Y):\n",
    "    return math.sqrt(ms_error(X, Y))\n",
    "\n",
    "\n",
    "distance = rms_error([1,0,5], [3,10,5])\n",
    "print(\"Root of Mean Error Distance between (1,0,5) and (3,10,5) is\", distance)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PLURALITY LEARNER CLASSIFIER\n",
    "\n",
    "### Overview\n",
    "\n",
    "The Plurality Learner is a simple algorithm, used mainly as a baseline comparison for other algorithms. It finds the most popular class in the dataset and classifies any subsequent item to that class. Essentially, it classifies every new item to the same class. For that reason, it is not used very often, instead opting for more complicated algorithms when we want accurate classification.\n",
    "\n",
    "![pL plot](images/pluralityLearner_plot.png)\n",
    "\n",
    "Let's see how the classifier works with the plot above. There are three classes named **Class A** (orange-colored dots) and **Class B** (blue-colored dots) and **Class C** (green-colored dots). Every point in this plot has two **features** (i.e. X<sub>1</sub>, X<sub>2</sub>). Now, let's say we have a new point, a red star and we want to know which class this red star belongs to. Solving this problem by predicting the class of this new red star is our current classification problem.\n",
    "\n",
    "The Plurality Learner will find the class most represented in the plot. ***Class A*** has four items, ***Class B*** has three and ***Class C*** has seven. The most popular class is ***Class C***. Therefore, the item will get classified in ***Class C***, despite the fact that it is closer to the other two classes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementation\n",
    "\n",
    "Below follows the implementation of the PluralityLearner algorithm:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01//EN\"\n",
       "   \"http://www.w3.org/TR/html4/strict.dtd\">\n",
       "\n",
       "<html>\n",
       "<head>\n",
       "  <title></title>\n",
       "  <meta http-equiv=\"content-type\" content=\"text/html; charset=None\">\n",
       "  <style type=\"text/css\">\n",
       "td.linenos { background-color: #f0f0f0; padding-right: 10px; }\n",
       "span.lineno { background-color: #f0f0f0; padding: 0 5px 0 5px; }\n",
       "pre { line-height: 125%; }\n",
       "body .hll { background-color: #ffffcc }\n",
       "body  { background: #f8f8f8; }\n",
       "body .c { color: #408080; font-style: italic } /* Comment */\n",
       "body .err { border: 1px solid #FF0000 } /* Error */\n",
       "body .k { color: #008000; font-weight: bold } /* Keyword */\n",
       "body .o { color: #666666 } /* Operator */\n",
       "body .ch { color: #408080; font-style: italic } /* Comment.Hashbang */\n",
       "body .cm { color: #408080; font-style: italic } /* Comment.Multiline */\n",
       "body .cp { color: #BC7A00 } /* Comment.Preproc */\n",
       "body .cpf { color: #408080; font-style: italic } /* Comment.PreprocFile */\n",
       "body .c1 { color: #408080; font-style: italic } /* Comment.Single */\n",
       "body .cs { color: #408080; font-style: italic } /* Comment.Special */\n",
       "body .gd { color: #A00000 } /* Generic.Deleted */\n",
       "body .ge { font-style: italic } /* Generic.Emph */\n",
       "body .gr { color: #FF0000 } /* Generic.Error */\n",
       "body .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
       "body .gi { color: #00A000 } /* Generic.Inserted */\n",
       "body .go { color: #888888 } /* Generic.Output */\n",
       "body .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
       "body .gs { font-weight: bold } /* Generic.Strong */\n",
       "body .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
       "body .gt { color: #0044DD } /* Generic.Traceback */\n",
       "body .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
       "body .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
       "body .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
       "body .kp { color: #008000 } /* Keyword.Pseudo */\n",
       "body .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
       "body .kt { color: #B00040 } /* Keyword.Type */\n",
       "body .m { color: #666666 } /* Literal.Number */\n",
       "body .s { color: #BA2121 } /* Literal.String */\n",
       "body .na { color: #7D9029 } /* Name.Attribute */\n",
       "body .nb { color: #008000 } /* Name.Builtin */\n",
       "body .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
       "body .no { color: #880000 } /* Name.Constant */\n",
       "body .nd { color: #AA22FF } /* Name.Decorator */\n",
       "body .ni { color: #999999; font-weight: bold } /* Name.Entity */\n",
       "body .ne { color: #D2413A; font-weight: bold } /* Name.Exception */\n",
       "body .nf { color: #0000FF } /* Name.Function */\n",
       "body .nl { color: #A0A000 } /* Name.Label */\n",
       "body .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
       "body .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
       "body .nv { color: #19177C } /* Name.Variable */\n",
       "body .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
       "body .w { color: #bbbbbb } /* Text.Whitespace */\n",
       "body .mb { color: #666666 } /* Literal.Number.Bin */\n",
       "body .mf { color: #666666 } /* Literal.Number.Float */\n",
       "body .mh { color: #666666 } /* Literal.Number.Hex */\n",
       "body .mi { color: #666666 } /* Literal.Number.Integer */\n",
       "body .mo { color: #666666 } /* Literal.Number.Oct */\n",
       "body .sa { color: #BA2121 } /* Literal.String.Affix */\n",
       "body .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
       "body .sc { color: #BA2121 } /* Literal.String.Char */\n",
       "body .dl { color: #BA2121 } /* Literal.String.Delimiter */\n",
       "body .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
       "body .s2 { color: #BA2121 } /* Literal.String.Double */\n",
       "body .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */\n",
       "body .sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
       "body .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */\n",
       "body .sx { color: #008000 } /* Literal.String.Other */\n",
       "body .sr { color: #BB6688 } /* Literal.String.Regex */\n",
       "body .s1 { color: #BA2121 } /* Literal.String.Single */\n",
       "body .ss { color: #19177C } /* Literal.String.Symbol */\n",
       "body .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
       "body .fm { color: #0000FF } /* Name.Function.Magic */\n",
       "body .vc { color: #19177C } /* Name.Variable.Class */\n",
       "body .vg { color: #19177C } /* Name.Variable.Global */\n",
       "body .vi { color: #19177C } /* Name.Variable.Instance */\n",
       "body .vm { color: #19177C } /* Name.Variable.Magic */\n",
       "body .il { color: #666666 } /* Literal.Number.Integer.Long */\n",
       "\n",
       "  </style>\n",
       "</head>\n",
       "<body>\n",
       "<h2></h2>\n",
       "\n",
       "<div class=\"highlight\"><pre><span></span><span class=\"k\">def</span> <span class=\"nf\">PluralityLearner</span><span class=\"p\">(</span><span class=\"n\">dataset</span><span class=\"p\">):</span>\n",
       "    <span class=\"sd\">&quot;&quot;&quot;A very dumb algorithm: always pick the result that was most popular</span>\n",
       "<span class=\"sd\">    in the training data.  Makes a baseline for comparison.&quot;&quot;&quot;</span>\n",
       "    <span class=\"n\">most_popular</span> <span class=\"o\">=</span> <span class=\"n\">mode</span><span class=\"p\">([</span><span class=\"n\">e</span><span class=\"p\">[</span><span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">target</span><span class=\"p\">]</span> <span class=\"k\">for</span> <span class=\"n\">e</span> <span class=\"ow\">in</span> <span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">examples</span><span class=\"p\">])</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">predict</span><span class=\"p\">(</span><span class=\"n\">example</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;Always return same result: the most popular from the training set.&quot;&quot;&quot;</span>\n",
       "        <span class=\"k\">return</span> <span class=\"n\">most_popular</span>\n",
       "    <span class=\"k\">return</span> <span class=\"n\">predict</span>\n",
       "</pre></div>\n",
       "</body>\n",
       "</html>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "psource(PluralityLearner)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It takes as input a dataset and returns a function. We can later call this function with the item we want to classify as the argument and it returns the class it should be classified in.\n",
    "\n",
    "The function first finds the most popular class in the dataset and then each time we call its \"predict\" function, it returns it. Note that the input (\"example\") does not matter. The function always returns the same class."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example\n",
    "\n",
    "For this example, we will not use the Iris dataset, since each class is represented the same. This will throw an error. Instead we will use the zoo dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mammal\n"
     ]
    }
   ],
   "source": [
    "zoo = DataSet(name=\"zoo\")\n",
    "\n",
    "pL = PluralityLearner(zoo)\n",
    "print(pL([1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 4, 1, 0, 1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The output for the above code is \"mammal\", since that is the most popular and common class in the dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## K-NEAREST NEIGHBOURS CLASSIFIER\n",
    "\n",
    "### Overview\n",
    "The k-Nearest Neighbors algorithm is a non-parametric method used for classification and regression. We are going to use this to classify Iris flowers. More about kNN on [Scholarpedia](http://www.scholarpedia.org/article/K-nearest_neighbor).\n",
    "\n",
    "![kNN plot](images/knn_plot.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see how kNN works with a simple plot shown in the above picture.\n",
    "\n",
    "We have co-ordinates (we call them **features** in Machine Learning) of this red star and we need to predict its class using the kNN algorithm. In this algorithm, the value of **k** is arbitrary. **k** is one of the **hyper parameters** for kNN algorithm. We choose this number based on our dataset and choosing a particular number is known as **hyper parameter tuning/optimising**. We learn more about this in coming topics.\n",
    "\n",
    "Let's put **k = 3**. It means you need to find 3-Nearest Neighbors of this red star and classify this new point into the majority class. Observe that smaller circle which contains three points other than **test point** (red star). As there are two violet points, which form the majority, we predict the class of red star as **violet- Class B**.\n",
    "\n",
    "Similarly if we put **k = 5**, you can observe that there are three yellow points, which form the majority. So, we classify our test point as **yellow- Class A**.\n",
    "\n",
    "In practical tasks, we iterate through a bunch of values for k (like [1, 3, 5, 10, 20, 50, 100]), see how it performs and select the best one. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementation\n",
    "\n",
    "Below follows the implementation of the kNN algorithm:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01//EN\"\n",
       "   \"http://www.w3.org/TR/html4/strict.dtd\">\n",
       "\n",
       "<html>\n",
       "<head>\n",
       "  <title></title>\n",
       "  <meta http-equiv=\"content-type\" content=\"text/html; charset=None\">\n",
       "  <style type=\"text/css\">\n",
       "td.linenos { background-color: #f0f0f0; padding-right: 10px; }\n",
       "span.lineno { background-color: #f0f0f0; padding: 0 5px 0 5px; }\n",
       "pre { line-height: 125%; }\n",
       "body .hll { background-color: #ffffcc }\n",
       "body  { background: #f8f8f8; }\n",
       "body .c { color: #408080; font-style: italic } /* Comment */\n",
       "body .err { border: 1px solid #FF0000 } /* Error */\n",
       "body .k { color: #008000; font-weight: bold } /* Keyword */\n",
       "body .o { color: #666666 } /* Operator */\n",
       "body .ch { color: #408080; font-style: italic } /* Comment.Hashbang */\n",
       "body .cm { color: #408080; font-style: italic } /* Comment.Multiline */\n",
       "body .cp { color: #BC7A00 } /* Comment.Preproc */\n",
       "body .cpf { color: #408080; font-style: italic } /* Comment.PreprocFile */\n",
       "body .c1 { color: #408080; font-style: italic } /* Comment.Single */\n",
       "body .cs { color: #408080; font-style: italic } /* Comment.Special */\n",
       "body .gd { color: #A00000 } /* Generic.Deleted */\n",
       "body .ge { font-style: italic } /* Generic.Emph */\n",
       "body .gr { color: #FF0000 } /* Generic.Error */\n",
       "body .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
       "body .gi { color: #00A000 } /* Generic.Inserted */\n",
       "body .go { color: #888888 } /* Generic.Output */\n",
       "body .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
       "body .gs { font-weight: bold } /* Generic.Strong */\n",
       "body .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
       "body .gt { color: #0044DD } /* Generic.Traceback */\n",
       "body .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
       "body .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
       "body .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
       "body .kp { color: #008000 } /* Keyword.Pseudo */\n",
       "body .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
       "body .kt { color: #B00040 } /* Keyword.Type */\n",
       "body .m { color: #666666 } /* Literal.Number */\n",
       "body .s { color: #BA2121 } /* Literal.String */\n",
       "body .na { color: #7D9029 } /* Name.Attribute */\n",
       "body .nb { color: #008000 } /* Name.Builtin */\n",
       "body .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
       "body .no { color: #880000 } /* Name.Constant */\n",
       "body .nd { color: #AA22FF } /* Name.Decorator */\n",
       "body .ni { color: #999999; font-weight: bold } /* Name.Entity */\n",
       "body .ne { color: #D2413A; font-weight: bold } /* Name.Exception */\n",
       "body .nf { color: #0000FF } /* Name.Function */\n",
       "body .nl { color: #A0A000 } /* Name.Label */\n",
       "body .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
       "body .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
       "body .nv { color: #19177C } /* Name.Variable */\n",
       "body .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
       "body .w { color: #bbbbbb } /* Text.Whitespace */\n",
       "body .mb { color: #666666 } /* Literal.Number.Bin */\n",
       "body .mf { color: #666666 } /* Literal.Number.Float */\n",
       "body .mh { color: #666666 } /* Literal.Number.Hex */\n",
       "body .mi { color: #666666 } /* Literal.Number.Integer */\n",
       "body .mo { color: #666666 } /* Literal.Number.Oct */\n",
       "body .sa { color: #BA2121 } /* Literal.String.Affix */\n",
       "body .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
       "body .sc { color: #BA2121 } /* Literal.String.Char */\n",
       "body .dl { color: #BA2121 } /* Literal.String.Delimiter */\n",
       "body .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
       "body .s2 { color: #BA2121 } /* Literal.String.Double */\n",
       "body .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */\n",
       "body .sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
       "body .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */\n",
       "body .sx { color: #008000 } /* Literal.String.Other */\n",
       "body .sr { color: #BB6688 } /* Literal.String.Regex */\n",
       "body .s1 { color: #BA2121 } /* Literal.String.Single */\n",
       "body .ss { color: #19177C } /* Literal.String.Symbol */\n",
       "body .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
       "body .fm { color: #0000FF } /* Name.Function.Magic */\n",
       "body .vc { color: #19177C } /* Name.Variable.Class */\n",
       "body .vg { color: #19177C } /* Name.Variable.Global */\n",
       "body .vi { color: #19177C } /* Name.Variable.Instance */\n",
       "body .vm { color: #19177C } /* Name.Variable.Magic */\n",
       "body .il { color: #666666 } /* Literal.Number.Integer.Long */\n",
       "\n",
       "  </style>\n",
       "</head>\n",
       "<body>\n",
       "<h2></h2>\n",
       "\n",
       "<div class=\"highlight\"><pre><span></span><span class=\"k\">def</span> <span class=\"nf\">NearestNeighborLearner</span><span class=\"p\">(</span><span class=\"n\">dataset</span><span class=\"p\">,</span> <span class=\"n\">k</span><span class=\"o\">=</span><span class=\"mi\">1</span><span class=\"p\">):</span>\n",
       "    <span class=\"sd\">&quot;&quot;&quot;k-NearestNeighbor: the k nearest neighbors vote.&quot;&quot;&quot;</span>\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">predict</span><span class=\"p\">(</span><span class=\"n\">example</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;Find the k closest items, and have them vote for the best.&quot;&quot;&quot;</span>\n",
       "        <span class=\"n\">best</span> <span class=\"o\">=</span> <span class=\"n\">heapq</span><span class=\"o\">.</span><span class=\"n\">nsmallest</span><span class=\"p\">(</span><span class=\"n\">k</span><span class=\"p\">,</span> <span class=\"p\">((</span><span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">distance</span><span class=\"p\">(</span><span class=\"n\">e</span><span class=\"p\">,</span> <span class=\"n\">example</span><span class=\"p\">),</span> <span class=\"n\">e</span><span class=\"p\">)</span>\n",
       "                                   <span class=\"k\">for</span> <span class=\"n\">e</span> <span class=\"ow\">in</span> <span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">examples</span><span class=\"p\">))</span>\n",
       "        <span class=\"k\">return</span> <span class=\"n\">mode</span><span class=\"p\">(</span><span class=\"n\">e</span><span class=\"p\">[</span><span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">target</span><span class=\"p\">]</span> <span class=\"k\">for</span> <span class=\"p\">(</span><span class=\"n\">d</span><span class=\"p\">,</span> <span class=\"n\">e</span><span class=\"p\">)</span> <span class=\"ow\">in</span> <span class=\"n\">best</span><span class=\"p\">)</span>\n",
       "    <span class=\"k\">return</span> <span class=\"n\">predict</span>\n",
       "</pre></div>\n",
       "</body>\n",
       "</html>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "psource(NearestNeighborLearner)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It takes as input a dataset and k (default value is 1) and it returns a function, which we can later use to classify a new item.\n",
    "\n",
    "To accomplish that, the function uses a heap-queue, where the items of the dataset are sorted according to their distance from *example* (the item to classify). We then take the k smallest elements from the heap-queue and we find the majority class. We classify the item to this class."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example\n",
    "\n",
    "We measured a new flower with the following values: 5.1, 3.0, 1.1, 0.1. We want to classify that item/flower in a class. To do that, we write the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "setosa\n"
     ]
    }
   ],
   "source": [
    "iris = DataSet(name=\"iris\")\n",
    "\n",
    "kNN = NearestNeighborLearner(iris,k=3)\n",
    "print(kNN([5.1,3.0,1.1,0.1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The output of the above code is \"setosa\", which means the flower with the above measurements is of the \"setosa\" species."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DECISION TREE LEARNER\n",
    "\n",
    "### Overview\n",
    "\n",
    "#### Decision Trees\n",
    "A decision tree is a flowchart that uses a tree of decisions and their possible consequences for classification. At each non-leaf node of the tree an attribute of the input is tested, based on which corresponding branch leading to a child-node is selected. At the leaf node the input is classified based on the class label of this leaf node. The paths from root to leaves represent classification rules based on which leaf nodes are assigned class labels.\n",
    "![perceptron](images/decisiontree_fruit.jpg)\n",
    "#### Decision Tree Learning\n",
    "Decision tree learning is the construction of a decision tree from class-labeled training data. The data is expected to be a tuple in which each record of the tuple is an attribute used for classification. The decision tree is built top-down, by choosing a variable at each step that best splits the set of items. There are different metrics for measuring the \"best split\". These generally measure the homogeneity of the target variable within the subsets.\n",
    "\n",
    "#### Gini Impurity\n",
    "Gini impurity of a set is the probability of a randomly chosen element to be incorrectly labeled if it was randomly labeled according to the distribution of labels in the set.\n",
    "\n",
    "$$I_G(p) = \\sum{p_i(1 - p_i)} = 1 - \\sum{p_i^2}$$\n",
    "\n",
    "We select a split which minimizes the Gini impurity in child nodes.\n",
    "\n",
    "#### Information Gain\n",
    "Information gain is based on the concept of entropy from information theory. Entropy is defined as:\n",
    "\n",
    "$$H(p) = -\\sum{p_i \\log_2{p_i}}$$\n",
    "\n",
    "Information Gain is difference between entropy of the parent and weighted sum of entropy of children. The feature used for splitting is the one which provides the most information gain.\n",
    "\n",
    "#### Pseudocode\n",
    "\n",
    "You can view the pseudocode by running the cell below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "### AIMA3e\n",
       "__function__ DECISION-TREE-LEARNING(_examples_, _attributes_, _parent\\_examples_) __returns__ a tree  \n",
       "&emsp;__if__ _examples_ is empty __then return__ PLURALITY\\-VALUE(_parent\\_examples_)  \n",
       "&emsp;__else if__ all _examples_ have the same classification __then return__ the classification  \n",
       "&emsp;__else if__ _attributes_ is empty __then return__ PLURALITY\\-VALUE(_examples_)  \n",
       "&emsp;__else__  \n",
       "&emsp;&emsp;&emsp;_A_ &larr; argmax<sub>_a_ &isin; _attributes_</sub> IMPORTANCE(_a_, _examples_)  \n",
       "&emsp;&emsp;&emsp;_tree_ &larr; a new decision tree with root test _A_  \n",
       "&emsp;&emsp;&emsp;__for each__ value _v<sub>k</sub>_ of _A_ __do__  \n",
       "&emsp;&emsp;&emsp;&emsp;&emsp;_exs_ &larr; \\{ _e_ : _e_ &isin; _examples_ __and__ _e_._A_ = _v<sub>k</sub>_ \\}  \n",
       "&emsp;&emsp;&emsp;&emsp;&emsp;_subtree_ &larr; DECISION-TREE-LEARNING(_exs_, _attributes_ &minus; _A_, _examples_)  \n",
       "&emsp;&emsp;&emsp;&emsp;&emsp;add a branch to _tree_ with label \\(_A_ = _v<sub>k</sub>_\\) and subtree _subtree_  \n",
       "&emsp;&emsp;&emsp;__return__ _tree_  \n",
       "\n",
       "---\n",
       "__Figure ??__ The decision\\-tree learning algorithm. The function  IMPORTANCE is described in Section __??__. The function PLURALITY\\-VALUE selects the most common output value among a set of examples, breaking ties randomly."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pseudocode(\"Decision Tree Learning\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementation\n",
    "The nodes of the tree constructed by our learning algorithm are stored using either `DecisionFork` or `DecisionLeaf` based on whether they are a parent node or a leaf node respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01//EN\"\n",
       "   \"http://www.w3.org/TR/html4/strict.dtd\">\n",
       "\n",
       "<html>\n",
       "<head>\n",
       "  <title></title>\n",
       "  <meta http-equiv=\"content-type\" content=\"text/html; charset=None\">\n",
       "  <style type=\"text/css\">\n",
       "td.linenos { background-color: #f0f0f0; padding-right: 10px; }\n",
       "span.lineno { background-color: #f0f0f0; padding: 0 5px 0 5px; }\n",
       "pre { line-height: 125%; }\n",
       "body .hll { background-color: #ffffcc }\n",
       "body  { background: #f8f8f8; }\n",
       "body .c { color: #408080; font-style: italic } /* Comment */\n",
       "body .err { border: 1px solid #FF0000 } /* Error */\n",
       "body .k { color: #008000; font-weight: bold } /* Keyword */\n",
       "body .o { color: #666666 } /* Operator */\n",
       "body .ch { color: #408080; font-style: italic } /* Comment.Hashbang */\n",
       "body .cm { color: #408080; font-style: italic } /* Comment.Multiline */\n",
       "body .cp { color: #BC7A00 } /* Comment.Preproc */\n",
       "body .cpf { color: #408080; font-style: italic } /* Comment.PreprocFile */\n",
       "body .c1 { color: #408080; font-style: italic } /* Comment.Single */\n",
       "body .cs { color: #408080; font-style: italic } /* Comment.Special */\n",
       "body .gd { color: #A00000 } /* Generic.Deleted */\n",
       "body .ge { font-style: italic } /* Generic.Emph */\n",
       "body .gr { color: #FF0000 } /* Generic.Error */\n",
       "body .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
       "body .gi { color: #00A000 } /* Generic.Inserted */\n",
       "body .go { color: #888888 } /* Generic.Output */\n",
       "body .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
       "body .gs { font-weight: bold } /* Generic.Strong */\n",
       "body .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
       "body .gt { color: #0044DD } /* Generic.Traceback */\n",
       "body .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
       "body .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
       "body .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
       "body .kp { color: #008000 } /* Keyword.Pseudo */\n",
       "body .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
       "body .kt { color: #B00040 } /* Keyword.Type */\n",
       "body .m { color: #666666 } /* Literal.Number */\n",
       "body .s { color: #BA2121 } /* Literal.String */\n",
       "body .na { color: #7D9029 } /* Name.Attribute */\n",
       "body .nb { color: #008000 } /* Name.Builtin */\n",
       "body .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
       "body .no { color: #880000 } /* Name.Constant */\n",
       "body .nd { color: #AA22FF } /* Name.Decorator */\n",
       "body .ni { color: #999999; font-weight: bold } /* Name.Entity */\n",
       "body .ne { color: #D2413A; font-weight: bold } /* Name.Exception */\n",
       "body .nf { color: #0000FF } /* Name.Function */\n",
       "body .nl { color: #A0A000 } /* Name.Label */\n",
       "body .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
       "body .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
       "body .nv { color: #19177C } /* Name.Variable */\n",
       "body .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
       "body .w { color: #bbbbbb } /* Text.Whitespace */\n",
       "body .mb { color: #666666 } /* Literal.Number.Bin */\n",
       "body .mf { color: #666666 } /* Literal.Number.Float */\n",
       "body .mh { color: #666666 } /* Literal.Number.Hex */\n",
       "body .mi { color: #666666 } /* Literal.Number.Integer */\n",
       "body .mo { color: #666666 } /* Literal.Number.Oct */\n",
       "body .sa { color: #BA2121 } /* Literal.String.Affix */\n",
       "body .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
       "body .sc { color: #BA2121 } /* Literal.String.Char */\n",
       "body .dl { color: #BA2121 } /* Literal.String.Delimiter */\n",
       "body .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
       "body .s2 { color: #BA2121 } /* Literal.String.Double */\n",
       "body .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */\n",
       "body .sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
       "body .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */\n",
       "body .sx { color: #008000 } /* Literal.String.Other */\n",
       "body .sr { color: #BB6688 } /* Literal.String.Regex */\n",
       "body .s1 { color: #BA2121 } /* Literal.String.Single */\n",
       "body .ss { color: #19177C } /* Literal.String.Symbol */\n",
       "body .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
       "body .fm { color: #0000FF } /* Name.Function.Magic */\n",
       "body .vc { color: #19177C } /* Name.Variable.Class */\n",
       "body .vg { color: #19177C } /* Name.Variable.Global */\n",
       "body .vi { color: #19177C } /* Name.Variable.Instance */\n",
       "body .vm { color: #19177C } /* Name.Variable.Magic */\n",
       "body .il { color: #666666 } /* Literal.Number.Integer.Long */\n",
       "\n",
       "  </style>\n",
       "</head>\n",
       "<body>\n",
       "<h2></h2>\n",
       "\n",
       "<div class=\"highlight\"><pre><span></span><span class=\"k\">class</span> <span class=\"nc\">DecisionFork</span><span class=\"p\">:</span>\n",
       "    <span class=\"sd\">&quot;&quot;&quot;A fork of a decision tree holds an attribute to test, and a dict</span>\n",
       "<span class=\"sd\">    of branches, one for each of the attribute&#39;s values.&quot;&quot;&quot;</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"fm\">__init__</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">attr</span><span class=\"p\">,</span> <span class=\"n\">attrname</span><span class=\"o\">=</span><span class=\"bp\">None</span><span class=\"p\">,</span> <span class=\"n\">default_child</span><span class=\"o\">=</span><span class=\"bp\">None</span><span class=\"p\">,</span> <span class=\"n\">branches</span><span class=\"o\">=</span><span class=\"bp\">None</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;Initialize by saying what attribute this node tests.&quot;&quot;&quot;</span>\n",
       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">attr</span> <span class=\"o\">=</span> <span class=\"n\">attr</span>\n",
       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">attrname</span> <span class=\"o\">=</span> <span class=\"n\">attrname</span> <span class=\"ow\">or</span> <span class=\"n\">attr</span>\n",
       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">default_child</span> <span class=\"o\">=</span> <span class=\"n\">default_child</span>\n",
       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">branches</span> <span class=\"o\">=</span> <span class=\"n\">branches</span> <span class=\"ow\">or</span> <span class=\"p\">{}</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"fm\">__call__</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">example</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;Given an example, classify it using the attribute and the branches.&quot;&quot;&quot;</span>\n",
       "        <span class=\"n\">attrvalue</span> <span class=\"o\">=</span> <span class=\"n\">example</span><span class=\"p\">[</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">attr</span><span class=\"p\">]</span>\n",
       "        <span class=\"k\">if</span> <span class=\"n\">attrvalue</span> <span class=\"ow\">in</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">branches</span><span class=\"p\">:</span>\n",
       "            <span class=\"k\">return</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">branches</span><span class=\"p\">[</span><span class=\"n\">attrvalue</span><span class=\"p\">](</span><span class=\"n\">example</span><span class=\"p\">)</span>\n",
       "        <span class=\"k\">else</span><span class=\"p\">:</span>\n",
       "            <span class=\"c1\"># return default class when attribute is unknown</span>\n",
       "            <span class=\"k\">return</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">default_child</span><span class=\"p\">(</span><span class=\"n\">example</span><span class=\"p\">)</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">add</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">val</span><span class=\"p\">,</span> <span class=\"n\">subtree</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;Add a branch.  If self.attr = val, go to the given subtree.&quot;&quot;&quot;</span>\n",
       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">branches</span><span class=\"p\">[</span><span class=\"n\">val</span><span class=\"p\">]</span> <span class=\"o\">=</span> <span class=\"n\">subtree</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">display</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">indent</span><span class=\"o\">=</span><span class=\"mi\">0</span><span class=\"p\">):</span>\n",
       "        <span class=\"n\">name</span> <span class=\"o\">=</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">attrname</span>\n",
       "        <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">&#39;Test&#39;</span><span class=\"p\">,</span> <span class=\"n\">name</span><span class=\"p\">)</span>\n",
       "        <span class=\"k\">for</span> <span class=\"p\">(</span><span class=\"n\">val</span><span class=\"p\">,</span> <span class=\"n\">subtree</span><span class=\"p\">)</span> <span class=\"ow\">in</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">branches</span><span class=\"o\">.</span><span class=\"n\">items</span><span class=\"p\">():</span>\n",
       "            <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">&#39; &#39;</span> <span class=\"o\">*</span> <span class=\"mi\">4</span> <span class=\"o\">*</span> <span class=\"n\">indent</span><span class=\"p\">,</span> <span class=\"n\">name</span><span class=\"p\">,</span> <span class=\"s1\">&#39;=&#39;</span><span class=\"p\">,</span> <span class=\"n\">val</span><span class=\"p\">,</span> <span class=\"s1\">&#39;==&gt;&#39;</span><span class=\"p\">,</span> <span class=\"n\">end</span><span class=\"o\">=</span><span class=\"s1\">&#39; &#39;</span><span class=\"p\">)</span>\n",
       "            <span class=\"n\">subtree</span><span class=\"o\">.</span><span class=\"n\">display</span><span class=\"p\">(</span><span class=\"n\">indent</span> <span class=\"o\">+</span> <span class=\"mi\">1</span><span class=\"p\">)</span>\n",
       "        <span class=\"k\">print</span><span class=\"p\">()</span>   <span class=\"c1\"># newline</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"fm\">__repr__</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">):</span>\n",
       "        <span class=\"k\">return</span> <span class=\"p\">(</span><span class=\"s1\">&#39;DecisionFork({0!r}, {1!r}, {2!r})&#39;</span>\n",
       "                <span class=\"o\">.</span><span class=\"n\">format</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">attr</span><span class=\"p\">,</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">attrname</span><span class=\"p\">,</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">branches</span><span class=\"p\">))</span>\n",
       "</pre></div>\n",
       "</body>\n",
       "</html>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "psource(DecisionFork)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`DecisionFork` holds the attribute, which is tested at that node, and a dict of branches. The branches store the child nodes, one for each of the attribute's values. Calling an object of this class as a function with input tuple as an argument returns the next node in the classification path based on the result of the attribute test."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01//EN\"\n",
       "   \"http://www.w3.org/TR/html4/strict.dtd\">\n",
       "\n",
       "<html>\n",
       "<head>\n",
       "  <title></title>\n",
       "  <meta http-equiv=\"content-type\" content=\"text/html; charset=None\">\n",
       "  <style type=\"text/css\">\n",
       "td.linenos { background-color: #f0f0f0; padding-right: 10px; }\n",
       "span.lineno { background-color: #f0f0f0; padding: 0 5px 0 5px; }\n",
       "pre { line-height: 125%; }\n",
       "body .hll { background-color: #ffffcc }\n",
       "body  { background: #f8f8f8; }\n",
       "body .c { color: #408080; font-style: italic } /* Comment */\n",
       "body .err { border: 1px solid #FF0000 } /* Error */\n",
       "body .k { color: #008000; font-weight: bold } /* Keyword */\n",
       "body .o { color: #666666 } /* Operator */\n",
       "body .ch { color: #408080; font-style: italic } /* Comment.Hashbang */\n",
       "body .cm { color: #408080; font-style: italic } /* Comment.Multiline */\n",
       "body .cp { color: #BC7A00 } /* Comment.Preproc */\n",
       "body .cpf { color: #408080; font-style: italic } /* Comment.PreprocFile */\n",
       "body .c1 { color: #408080; font-style: italic } /* Comment.Single */\n",
       "body .cs { color: #408080; font-style: italic } /* Comment.Special */\n",
       "body .gd { color: #A00000 } /* Generic.Deleted */\n",
       "body .ge { font-style: italic } /* Generic.Emph */\n",
       "body .gr { color: #FF0000 } /* Generic.Error */\n",
       "body .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
       "body .gi { color: #00A000 } /* Generic.Inserted */\n",
       "body .go { color: #888888 } /* Generic.Output */\n",
       "body .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
       "body .gs { font-weight: bold } /* Generic.Strong */\n",
       "body .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
       "body .gt { color: #0044DD } /* Generic.Traceback */\n",
       "body .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
       "body .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
       "body .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
       "body .kp { color: #008000 } /* Keyword.Pseudo */\n",
       "body .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
       "body .kt { color: #B00040 } /* Keyword.Type */\n",
       "body .m { color: #666666 } /* Literal.Number */\n",
       "body .s { color: #BA2121 } /* Literal.String */\n",
       "body .na { color: #7D9029 } /* Name.Attribute */\n",
       "body .nb { color: #008000 } /* Name.Builtin */\n",
       "body .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
       "body .no { color: #880000 } /* Name.Constant */\n",
       "body .nd { color: #AA22FF } /* Name.Decorator */\n",
       "body .ni { color: #999999; font-weight: bold } /* Name.Entity */\n",
       "body .ne { color: #D2413A; font-weight: bold } /* Name.Exception */\n",
       "body .nf { color: #0000FF } /* Name.Function */\n",
       "body .nl { color: #A0A000 } /* Name.Label */\n",
       "body .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
       "body .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
       "body .nv { color: #19177C } /* Name.Variable */\n",
       "body .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
       "body .w { color: #bbbbbb } /* Text.Whitespace */\n",
       "body .mb { color: #666666 } /* Literal.Number.Bin */\n",
       "body .mf { color: #666666 } /* Literal.Number.Float */\n",
       "body .mh { color: #666666 } /* Literal.Number.Hex */\n",
       "body .mi { color: #666666 } /* Literal.Number.Integer */\n",
       "body .mo { color: #666666 } /* Literal.Number.Oct */\n",
       "body .sa { color: #BA2121 } /* Literal.String.Affix */\n",
       "body .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
       "body .sc { color: #BA2121 } /* Literal.String.Char */\n",
       "body .dl { color: #BA2121 } /* Literal.String.Delimiter */\n",
       "body .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
       "body .s2 { color: #BA2121 } /* Literal.String.Double */\n",
       "body .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */\n",
       "body .sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
       "body .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */\n",
       "body .sx { color: #008000 } /* Literal.String.Other */\n",
       "body .sr { color: #BB6688 } /* Literal.String.Regex */\n",
       "body .s1 { color: #BA2121 } /* Literal.String.Single */\n",
       "body .ss { color: #19177C } /* Literal.String.Symbol */\n",
       "body .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
       "body .fm { color: #0000FF } /* Name.Function.Magic */\n",
       "body .vc { color: #19177C } /* Name.Variable.Class */\n",
       "body .vg { color: #19177C } /* Name.Variable.Global */\n",
       "body .vi { color: #19177C } /* Name.Variable.Instance */\n",
       "body .vm { color: #19177C } /* Name.Variable.Magic */\n",
       "body .il { color: #666666 } /* Literal.Number.Integer.Long */\n",
       "\n",
       "  </style>\n",
       "</head>\n",
       "<body>\n",
       "<h2></h2>\n",
       "\n",
       "<div class=\"highlight\"><pre><span></span><span class=\"k\">class</span> <span class=\"nc\">DecisionLeaf</span><span class=\"p\">:</span>\n",
       "    <span class=\"sd\">&quot;&quot;&quot;A leaf of a decision tree holds just a result.&quot;&quot;&quot;</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"fm\">__init__</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">result</span><span class=\"p\">):</span>\n",
       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">result</span> <span class=\"o\">=</span> <span class=\"n\">result</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"fm\">__call__</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">example</span><span class=\"p\">):</span>\n",
       "        <span class=\"k\">return</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">result</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">display</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">indent</span><span class=\"o\">=</span><span class=\"mi\">0</span><span class=\"p\">):</span>\n",
       "        <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">&#39;RESULT =&#39;</span><span class=\"p\">,</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">result</span><span class=\"p\">)</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"fm\">__repr__</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">):</span>\n",
       "        <span class=\"k\">return</span> <span class=\"nb\">repr</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">result</span><span class=\"p\">)</span>\n",
       "</pre></div>\n",
       "</body>\n",
       "</html>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "psource(DecisionLeaf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The leaf node stores the class label in `result`. All input tuples' classification paths end on a `DecisionLeaf` whose `result` attribute decide their class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01//EN\"\n",
       "   \"http://www.w3.org/TR/html4/strict.dtd\">\n",
       "\n",
       "<html>\n",
       "<head>\n",
       "  <title></title>\n",
       "  <meta http-equiv=\"content-type\" content=\"text/html; charset=None\">\n",
       "  <style type=\"text/css\">\n",
       "td.linenos { background-color: #f0f0f0; padding-right: 10px; }\n",
       "span.lineno { background-color: #f0f0f0; padding: 0 5px 0 5px; }\n",
       "pre { line-height: 125%; }\n",
       "body .hll { background-color: #ffffcc }\n",
       "body  { background: #f8f8f8; }\n",
       "body .c { color: #408080; font-style: italic } /* Comment */\n",
       "body .err { border: 1px solid #FF0000 } /* Error */\n",
       "body .k { color: #008000; font-weight: bold } /* Keyword */\n",
       "body .o { color: #666666 } /* Operator */\n",
       "body .ch { color: #408080; font-style: italic } /* Comment.Hashbang */\n",
       "body .cm { color: #408080; font-style: italic } /* Comment.Multiline */\n",
       "body .cp { color: #BC7A00 } /* Comment.Preproc */\n",
       "body .cpf { color: #408080; font-style: italic } /* Comment.PreprocFile */\n",
       "body .c1 { color: #408080; font-style: italic } /* Comment.Single */\n",
       "body .cs { color: #408080; font-style: italic } /* Comment.Special */\n",
       "body .gd { color: #A00000 } /* Generic.Deleted */\n",
       "body .ge { font-style: italic } /* Generic.Emph */\n",
       "body .gr { color: #FF0000 } /* Generic.Error */\n",
       "body .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
       "body .gi { color: #00A000 } /* Generic.Inserted */\n",
       "body .go { color: #888888 } /* Generic.Output */\n",
       "body .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
       "body .gs { font-weight: bold } /* Generic.Strong */\n",
       "body .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
       "body .gt { color: #0044DD } /* Generic.Traceback */\n",
       "body .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
       "body .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
       "body .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
       "body .kp { color: #008000 } /* Keyword.Pseudo */\n",
       "body .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
       "body .kt { color: #B00040 } /* Keyword.Type */\n",
       "body .m { color: #666666 } /* Literal.Number */\n",
       "body .s { color: #BA2121 } /* Literal.String */\n",
       "body .na { color: #7D9029 } /* Name.Attribute */\n",
       "body .nb { color: #008000 } /* Name.Builtin */\n",
       "body .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
       "body .no { color: #880000 } /* Name.Constant */\n",
       "body .nd { color: #AA22FF } /* Name.Decorator */\n",
       "body .ni { color: #999999; font-weight: bold } /* Name.Entity */\n",
       "body .ne { color: #D2413A; font-weight: bold } /* Name.Exception */\n",
       "body .nf { color: #0000FF } /* Name.Function */\n",
       "body .nl { color: #A0A000 } /* Name.Label */\n",
       "body .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
       "body .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
       "body .nv { color: #19177C } /* Name.Variable */\n",
       "body .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
       "body .w { color: #bbbbbb } /* Text.Whitespace */\n",
       "body .mb { color: #666666 } /* Literal.Number.Bin */\n",
       "body .mf { color: #666666 } /* Literal.Number.Float */\n",
       "body .mh { color: #666666 } /* Literal.Number.Hex */\n",
       "body .mi { color: #666666 } /* Literal.Number.Integer */\n",
       "body .mo { color: #666666 } /* Literal.Number.Oct */\n",
       "body .sa { color: #BA2121 } /* Literal.String.Affix */\n",
       "body .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
       "body .sc { color: #BA2121 } /* Literal.String.Char */\n",
       "body .dl { color: #BA2121 } /* Literal.String.Delimiter */\n",
       "body .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
       "body .s2 { color: #BA2121 } /* Literal.String.Double */\n",
       "body .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */\n",
       "body .sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
       "body .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */\n",
       "body .sx { color: #008000 } /* Literal.String.Other */\n",
       "body .sr { color: #BB6688 } /* Literal.String.Regex */\n",
       "body .s1 { color: #BA2121 } /* Literal.String.Single */\n",
       "body .ss { color: #19177C } /* Literal.String.Symbol */\n",
       "body .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
       "body .fm { color: #0000FF } /* Name.Function.Magic */\n",
       "body .vc { color: #19177C } /* Name.Variable.Class */\n",
       "body .vg { color: #19177C } /* Name.Variable.Global */\n",
       "body .vi { color: #19177C } /* Name.Variable.Instance */\n",
       "body .vm { color: #19177C } /* Name.Variable.Magic */\n",
       "body .il { color: #666666 } /* Literal.Number.Integer.Long */\n",
       "\n",
       "  </style>\n",
       "</head>\n",
       "<body>\n",
       "<h2></h2>\n",
       "\n",
       "<div class=\"highlight\"><pre><span></span><span class=\"k\">def</span> <span class=\"nf\">DecisionTreeLearner</span><span class=\"p\">(</span><span class=\"n\">dataset</span><span class=\"p\">):</span>\n",
       "    <span class=\"sd\">&quot;&quot;&quot;[Figure 18.5]&quot;&quot;&quot;</span>\n",
       "\n",
       "    <span class=\"n\">target</span><span class=\"p\">,</span> <span class=\"n\">values</span> <span class=\"o\">=</span> <span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">target</span><span class=\"p\">,</span> <span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">values</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">decision_tree_learning</span><span class=\"p\">(</span><span class=\"n\">examples</span><span class=\"p\">,</span> <span class=\"n\">attrs</span><span class=\"p\">,</span> <span class=\"n\">parent_examples</span><span class=\"o\">=</span><span class=\"p\">()):</span>\n",
       "        <span class=\"k\">if</span> <span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">examples</span><span class=\"p\">)</span> <span class=\"o\">==</span> <span class=\"mi\">0</span><span class=\"p\">:</span>\n",
       "            <span class=\"k\">return</span> <span class=\"n\">plurality_value</span><span class=\"p\">(</span><span class=\"n\">parent_examples</span><span class=\"p\">)</span>\n",
       "        <span class=\"k\">elif</span> <span class=\"n\">all_same_class</span><span class=\"p\">(</span><span class=\"n\">examples</span><span class=\"p\">):</span>\n",
       "            <span class=\"k\">return</span> <span class=\"n\">DecisionLeaf</span><span class=\"p\">(</span><span class=\"n\">examples</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">][</span><span class=\"n\">target</span><span class=\"p\">])</span>\n",
       "        <span class=\"k\">elif</span> <span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">attrs</span><span class=\"p\">)</span> <span class=\"o\">==</span> <span class=\"mi\">0</span><span class=\"p\">:</span>\n",
       "            <span class=\"k\">return</span> <span class=\"n\">plurality_value</span><span class=\"p\">(</span><span class=\"n\">examples</span><span class=\"p\">)</span>\n",
       "        <span class=\"k\">else</span><span class=\"p\">:</span>\n",
       "            <span class=\"n\">A</span> <span class=\"o\">=</span> <span class=\"n\">choose_attribute</span><span class=\"p\">(</span><span class=\"n\">attrs</span><span class=\"p\">,</span> <span class=\"n\">examples</span><span class=\"p\">)</span>\n",
       "            <span class=\"n\">tree</span> <span class=\"o\">=</span> <span class=\"n\">DecisionFork</span><span class=\"p\">(</span><span class=\"n\">A</span><span class=\"p\">,</span> <span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">attrnames</span><span class=\"p\">[</span><span class=\"n\">A</span><span class=\"p\">],</span> <span class=\"n\">plurality_value</span><span class=\"p\">(</span><span class=\"n\">examples</span><span class=\"p\">))</span>\n",
       "            <span class=\"k\">for</span> <span class=\"p\">(</span><span class=\"n\">v_k</span><span class=\"p\">,</span> <span class=\"n\">exs</span><span class=\"p\">)</span> <span class=\"ow\">in</span> <span class=\"n\">split_by</span><span class=\"p\">(</span><span class=\"n\">A</span><span class=\"p\">,</span> <span class=\"n\">examples</span><span class=\"p\">):</span>\n",
       "                <span class=\"n\">subtree</span> <span class=\"o\">=</span> <span class=\"n\">decision_tree_learning</span><span class=\"p\">(</span>\n",
       "                    <span class=\"n\">exs</span><span class=\"p\">,</span> <span class=\"n\">removeall</span><span class=\"p\">(</span><span class=\"n\">A</span><span class=\"p\">,</span> <span class=\"n\">attrs</span><span class=\"p\">),</span> <span class=\"n\">examples</span><span class=\"p\">)</span>\n",
       "                <span class=\"n\">tree</span><span class=\"o\">.</span><span class=\"n\">add</span><span class=\"p\">(</span><span class=\"n\">v_k</span><span class=\"p\">,</span> <span class=\"n\">subtree</span><span class=\"p\">)</span>\n",
       "            <span class=\"k\">return</span> <span class=\"n\">tree</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">plurality_value</span><span class=\"p\">(</span><span class=\"n\">examples</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;Return the most popular target value for this set of examples.</span>\n",
       "<span class=\"sd\">        (If target is binary, this is the majority; otherwise plurality.)&quot;&quot;&quot;</span>\n",
       "        <span class=\"n\">popular</span> <span class=\"o\">=</span> <span class=\"n\">argmax_random_tie</span><span class=\"p\">(</span><span class=\"n\">values</span><span class=\"p\">[</span><span class=\"n\">target</span><span class=\"p\">],</span>\n",
       "                                    <span class=\"n\">key</span><span class=\"o\">=</span><span class=\"k\">lambda</span> <span class=\"n\">v</span><span class=\"p\">:</span> <span class=\"n\">count</span><span class=\"p\">(</span><span class=\"n\">target</span><span class=\"p\">,</span> <span class=\"n\">v</span><span class=\"p\">,</span> <span class=\"n\">examples</span><span class=\"p\">))</span>\n",
       "        <span class=\"k\">return</span> <span class=\"n\">DecisionLeaf</span><span class=\"p\">(</span><span class=\"n\">popular</span><span class=\"p\">)</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">count</span><span class=\"p\">(</span><span class=\"n\">attr</span><span class=\"p\">,</span> <span class=\"n\">val</span><span class=\"p\">,</span> <span class=\"n\">examples</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;Count the number of examples that have example[attr] = val.&quot;&quot;&quot;</span>\n",
       "        <span class=\"k\">return</span> <span class=\"nb\">sum</span><span class=\"p\">(</span><span class=\"n\">e</span><span class=\"p\">[</span><span class=\"n\">attr</span><span class=\"p\">]</span> <span class=\"o\">==</span> <span class=\"n\">val</span> <span class=\"k\">for</span> <span class=\"n\">e</span> <span class=\"ow\">in</span> <span class=\"n\">examples</span><span class=\"p\">)</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">all_same_class</span><span class=\"p\">(</span><span class=\"n\">examples</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;Are all these examples in the same target class?&quot;&quot;&quot;</span>\n",
       "        <span class=\"n\">class0</span> <span class=\"o\">=</span> <span class=\"n\">examples</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">][</span><span class=\"n\">target</span><span class=\"p\">]</span>\n",
       "        <span class=\"k\">return</span> <span class=\"nb\">all</span><span class=\"p\">(</span><span class=\"n\">e</span><span class=\"p\">[</span><span class=\"n\">target</span><span class=\"p\">]</span> <span class=\"o\">==</span> <span class=\"n\">class0</span> <span class=\"k\">for</span> <span class=\"n\">e</span> <span class=\"ow\">in</span> <span class=\"n\">examples</span><span class=\"p\">)</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">choose_attribute</span><span class=\"p\">(</span><span class=\"n\">attrs</span><span class=\"p\">,</span> <span class=\"n\">examples</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;Choose the attribute with the highest information gain.&quot;&quot;&quot;</span>\n",
       "        <span class=\"k\">return</span> <span class=\"n\">argmax_random_tie</span><span class=\"p\">(</span><span class=\"n\">attrs</span><span class=\"p\">,</span>\n",
       "                                 <span class=\"n\">key</span><span class=\"o\">=</span><span class=\"k\">lambda</span> <span class=\"n\">a</span><span class=\"p\">:</span> <span class=\"n\">information_gain</span><span class=\"p\">(</span><span class=\"n\">a</span><span class=\"p\">,</span> <span class=\"n\">examples</span><span class=\"p\">))</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">information_gain</span><span class=\"p\">(</span><span class=\"n\">attr</span><span class=\"p\">,</span> <span class=\"n\">examples</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;Return the expected reduction in entropy from splitting by attr.&quot;&quot;&quot;</span>\n",
       "        <span class=\"k\">def</span> <span class=\"nf\">I</span><span class=\"p\">(</span><span class=\"n\">examples</span><span class=\"p\">):</span>\n",
       "            <span class=\"k\">return</span> <span class=\"n\">information_content</span><span class=\"p\">([</span><span class=\"n\">count</span><span class=\"p\">(</span><span class=\"n\">target</span><span class=\"p\">,</span> <span class=\"n\">v</span><span class=\"p\">,</span> <span class=\"n\">examples</span><span class=\"p\">)</span>\n",
       "                                        <span class=\"k\">for</span> <span class=\"n\">v</span> <span class=\"ow\">in</span> <span class=\"n\">values</span><span class=\"p\">[</span><span class=\"n\">target</span><span class=\"p\">]])</span>\n",
       "        <span class=\"n\">N</span> <span class=\"o\">=</span> <span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">examples</span><span class=\"p\">)</span>\n",
       "        <span class=\"n\">remainder</span> <span class=\"o\">=</span> <span class=\"nb\">sum</span><span class=\"p\">((</span><span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">examples_i</span><span class=\"p\">)</span><span class=\"o\">/</span><span class=\"n\">N</span><span class=\"p\">)</span> <span class=\"o\">*</span> <span class=\"n\">I</span><span class=\"p\">(</span><span class=\"n\">examples_i</span><span class=\"p\">)</span>\n",
       "                        <span class=\"k\">for</span> <span class=\"p\">(</span><span class=\"n\">v</span><span class=\"p\">,</span> <span class=\"n\">examples_i</span><span class=\"p\">)</span> <span class=\"ow\">in</span> <span class=\"n\">split_by</span><span class=\"p\">(</span><span class=\"n\">attr</span><span class=\"p\">,</span> <span class=\"n\">examples</span><span class=\"p\">))</span>\n",
       "        <span class=\"k\">return</span> <span class=\"n\">I</span><span class=\"p\">(</span><span class=\"n\">examples</span><span class=\"p\">)</span> <span class=\"o\">-</span> <span class=\"n\">remainder</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">split_by</span><span class=\"p\">(</span><span class=\"n\">attr</span><span class=\"p\">,</span> <span class=\"n\">examples</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;Return a list of (val, examples) pairs for each val of attr.&quot;&quot;&quot;</span>\n",
       "        <span class=\"k\">return</span> <span class=\"p\">[(</span><span class=\"n\">v</span><span class=\"p\">,</span> <span class=\"p\">[</span><span class=\"n\">e</span> <span class=\"k\">for</span> <span class=\"n\">e</span> <span class=\"ow\">in</span> <span class=\"n\">examples</span> <span class=\"k\">if</span> <span class=\"n\">e</span><span class=\"p\">[</span><span class=\"n\">attr</span><span class=\"p\">]</span> <span class=\"o\">==</span> <span class=\"n\">v</span><span class=\"p\">])</span>\n",
       "                <span class=\"k\">for</span> <span class=\"n\">v</span> <span class=\"ow\">in</span> <span class=\"n\">values</span><span class=\"p\">[</span><span class=\"n\">attr</span><span class=\"p\">]]</span>\n",
       "\n",
       "    <span class=\"k\">return</span> <span class=\"n\">decision_tree_learning</span><span class=\"p\">(</span><span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">examples</span><span class=\"p\">,</span> <span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">inputs</span><span class=\"p\">)</span>\n",
       "</pre></div>\n",
       "</body>\n",
       "</html>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "psource(DecisionTreeLearner)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The implementation of `DecisionTreeLearner` provided in [learning.py](https://github.com/aimacode/aima-python/blob/master/learning.py) uses information gain as the metric for selecting which attribute to test for splitting. The function builds the tree top-down in a recursive manner. Based on the input it makes one of the four choices:\n",
    "<ol>\n",
    "<li>If the input at the current step has no training data we return the mode of classes of input data received in the parent step (previous level of recursion).</li>\n",
    "<li>If all values in training data belong to the same class it returns a `DecisionLeaf` whose class label is the class which all the data belongs to.</li>\n",
    "<li>If the data has no attributes that can be tested we return the class with highest plurality value in the training data.</li>\n",
    "<li>We choose the attribute which gives the highest amount of entropy gain and return a `DecisionFork` which splits based on this attribute. Each branch recursively calls `decision_tree_learning` to construct the sub-tree.</li>\n",
    "</ol>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example\n",
    "\n",
    "We will now use the Decision Tree Learner to classify a sample with values: 5.1, 3.0, 1.1, 0.1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "setosa\n"
     ]
    }
   ],
   "source": [
    "iris = DataSet(name=\"iris\")\n",
    "\n",
    "DTL = DecisionTreeLearner(iris)\n",
    "print(DTL([5.1, 3.0, 1.1, 0.1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As expected, the Decision Tree learner classifies the sample as \"setosa\" as seen in the previous section."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## RANDOM FOREST LEARNER\n",
    "\n",
    "### Overview\n",
    "\n",
    "![random_forest.png](images/random_forest.png)   \n",
    "Image via [src](https://cdn-images-1.medium.com/max/800/0*tG-IWcxL1jg7RkT0.png)\n",
    "\n",
    "#### Random Forest\n",
    "\n",
    "As the name of the algorithm and image above suggest, this algorithm creates the forest with a number of trees. The more number of trees makes the forest robust. In the same way in random forest algorithm, the higher the number of trees in the forest, the higher is the accuray result. The main difference between Random Forest and Decision trees is that, finding the root node and splitting the feature nodes will be random.  \n",
    "\n",
    "Let's see how Rnadom Forest Algorithm work :   \n",
    "Random Forest Algorithm works in two steps, first is the creation of random forest and then the prediction. Let's first see the creation :  \n",
    "\n",
    "The first step in creation is to randomly select 'm' features out of total 'n' features. From these 'm' features calculate the node d using the best split point and then split the node into further nodes using best split. Repeat these steps until 'i' number of nodes are reached. Repeat the entire whole process to build the forest.  \n",
    "\n",
    "Now, let's see how the prediction works\n",
    "Take the test features and predict the outcome for each randomly created decision tree. Calculate the votes for each prediction and the prediction which gets the highest votes would be the final prediction.\n",
    "\n",
    "\n",
    "### Implementation\n",
    "\n",
    "Below mentioned is the implementation of Random Forest Algorithm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01//EN\"\n",
       "   \"http://www.w3.org/TR/html4/strict.dtd\">\n",
       "\n",
       "<html>\n",
       "<head>\n",
       "  <title></title>\n",
       "  <meta http-equiv=\"content-type\" content=\"text/html; charset=None\">\n",
       "  <style type=\"text/css\">\n",
       "td.linenos { background-color: #f0f0f0; padding-right: 10px; }\n",
       "span.lineno { background-color: #f0f0f0; padding: 0 5px 0 5px; }\n",
       "pre { line-height: 125%; }\n",
       "body .hll { background-color: #ffffcc }\n",
       "body  { background: #f8f8f8; }\n",
       "body .c { color: #408080; font-style: italic } /* Comment */\n",
       "body .err { border: 1px solid #FF0000 } /* Error */\n",
       "body .k { color: #008000; font-weight: bold } /* Keyword */\n",
       "body .o { color: #666666 } /* Operator */\n",
       "body .ch { color: #408080; font-style: italic } /* Comment.Hashbang */\n",
       "body .cm { color: #408080; font-style: italic } /* Comment.Multiline */\n",
       "body .cp { color: #BC7A00 } /* Comment.Preproc */\n",
       "body .cpf { color: #408080; font-style: italic } /* Comment.PreprocFile */\n",
       "body .c1 { color: #408080; font-style: italic } /* Comment.Single */\n",
       "body .cs { color: #408080; font-style: italic } /* Comment.Special */\n",
       "body .gd { color: #A00000 } /* Generic.Deleted */\n",
       "body .ge { font-style: italic } /* Generic.Emph */\n",
       "body .gr { color: #FF0000 } /* Generic.Error */\n",
       "body .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
       "body .gi { color: #00A000 } /* Generic.Inserted */\n",
       "body .go { color: #888888 } /* Generic.Output */\n",
       "body .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
       "body .gs { font-weight: bold } /* Generic.Strong */\n",
       "body .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
       "body .gt { color: #0044DD } /* Generic.Traceback */\n",
       "body .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
       "body .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
       "body .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
       "body .kp { color: #008000 } /* Keyword.Pseudo */\n",
       "body .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
       "body .kt { color: #B00040 } /* Keyword.Type */\n",
       "body .m { color: #666666 } /* Literal.Number */\n",
       "body .s { color: #BA2121 } /* Literal.String */\n",
       "body .na { color: #7D9029 } /* Name.Attribute */\n",
       "body .nb { color: #008000 } /* Name.Builtin */\n",
       "body .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
       "body .no { color: #880000 } /* Name.Constant */\n",
       "body .nd { color: #AA22FF } /* Name.Decorator */\n",
       "body .ni { color: #999999; font-weight: bold } /* Name.Entity */\n",
       "body .ne { color: #D2413A; font-weight: bold } /* Name.Exception */\n",
       "body .nf { color: #0000FF } /* Name.Function */\n",
       "body .nl { color: #A0A000 } /* Name.Label */\n",
       "body .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
       "body .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
       "body .nv { color: #19177C } /* Name.Variable */\n",
       "body .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
       "body .w { color: #bbbbbb } /* Text.Whitespace */\n",
       "body .mb { color: #666666 } /* Literal.Number.Bin */\n",
       "body .mf { color: #666666 } /* Literal.Number.Float */\n",
       "body .mh { color: #666666 } /* Literal.Number.Hex */\n",
       "body .mi { color: #666666 } /* Literal.Number.Integer */\n",
       "body .mo { color: #666666 } /* Literal.Number.Oct */\n",
       "body .sa { color: #BA2121 } /* Literal.String.Affix */\n",
       "body .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
       "body .sc { color: #BA2121 } /* Literal.String.Char */\n",
       "body .dl { color: #BA2121 } /* Literal.String.Delimiter */\n",
       "body .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
       "body .s2 { color: #BA2121 } /* Literal.String.Double */\n",
       "body .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */\n",
       "body .sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
       "body .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */\n",
       "body .sx { color: #008000 } /* Literal.String.Other */\n",
       "body .sr { color: #BB6688 } /* Literal.String.Regex */\n",
       "body .s1 { color: #BA2121 } /* Literal.String.Single */\n",
       "body .ss { color: #19177C } /* Literal.String.Symbol */\n",
       "body .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
       "body .fm { color: #0000FF } /* Name.Function.Magic */\n",
       "body .vc { color: #19177C } /* Name.Variable.Class */\n",
       "body .vg { color: #19177C } /* Name.Variable.Global */\n",
       "body .vi { color: #19177C } /* Name.Variable.Instance */\n",
       "body .vm { color: #19177C } /* Name.Variable.Magic */\n",
       "body .il { color: #666666 } /* Literal.Number.Integer.Long */\n",
       "\n",
       "  </style>\n",
       "</head>\n",
       "<body>\n",
       "<h2></h2>\n",
       "\n",
       "<div class=\"highlight\"><pre><span></span><span class=\"k\">def</span> <span class=\"nf\">RandomForest</span><span class=\"p\">(</span><span class=\"n\">dataset</span><span class=\"p\">,</span> <span class=\"n\">n</span><span class=\"o\">=</span><span class=\"mi\">5</span><span class=\"p\">):</span>\n",
       "    <span class=\"sd\">&quot;&quot;&quot;An ensemble of Decision Trees trained using bagging and feature bagging.&quot;&quot;&quot;</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">data_bagging</span><span class=\"p\">(</span><span class=\"n\">dataset</span><span class=\"p\">,</span> <span class=\"n\">m</span><span class=\"o\">=</span><span class=\"mi\">0</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;Sample m examples with replacement&quot;&quot;&quot;</span>\n",
       "        <span class=\"n\">n</span> <span class=\"o\">=</span> <span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">examples</span><span class=\"p\">)</span>\n",
       "        <span class=\"k\">return</span> <span class=\"n\">weighted_sample_with_replacement</span><span class=\"p\">(</span><span class=\"n\">m</span> <span class=\"ow\">or</span> <span class=\"n\">n</span><span class=\"p\">,</span> <span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">examples</span><span class=\"p\">,</span> <span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">]</span><span class=\"o\">*</span><span class=\"n\">n</span><span class=\"p\">)</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">feature_bagging</span><span class=\"p\">(</span><span class=\"n\">dataset</span><span class=\"p\">,</span> <span class=\"n\">p</span><span class=\"o\">=</span><span class=\"mf\">0.7</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;Feature bagging with probability p to retain an attribute&quot;&quot;&quot;</span>\n",
       "        <span class=\"n\">inputs</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"n\">i</span> <span class=\"k\">for</span> <span class=\"n\">i</span> <span class=\"ow\">in</span> <span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">inputs</span> <span class=\"k\">if</span> <span class=\"n\">probability</span><span class=\"p\">(</span><span class=\"n\">p</span><span class=\"p\">)]</span>\n",
       "        <span class=\"k\">return</span> <span class=\"n\">inputs</span> <span class=\"ow\">or</span> <span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">inputs</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">predict</span><span class=\"p\">(</span><span class=\"n\">example</span><span class=\"p\">):</span>\n",
       "        <span class=\"k\">print</span><span class=\"p\">([</span><span class=\"n\">predictor</span><span class=\"p\">(</span><span class=\"n\">example</span><span class=\"p\">)</span> <span class=\"k\">for</span> <span class=\"n\">predictor</span> <span class=\"ow\">in</span> <span class=\"n\">predictors</span><span class=\"p\">])</span>\n",
       "        <span class=\"k\">return</span> <span class=\"n\">mode</span><span class=\"p\">(</span><span class=\"n\">predictor</span><span class=\"p\">(</span><span class=\"n\">example</span><span class=\"p\">)</span> <span class=\"k\">for</span> <span class=\"n\">predictor</span> <span class=\"ow\">in</span> <span class=\"n\">predictors</span><span class=\"p\">)</span>\n",
       "\n",
       "    <span class=\"n\">predictors</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"n\">DecisionTreeLearner</span><span class=\"p\">(</span><span class=\"n\">DataSet</span><span class=\"p\">(</span><span class=\"n\">examples</span><span class=\"o\">=</span><span class=\"n\">data_bagging</span><span class=\"p\">(</span><span class=\"n\">dataset</span><span class=\"p\">),</span>\n",
       "                                              <span class=\"n\">attrs</span><span class=\"o\">=</span><span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">attrs</span><span class=\"p\">,</span>\n",
       "                                              <span class=\"n\">attrnames</span><span class=\"o\">=</span><span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">attrnames</span><span class=\"p\">,</span>\n",
       "                                              <span class=\"n\">target</span><span class=\"o\">=</span><span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">target</span><span class=\"p\">,</span>\n",
       "                                              <span class=\"n\">inputs</span><span class=\"o\">=</span><span class=\"n\">feature_bagging</span><span class=\"p\">(</span><span class=\"n\">dataset</span><span class=\"p\">)))</span> <span class=\"k\">for</span> <span class=\"n\">_</span> <span class=\"ow\">in</span> <span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"n\">n</span><span class=\"p\">)]</span>\n",
       "\n",
       "    <span class=\"k\">return</span> <span class=\"n\">predict</span>\n",
       "</pre></div>\n",
       "</body>\n",
       "</html>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "psource(RandomForest)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This algorithm creates an ensemble of decision trees using bagging and feature bagging. It takes 'm' examples randomly from the total number of examples and then perform feature bagging with probability p to retain an attribute. All the predictors are predicted from the DecisionTreeLearner and then a final prediction is made.\n",
    "\n",
    "\n",
    "### Example\n",
    "\n",
    "We will now use the Random Forest to classify a sample with values: 5.1, 3.0, 1.1, 0.1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['setosa', 'setosa', 'versicolor', 'setosa', 'setosa']\n",
      "setosa\n"
     ]
    }
   ],
   "source": [
    "iris = DataSet(name=\"iris\")\n",
    "\n",
    "DTL = RandomForest(iris)\n",
    "print(DTL([5.1, 3.0, 1.1, 0.1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As expected, the Random Forest classifies the sample as \"setosa\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NAIVE BAYES LEARNER\n",
    "\n",
    "### Overview\n",
    "\n",
    "#### Theory of Probabilities\n",
    "\n",
    "The Naive Bayes algorithm is a probabilistic classifier, making use of [Bayes' Theorem](https://en.wikipedia.org/wiki/Bayes%27_theorem). The theorem states that the conditional probability of **A** given **B** equals the conditional probability of **B** given **A** multiplied by the probability of **A**, divided by the probability of **B**.\n",
    "\n",
    "$$P(A|B) = \\dfrac{P(B|A)*P(A)}{P(B)}$$\n",
    "\n",
    "From the theory of Probabilities we have the Multiplication Rule, if the events *X* are independent the following is true:\n",
    "\n",
    "$$P(X_{1} \\cap X_{2} \\cap ... \\cap X_{n}) = P(X_{1})*P(X_{2})*...*P(X_{n})$$\n",
    "\n",
    "For conditional probabilities this becomes:\n",
    "\n",
    "$$P(X_{1}, X_{2}, ..., X_{n}|Y) = P(X_{1}|Y)*P(X_{2}|Y)*...*P(X_{n}|Y)$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Classifying an Item\n",
    "\n",
    "How can we use the above to classify an item though?\n",
    "\n",
    "We have a dataset with a set of classes (**C**) and we want to classify an item with a set of features (**F**). Essentially what we want to do is predict the class of an item given the features.\n",
    "\n",
    "For a specific class, **Class**, we will find the conditional probability given the item features:\n",
    "\n",
    "$$P(Class|F) = \\dfrac{P(F|Class)*P(Class)}{P(F)}$$\n",
    "\n",
    "We will do this for every class and we will pick the maximum. This will be the class the item is classified in.\n",
    "\n",
    "The features though are a vector with many elements. We need to break the probabilities up using the multiplication rule. Thus the above equation becomes:\n",
    "\n",
    "$$P(Class|F) = \\dfrac{P(Class)*P(F_{1}|Class)*P(F_{2}|Class)*...*P(F_{n}|Class)}{P(F_{1})*P(F_{2})*...*P(F_{n})}$$\n",
    "\n",
    "The calculation of the conditional probability then depends on the calculation of the following:\n",
    "\n",
    "*a)* The probability of **Class** in the dataset.\n",
    "\n",
    "*b)* The conditional probability of each feature occurring in an item classified in **Class**.\n",
    "\n",
    "*c)* The probabilities of each individual feature.\n",
    "\n",
    "For *a)*, we will count how many times **Class** occurs in the dataset (aka how many items are classified in a particular class).\n",
    "\n",
    "For *b)*, if the feature values are discrete ('Blue', '3', 'Tall', etc.), we will count how many times a feature value occurs in items of each class. If the feature values are not discrete, we will go a different route. We will use a distribution function to calculate the probability of values for a given class and feature. If we know the distribution function of the dataset, then great, we will use it to compute the probabilities. If we don't know the function, we can assume the dataset follows the normal (Gaussian) distribution without much loss of accuracy. In fact, it can be proven that any distribution tends to the Gaussian the larger the population gets (see [Central Limit Theorem](https://en.wikipedia.org/wiki/Central_limit_theorem)).\n",
    "\n",
    "*NOTE:* If the values are continuous but use the discrete approach, there might be issues if we are not lucky. For one, if we have two values, '5.0 and 5.1', with the discrete approach they will be two completely different values, despite being so close. Second, if we are trying to classify an item with a feature value of '5.15', if the value does not appear for the feature, its probability will be 0. This might lead to misclassification. Generally, the continuous approach is more accurate and more useful, despite the overhead of calculating the distribution function.\n",
    "\n",
    "The last one, *c)*, is tricky. If feature values are discrete, we can count how many times they occur in the dataset. But what if the feature values are continuous? Imagine a dataset with a height feature. Is it worth it to count how many times each value occurs? Most of the time it is not, since there can be miscellaneous differences in the values (for example, 1.7 meters and 1.700001 meters are practically equal, but they count as different values).\n",
    "\n",
    "So as we cannot calculate the feature value probabilities, what are we going to do?\n",
    "\n",
    "Let's take a step back and rethink exactly what we are doing. We are essentially comparing conditional probabilities of all the classes. For two classes, **A** and **B**, we want to know which one is greater:\n",
    "\n",
    "$$\\dfrac{P(F|A)*P(A)}{P(F)} vs. \\dfrac{P(F|B)*P(B)}{P(F)}$$\n",
    "\n",
    "Wait, **P(F)** is the same for both the classes! In fact, it is the same for every combination of classes. That is because **P(F)** does not depend on a class, thus being independent of the classes.\n",
    "\n",
    "So, for *c)*, we actually don't need to calculate it at all."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Wrapping It Up\n",
    "\n",
    "Classifying an item to a class then becomes a matter of calculating the conditional probabilities of feature values and the probabilities of classes. This is something very desirable and computationally delicious.\n",
    "\n",
    "Remember though that all the above are true because we made the assumption that the features are independent. In most real-world cases that is not true though. Is that an issue here? Fret not, for the the algorithm is very efficient even with that assumption. That is why the algorithm is called **Naive** Bayes Classifier. We (naively) assume that the features are independent to make computations easier."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementation\n",
    "\n",
    "The implementation of the Naive Bayes Classifier is split in two; *Learning* and *Simple*. The *learning* classifier takes as input a dataset and learns the needed distributions from that. It is itself split into two, for discrete and continuous features. The *simple* classifier takes as input not a dataset, but already calculated distributions (a dictionary of `CountingProbDist` objects)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Discrete\n",
    "\n",
    "The implementation for discrete values counts how many times each feature value occurs for each class, and how many times each class occurs. The results are stored in a `CountinProbDist` object."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the below code you can see the probabilities of the class \"Setosa\" appearing in the dataset and the probability of the first feature (at index 0) of the same class having a value of 5. Notice that the second probability is relatively small, even though if we observe the dataset we will find that a lot of values are around 5. The issue arises because the features in the Iris dataset are continuous, and we are assuming they are discrete. If the features were discrete (for example, \"Tall\", \"3\", etc.) this probably wouldn't have been the case and we would see a much nicer probability distribution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.3333333333333333\n",
      "0.10588235294117647\n"
     ]
    }
   ],
   "source": [
    "dataset = iris\n",
    "\n",
    "target_vals = dataset.values[dataset.target]\n",
    "target_dist = CountingProbDist(target_vals)\n",
    "attr_dists = {(gv, attr): CountingProbDist(dataset.values[attr])\n",
    "              for gv in target_vals\n",
    "              for attr in dataset.inputs}\n",
    "for example in dataset.examples:\n",
    "        targetval = example[dataset.target]\n",
    "        target_dist.add(targetval)\n",
    "        for attr in dataset.inputs:\n",
    "            attr_dists[targetval, attr].add(example[attr])\n",
    "\n",
    "\n",
    "print(target_dist['setosa'])\n",
    "print(attr_dists['setosa', 0][5.0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First we found the different values for the classes (called targets here) and calculated their distribution. Next we initialized a dictionary of `CountingProbDist` objects, one for each class and feature. Finally, we iterated through the examples in the dataset and calculated the needed probabilites.\n",
    "\n",
    "Having calculated the different probabilities, we will move on to the predicting function. It will receive as input an item and output the most likely class. Using the above formula, it will multiply the probability of the class appearing, with the probability of each feature value appearing in the class. It will return the max result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "setosa\n"
     ]
    }
   ],
   "source": [
    "def predict(example):\n",
    "    def class_probability(targetval):\n",
    "        return (target_dist[targetval] *\n",
    "                product(attr_dists[targetval, attr][example[attr]]\n",
    "                        for attr in dataset.inputs))\n",
    "    return argmax(target_vals, key=class_probability)\n",
    "\n",
    "\n",
    "print(predict([5, 3, 1, 0.1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can view the complete code by executing the next line:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01//EN\"\n",
       "   \"http://www.w3.org/TR/html4/strict.dtd\">\n",
       "\n",
       "<html>\n",
       "<head>\n",
       "  <title></title>\n",
       "  <meta http-equiv=\"content-type\" content=\"text/html; charset=None\">\n",
       "  <style type=\"text/css\">\n",
       "td.linenos { background-color: #f0f0f0; padding-right: 10px; }\n",
       "span.lineno { background-color: #f0f0f0; padding: 0 5px 0 5px; }\n",
       "pre { line-height: 125%; }\n",
       "body .hll { background-color: #ffffcc }\n",
       "body  { background: #f8f8f8; }\n",
       "body .c { color: #408080; font-style: italic } /* Comment */\n",
       "body .err { border: 1px solid #FF0000 } /* Error */\n",
       "body .k { color: #008000; font-weight: bold } /* Keyword */\n",
       "body .o { color: #666666 } /* Operator */\n",
       "body .ch { color: #408080; font-style: italic } /* Comment.Hashbang */\n",
       "body .cm { color: #408080; font-style: italic } /* Comment.Multiline */\n",
       "body .cp { color: #BC7A00 } /* Comment.Preproc */\n",
       "body .cpf { color: #408080; font-style: italic } /* Comment.PreprocFile */\n",
       "body .c1 { color: #408080; font-style: italic } /* Comment.Single */\n",
       "body .cs { color: #408080; font-style: italic } /* Comment.Special */\n",
       "body .gd { color: #A00000 } /* Generic.Deleted */\n",
       "body .ge { font-style: italic } /* Generic.Emph */\n",
       "body .gr { color: #FF0000 } /* Generic.Error */\n",
       "body .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
       "body .gi { color: #00A000 } /* Generic.Inserted */\n",
       "body .go { color: #888888 } /* Generic.Output */\n",
       "body .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
       "body .gs { font-weight: bold } /* Generic.Strong */\n",
       "body .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
       "body .gt { color: #0044DD } /* Generic.Traceback */\n",
       "body .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
       "body .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
       "body .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
       "body .kp { color: #008000 } /* Keyword.Pseudo */\n",
       "body .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
       "body .kt { color: #B00040 } /* Keyword.Type */\n",
       "body .m { color: #666666 } /* Literal.Number */\n",
       "body .s { color: #BA2121 } /* Literal.String */\n",
       "body .na { color: #7D9029 } /* Name.Attribute */\n",
       "body .nb { color: #008000 } /* Name.Builtin */\n",
       "body .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
       "body .no { color: #880000 } /* Name.Constant */\n",
       "body .nd { color: #AA22FF } /* Name.Decorator */\n",
       "body .ni { color: #999999; font-weight: bold } /* Name.Entity */\n",
       "body .ne { color: #D2413A; font-weight: bold } /* Name.Exception */\n",
       "body .nf { color: #0000FF } /* Name.Function */\n",
       "body .nl { color: #A0A000 } /* Name.Label */\n",
       "body .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
       "body .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
       "body .nv { color: #19177C } /* Name.Variable */\n",
       "body .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
       "body .w { color: #bbbbbb } /* Text.Whitespace */\n",
       "body .mb { color: #666666 } /* Literal.Number.Bin */\n",
       "body .mf { color: #666666 } /* Literal.Number.Float */\n",
       "body .mh { color: #666666 } /* Literal.Number.Hex */\n",
       "body .mi { color: #666666 } /* Literal.Number.Integer */\n",
       "body .mo { color: #666666 } /* Literal.Number.Oct */\n",
       "body .sa { color: #BA2121 } /* Literal.String.Affix */\n",
       "body .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
       "body .sc { color: #BA2121 } /* Literal.String.Char */\n",
       "body .dl { color: #BA2121 } /* Literal.String.Delimiter */\n",
       "body .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
       "body .s2 { color: #BA2121 } /* Literal.String.Double */\n",
       "body .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */\n",
       "body .sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
       "body .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */\n",
       "body .sx { color: #008000 } /* Literal.String.Other */\n",
       "body .sr { color: #BB6688 } /* Literal.String.Regex */\n",
       "body .s1 { color: #BA2121 } /* Literal.String.Single */\n",
       "body .ss { color: #19177C } /* Literal.String.Symbol */\n",
       "body .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
       "body .fm { color: #0000FF } /* Name.Function.Magic */\n",
       "body .vc { color: #19177C } /* Name.Variable.Class */\n",
       "body .vg { color: #19177C } /* Name.Variable.Global */\n",
       "body .vi { color: #19177C } /* Name.Variable.Instance */\n",
       "body .vm { color: #19177C } /* Name.Variable.Magic */\n",
       "body .il { color: #666666 } /* Literal.Number.Integer.Long */\n",
       "\n",
       "  </style>\n",
       "</head>\n",
       "<body>\n",
       "<h2></h2>\n",
       "\n",
       "<div class=\"highlight\"><pre><span></span><span class=\"k\">def</span> <span class=\"nf\">NaiveBayesDiscrete</span><span class=\"p\">(</span><span class=\"n\">dataset</span><span class=\"p\">):</span>\n",
       "    <span class=\"sd\">&quot;&quot;&quot;Just count how many times each value of each input attribute</span>\n",
       "<span class=\"sd\">    occurs, conditional on the target value. Count the different</span>\n",
       "<span class=\"sd\">    target values too.&quot;&quot;&quot;</span>\n",
       "\n",
       "    <span class=\"n\">target_vals</span> <span class=\"o\">=</span> <span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">values</span><span class=\"p\">[</span><span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">target</span><span class=\"p\">]</span>\n",
       "    <span class=\"n\">target_dist</span> <span class=\"o\">=</span> <span class=\"n\">CountingProbDist</span><span class=\"p\">(</span><span class=\"n\">target_vals</span><span class=\"p\">)</span>\n",
       "    <span class=\"n\">attr_dists</span> <span class=\"o\">=</span> <span class=\"p\">{(</span><span class=\"n\">gv</span><span class=\"p\">,</span> <span class=\"n\">attr</span><span class=\"p\">):</span> <span class=\"n\">CountingProbDist</span><span class=\"p\">(</span><span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">values</span><span class=\"p\">[</span><span class=\"n\">attr</span><span class=\"p\">])</span>\n",
       "                  <span class=\"k\">for</span> <span class=\"n\">gv</span> <span class=\"ow\">in</span> <span class=\"n\">target_vals</span>\n",
       "                  <span class=\"k\">for</span> <span class=\"n\">attr</span> <span class=\"ow\">in</span> <span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">inputs</span><span class=\"p\">}</span>\n",
       "    <span class=\"k\">for</span> <span class=\"n\">example</span> <span class=\"ow\">in</span> <span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">examples</span><span class=\"p\">:</span>\n",
       "        <span class=\"n\">targetval</span> <span class=\"o\">=</span> <span class=\"n\">example</span><span class=\"p\">[</span><span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">target</span><span class=\"p\">]</span>\n",
       "        <span class=\"n\">target_dist</span><span class=\"o\">.</span><span class=\"n\">add</span><span class=\"p\">(</span><span class=\"n\">targetval</span><span class=\"p\">)</span>\n",
       "        <span class=\"k\">for</span> <span class=\"n\">attr</span> <span class=\"ow\">in</span> <span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">inputs</span><span class=\"p\">:</span>\n",
       "            <span class=\"n\">attr_dists</span><span class=\"p\">[</span><span class=\"n\">targetval</span><span class=\"p\">,</span> <span class=\"n\">attr</span><span class=\"p\">]</span><span class=\"o\">.</span><span class=\"n\">add</span><span class=\"p\">(</span><span class=\"n\">example</span><span class=\"p\">[</span><span class=\"n\">attr</span><span class=\"p\">])</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">predict</span><span class=\"p\">(</span><span class=\"n\">example</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;Predict the target value for example. Consider each possible value,</span>\n",
       "<span class=\"sd\">        and pick the most likely by looking at each attribute independently.&quot;&quot;&quot;</span>\n",
       "        <span class=\"k\">def</span> <span class=\"nf\">class_probability</span><span class=\"p\">(</span><span class=\"n\">targetval</span><span class=\"p\">):</span>\n",
       "            <span class=\"k\">return</span> <span class=\"p\">(</span><span class=\"n\">target_dist</span><span class=\"p\">[</span><span class=\"n\">targetval</span><span class=\"p\">]</span> <span class=\"o\">*</span>\n",
       "                    <span class=\"n\">product</span><span class=\"p\">(</span><span class=\"n\">attr_dists</span><span class=\"p\">[</span><span class=\"n\">targetval</span><span class=\"p\">,</span> <span class=\"n\">attr</span><span class=\"p\">][</span><span class=\"n\">example</span><span class=\"p\">[</span><span class=\"n\">attr</span><span class=\"p\">]]</span>\n",
       "                            <span class=\"k\">for</span> <span class=\"n\">attr</span> <span class=\"ow\">in</span> <span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">inputs</span><span class=\"p\">))</span>\n",
       "        <span class=\"k\">return</span> <span class=\"n\">argmax</span><span class=\"p\">(</span><span class=\"n\">target_vals</span><span class=\"p\">,</span> <span class=\"n\">key</span><span class=\"o\">=</span><span class=\"n\">class_probability</span><span class=\"p\">)</span>\n",
       "\n",
       "    <span class=\"k\">return</span> <span class=\"n\">predict</span>\n",
       "</pre></div>\n",
       "</body>\n",
       "</html>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "psource(NaiveBayesDiscrete)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Continuous\n",
    "\n",
    "In the implementation we use the Gaussian/Normal distribution function. To make it work, we need to find the means and standard deviations of features for each class. We make use of the `find_means_and_deviations` Dataset function. On top of that, we will also calculate the class probabilities as we did with the Discrete approach."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5.006, 3.418, 1.464, 0.244]\n",
      "[0.5161711470638634, 0.3137983233784114, 0.46991097723995795, 0.19775268000454405]\n"
     ]
    }
   ],
   "source": [
    "means, deviations = dataset.find_means_and_deviations()\n",
    "\n",
    "target_vals = dataset.values[dataset.target]\n",
    "target_dist = CountingProbDist(target_vals)\n",
    "\n",
    "\n",
    "print(means[\"setosa\"])\n",
    "print(deviations[\"versicolor\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see the means of the features for the \"Setosa\" class and the deviations for \"Versicolor\".\n",
    "\n",
    "The prediction function will work similarly to the Discrete algorithm. It will multiply the probability of the class occurring with the conditional probabilities of the feature values for the class.\n",
    "\n",
    "Since we are using the Gaussian distribution, we will input the value for each feature into the Gaussian function, together with the mean and deviation of the feature. This will return the probability of the particular feature value for the given class. We will repeat for each class and pick the max value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "setosa\n"
     ]
    }
   ],
   "source": [
    "def predict(example):\n",
    "    def class_probability(targetval):\n",
    "        prob = target_dist[targetval]\n",
    "        for attr in dataset.inputs:\n",
    "            prob *= gaussian(means[targetval][attr], deviations[targetval][attr], example[attr])\n",
    "        return prob\n",
    "\n",
    "    return argmax(target_vals, key=class_probability)\n",
    "\n",
    "\n",
    "print(predict([5, 3, 1, 0.1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The complete code of the continuous algorithm:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01//EN\"\n",
       "   \"http://www.w3.org/TR/html4/strict.dtd\">\n",
       "\n",
       "<html>\n",
       "<head>\n",
       "  <title></title>\n",
       "  <meta http-equiv=\"content-type\" content=\"text/html; charset=None\">\n",
       "  <style type=\"text/css\">\n",
       "td.linenos { background-color: #f0f0f0; padding-right: 10px; }\n",
       "span.lineno { background-color: #f0f0f0; padding: 0 5px 0 5px; }\n",
       "pre { line-height: 125%; }\n",
       "body .hll { background-color: #ffffcc }\n",
       "body  { background: #f8f8f8; }\n",
       "body .c { color: #408080; font-style: italic } /* Comment */\n",
       "body .err { border: 1px solid #FF0000 } /* Error */\n",
       "body .k { color: #008000; font-weight: bold } /* Keyword */\n",
       "body .o { color: #666666 } /* Operator */\n",
       "body .ch { color: #408080; font-style: italic } /* Comment.Hashbang */\n",
       "body .cm { color: #408080; font-style: italic } /* Comment.Multiline */\n",
       "body .cp { color: #BC7A00 } /* Comment.Preproc */\n",
       "body .cpf { color: #408080; font-style: italic } /* Comment.PreprocFile */\n",
       "body .c1 { color: #408080; font-style: italic } /* Comment.Single */\n",
       "body .cs { color: #408080; font-style: italic } /* Comment.Special */\n",
       "body .gd { color: #A00000 } /* Generic.Deleted */\n",
       "body .ge { font-style: italic } /* Generic.Emph */\n",
       "body .gr { color: #FF0000 } /* Generic.Error */\n",
       "body .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
       "body .gi { color: #00A000 } /* Generic.Inserted */\n",
       "body .go { color: #888888 } /* Generic.Output */\n",
       "body .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
       "body .gs { font-weight: bold } /* Generic.Strong */\n",
       "body .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
       "body .gt { color: #0044DD } /* Generic.Traceback */\n",
       "body .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
       "body .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
       "body .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
       "body .kp { color: #008000 } /* Keyword.Pseudo */\n",
       "body .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
       "body .kt { color: #B00040 } /* Keyword.Type */\n",
       "body .m { color: #666666 } /* Literal.Number */\n",
       "body .s { color: #BA2121 } /* Literal.String */\n",
       "body .na { color: #7D9029 } /* Name.Attribute */\n",
       "body .nb { color: #008000 } /* Name.Builtin */\n",
       "body .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
       "body .no { color: #880000 } /* Name.Constant */\n",
       "body .nd { color: #AA22FF } /* Name.Decorator */\n",
       "body .ni { color: #999999; font-weight: bold } /* Name.Entity */\n",
       "body .ne { color: #D2413A; font-weight: bold } /* Name.Exception */\n",
       "body .nf { color: #0000FF } /* Name.Function */\n",
       "body .nl { color: #A0A000 } /* Name.Label */\n",
       "body .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
       "body .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
       "body .nv { color: #19177C } /* Name.Variable */\n",
       "body .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
       "body .w { color: #bbbbbb } /* Text.Whitespace */\n",
       "body .mb { color: #666666 } /* Literal.Number.Bin */\n",
       "body .mf { color: #666666 } /* Literal.Number.Float */\n",
       "body .mh { color: #666666 } /* Literal.Number.Hex */\n",
       "body .mi { color: #666666 } /* Literal.Number.Integer */\n",
       "body .mo { color: #666666 } /* Literal.Number.Oct */\n",
       "body .sa { color: #BA2121 } /* Literal.String.Affix */\n",
       "body .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
       "body .sc { color: #BA2121 } /* Literal.String.Char */\n",
       "body .dl { color: #BA2121 } /* Literal.String.Delimiter */\n",
       "body .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
       "body .s2 { color: #BA2121 } /* Literal.String.Double */\n",
       "body .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */\n",
       "body .sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
       "body .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */\n",
       "body .sx { color: #008000 } /* Literal.String.Other */\n",
       "body .sr { color: #BB6688 } /* Literal.String.Regex */\n",
       "body .s1 { color: #BA2121 } /* Literal.String.Single */\n",
       "body .ss { color: #19177C } /* Literal.String.Symbol */\n",
       "body .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
       "body .fm { color: #0000FF } /* Name.Function.Magic */\n",
       "body .vc { color: #19177C } /* Name.Variable.Class */\n",
       "body .vg { color: #19177C } /* Name.Variable.Global */\n",
       "body .vi { color: #19177C } /* Name.Variable.Instance */\n",
       "body .vm { color: #19177C } /* Name.Variable.Magic */\n",
       "body .il { color: #666666 } /* Literal.Number.Integer.Long */\n",
       "\n",
       "  </style>\n",
       "</head>\n",
       "<body>\n",
       "<h2></h2>\n",
       "\n",
       "<div class=\"highlight\"><pre><span></span><span class=\"k\">def</span> <span class=\"nf\">NaiveBayesContinuous</span><span class=\"p\">(</span><span class=\"n\">dataset</span><span class=\"p\">):</span>\n",
       "    <span class=\"sd\">&quot;&quot;&quot;Count how many times each target value occurs.</span>\n",
       "<span class=\"sd\">    Also, find the means and deviations of input attribute values for each target value.&quot;&quot;&quot;</span>\n",
       "    <span class=\"n\">means</span><span class=\"p\">,</span> <span class=\"n\">deviations</span> <span class=\"o\">=</span> <span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">find_means_and_deviations</span><span class=\"p\">()</span>\n",
       "\n",
       "    <span class=\"n\">target_vals</span> <span class=\"o\">=</span> <span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">values</span><span class=\"p\">[</span><span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">target</span><span class=\"p\">]</span>\n",
       "    <span class=\"n\">target_dist</span> <span class=\"o\">=</span> <span class=\"n\">CountingProbDist</span><span class=\"p\">(</span><span class=\"n\">target_vals</span><span class=\"p\">)</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">predict</span><span class=\"p\">(</span><span class=\"n\">example</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;Predict the target value for example. Consider each possible value,</span>\n",
       "<span class=\"sd\">        and pick the most likely by looking at each attribute independently.&quot;&quot;&quot;</span>\n",
       "        <span class=\"k\">def</span> <span class=\"nf\">class_probability</span><span class=\"p\">(</span><span class=\"n\">targetval</span><span class=\"p\">):</span>\n",
       "            <span class=\"n\">prob</span> <span class=\"o\">=</span> <span class=\"n\">target_dist</span><span class=\"p\">[</span><span class=\"n\">targetval</span><span class=\"p\">]</span>\n",
       "            <span class=\"k\">for</span> <span class=\"n\">attr</span> <span class=\"ow\">in</span> <span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">inputs</span><span class=\"p\">:</span>\n",
       "                <span class=\"n\">prob</span> <span class=\"o\">*=</span> <span class=\"n\">gaussian</span><span class=\"p\">(</span><span class=\"n\">means</span><span class=\"p\">[</span><span class=\"n\">targetval</span><span class=\"p\">][</span><span class=\"n\">attr</span><span class=\"p\">],</span> <span class=\"n\">deviations</span><span class=\"p\">[</span><span class=\"n\">targetval</span><span class=\"p\">][</span><span class=\"n\">attr</span><span class=\"p\">],</span> <span class=\"n\">example</span><span class=\"p\">[</span><span class=\"n\">attr</span><span class=\"p\">])</span>\n",
       "            <span class=\"k\">return</span> <span class=\"n\">prob</span>\n",
       "\n",
       "        <span class=\"k\">return</span> <span class=\"n\">argmax</span><span class=\"p\">(</span><span class=\"n\">target_vals</span><span class=\"p\">,</span> <span class=\"n\">key</span><span class=\"o\">=</span><span class=\"n\">class_probability</span><span class=\"p\">)</span>\n",
       "\n",
       "    <span class=\"k\">return</span> <span class=\"n\">predict</span>\n",
       "</pre></div>\n",
       "</body>\n",
       "</html>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "psource(NaiveBayesContinuous)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Simple\n",
    "\n",
    "The simple classifier (chosen with the argument `simple`) does not learn from a dataset, instead it takes as input a dictionary of already calculated `CountingProbDist` objects and returns a predictor function. The dictionary is in the following form: `(Class Name, Class Probability): CountingProbDist Object`.\n",
    "\n",
    "Each class has its own probability distribution. The classifier given a list of features calculates the probability of the input for each class and returns the max. The only pre-processing work is to create dictionaries for the distribution of classes (named `targets`) and attributes/features.\n",
    "\n",
    "The complete code for the simple classifier:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01//EN\"\n",
       "   \"http://www.w3.org/TR/html4/strict.dtd\">\n",
       "\n",
       "<html>\n",
       "<head>\n",
       "  <title></title>\n",
       "  <meta http-equiv=\"content-type\" content=\"text/html; charset=None\">\n",
       "  <style type=\"text/css\">\n",
       "td.linenos { background-color: #f0f0f0; padding-right: 10px; }\n",
       "span.lineno { background-color: #f0f0f0; padding: 0 5px 0 5px; }\n",
       "pre { line-height: 125%; }\n",
       "body .hll { background-color: #ffffcc }\n",
       "body  { background: #f8f8f8; }\n",
       "body .c { color: #408080; font-style: italic } /* Comment */\n",
       "body .err { border: 1px solid #FF0000 } /* Error */\n",
       "body .k { color: #008000; font-weight: bold } /* Keyword */\n",
       "body .o { color: #666666 } /* Operator */\n",
       "body .ch { color: #408080; font-style: italic } /* Comment.Hashbang */\n",
       "body .cm { color: #408080; font-style: italic } /* Comment.Multiline */\n",
       "body .cp { color: #BC7A00 } /* Comment.Preproc */\n",
       "body .cpf { color: #408080; font-style: italic } /* Comment.PreprocFile */\n",
       "body .c1 { color: #408080; font-style: italic } /* Comment.Single */\n",
       "body .cs { color: #408080; font-style: italic } /* Comment.Special */\n",
       "body .gd { color: #A00000 } /* Generic.Deleted */\n",
       "body .ge { font-style: italic } /* Generic.Emph */\n",
       "body .gr { color: #FF0000 } /* Generic.Error */\n",
       "body .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
       "body .gi { color: #00A000 } /* Generic.Inserted */\n",
       "body .go { color: #888888 } /* Generic.Output */\n",
       "body .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
       "body .gs { font-weight: bold } /* Generic.Strong */\n",
       "body .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
       "body .gt { color: #0044DD } /* Generic.Traceback */\n",
       "body .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
       "body .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
       "body .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
       "body .kp { color: #008000 } /* Keyword.Pseudo */\n",
       "body .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
       "body .kt { color: #B00040 } /* Keyword.Type */\n",
       "body .m { color: #666666 } /* Literal.Number */\n",
       "body .s { color: #BA2121 } /* Literal.String */\n",
       "body .na { color: #7D9029 } /* Name.Attribute */\n",
       "body .nb { color: #008000 } /* Name.Builtin */\n",
       "body .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
       "body .no { color: #880000 } /* Name.Constant */\n",
       "body .nd { color: #AA22FF } /* Name.Decorator */\n",
       "body .ni { color: #999999; font-weight: bold } /* Name.Entity */\n",
       "body .ne { color: #D2413A; font-weight: bold } /* Name.Exception */\n",
       "body .nf { color: #0000FF } /* Name.Function */\n",
       "body .nl { color: #A0A000 } /* Name.Label */\n",
       "body .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
       "body .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
       "body .nv { color: #19177C } /* Name.Variable */\n",
       "body .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
       "body .w { color: #bbbbbb } /* Text.Whitespace */\n",
       "body .mb { color: #666666 } /* Literal.Number.Bin */\n",
       "body .mf { color: #666666 } /* Literal.Number.Float */\n",
       "body .mh { color: #666666 } /* Literal.Number.Hex */\n",
       "body .mi { color: #666666 } /* Literal.Number.Integer */\n",
       "body .mo { color: #666666 } /* Literal.Number.Oct */\n",
       "body .sa { color: #BA2121 } /* Literal.String.Affix */\n",
       "body .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
       "body .sc { color: #BA2121 } /* Literal.String.Char */\n",
       "body .dl { color: #BA2121 } /* Literal.String.Delimiter */\n",
       "body .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
       "body .s2 { color: #BA2121 } /* Literal.String.Double */\n",
       "body .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */\n",
       "body .sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
       "body .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */\n",
       "body .sx { color: #008000 } /* Literal.String.Other */\n",
       "body .sr { color: #BB6688 } /* Literal.String.Regex */\n",
       "body .s1 { color: #BA2121 } /* Literal.String.Single */\n",
       "body .ss { color: #19177C } /* Literal.String.Symbol */\n",
       "body .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
       "body .fm { color: #0000FF } /* Name.Function.Magic */\n",
       "body .vc { color: #19177C } /* Name.Variable.Class */\n",
       "body .vg { color: #19177C } /* Name.Variable.Global */\n",
       "body .vi { color: #19177C } /* Name.Variable.Instance */\n",
       "body .vm { color: #19177C } /* Name.Variable.Magic */\n",
       "body .il { color: #666666 } /* Literal.Number.Integer.Long */\n",
       "\n",
       "  </style>\n",
       "</head>\n",
       "<body>\n",
       "<h2></h2>\n",
       "\n",
       "<div class=\"highlight\"><pre><span></span><span class=\"k\">def</span> <span class=\"nf\">NaiveBayesSimple</span><span class=\"p\">(</span><span class=\"n\">distribution</span><span class=\"p\">):</span>\n",
       "    <span class=\"sd\">&quot;&quot;&quot;A simple naive bayes classifier that takes as input a dictionary of</span>\n",
       "<span class=\"sd\">    CountingProbDist objects and classifies items according to these distributions.</span>\n",
       "<span class=\"sd\">    The input dictionary is in the following form:</span>\n",
       "<span class=\"sd\">        (ClassName, ClassProb): CountingProbDist&quot;&quot;&quot;</span>\n",
       "    <span class=\"n\">target_dist</span> <span class=\"o\">=</span> <span class=\"p\">{</span><span class=\"n\">c_name</span><span class=\"p\">:</span> <span class=\"n\">prob</span> <span class=\"k\">for</span> <span class=\"n\">c_name</span><span class=\"p\">,</span> <span class=\"n\">prob</span> <span class=\"ow\">in</span> <span class=\"n\">distribution</span><span class=\"o\">.</span><span class=\"n\">keys</span><span class=\"p\">()}</span>\n",
       "    <span class=\"n\">attr_dists</span> <span class=\"o\">=</span> <span class=\"p\">{</span><span class=\"n\">c_name</span><span class=\"p\">:</span> <span class=\"n\">count_prob</span> <span class=\"k\">for</span> <span class=\"p\">(</span><span class=\"n\">c_name</span><span class=\"p\">,</span> <span class=\"n\">_</span><span class=\"p\">),</span> <span class=\"n\">count_prob</span> <span class=\"ow\">in</span> <span class=\"n\">distribution</span><span class=\"o\">.</span><span class=\"n\">items</span><span class=\"p\">()}</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">predict</span><span class=\"p\">(</span><span class=\"n\">example</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;Predict the target value for example. Calculate probabilities for each</span>\n",
       "<span class=\"sd\">        class and pick the max.&quot;&quot;&quot;</span>\n",
       "        <span class=\"k\">def</span> <span class=\"nf\">class_probability</span><span class=\"p\">(</span><span class=\"n\">targetval</span><span class=\"p\">):</span>\n",
       "            <span class=\"n\">attr_dist</span> <span class=\"o\">=</span> <span class=\"n\">attr_dists</span><span class=\"p\">[</span><span class=\"n\">targetval</span><span class=\"p\">]</span>\n",
       "            <span class=\"k\">return</span> <span class=\"n\">target_dist</span><span class=\"p\">[</span><span class=\"n\">targetval</span><span class=\"p\">]</span> <span class=\"o\">*</span> <span class=\"n\">product</span><span class=\"p\">(</span><span class=\"n\">attr_dist</span><span class=\"p\">[</span><span class=\"n\">a</span><span class=\"p\">]</span> <span class=\"k\">for</span> <span class=\"n\">a</span> <span class=\"ow\">in</span> <span class=\"n\">example</span><span class=\"p\">)</span>\n",
       "\n",
       "        <span class=\"k\">return</span> <span class=\"n\">argmax</span><span class=\"p\">(</span><span class=\"n\">target_dist</span><span class=\"o\">.</span><span class=\"n\">keys</span><span class=\"p\">(),</span> <span class=\"n\">key</span><span class=\"o\">=</span><span class=\"n\">class_probability</span><span class=\"p\">)</span>\n",
       "\n",
       "    <span class=\"k\">return</span> <span class=\"n\">predict</span>\n",
       "</pre></div>\n",
       "</body>\n",
       "</html>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "psource(NaiveBayesSimple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This classifier is useful when you already have calculated the distributions and you need to predict future items."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Examples\n",
    "\n",
    "We will now use the Naive Bayes Classifier (Discrete and Continuous) to classify items:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Discrete Classifier\n",
      "setosa\n",
      "versicolor\n",
      "versicolor\n",
      "\n",
      "Continuous Classifier\n",
      "setosa\n",
      "versicolor\n",
      "virginica\n"
     ]
    }
   ],
   "source": [
    "nBD = NaiveBayesLearner(iris, continuous=False)\n",
    "print(\"Discrete Classifier\")\n",
    "print(nBD([5, 3, 1, 0.1]))\n",
    "print(nBD([6, 5, 3, 1.5]))\n",
    "print(nBD([7, 3, 6.5, 2]))\n",
    "\n",
    "\n",
    "nBC = NaiveBayesLearner(iris, continuous=True)\n",
    "print(\"\\nContinuous Classifier\")\n",
    "print(nBC([5, 3, 1, 0.1]))\n",
    "print(nBC([6, 5, 3, 1.5]))\n",
    "print(nBC([7, 3, 6.5, 2]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how the Discrete Classifier misclassified the second item, while the Continuous one had no problem.\n",
    "\n",
    "Let's now take a look at the simple classifier. First we will come up with a sample problem to solve. Say we are given three bags. Each bag contains three letters ('a', 'b' and 'c') of different quantities. We are given a string of letters and we are tasked with finding from which bag the string of letters came.\n",
    "\n",
    "Since we know the probability distribution of the letters for each bag, we can use the naive bayes classifier to make our prediction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "bag1 = 'a'*50 + 'b'*30 + 'c'*15\n",
    "dist1 = CountingProbDist(bag1)\n",
    "bag2 = 'a'*30 + 'b'*45 + 'c'*20\n",
    "dist2 = CountingProbDist(bag2)\n",
    "bag3 = 'a'*20 + 'b'*20 + 'c'*35\n",
    "dist3 = CountingProbDist(bag3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have the `CountingProbDist` objects for each bag/class, we will create the dictionary. We assume that it is equally probable that we will pick from any bag."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "dist = {('First', 0.5): dist1, ('Second', 0.3): dist2, ('Third', 0.2): dist3}\n",
    "nBS = NaiveBayesLearner(dist, simple=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can start making predictions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First\n",
      "Second\n",
      "Third\n"
     ]
    }
   ],
   "source": [
    "print(nBS('aab'))        # We can handle strings\n",
    "print(nBS(['b', 'b']))   # And lists!\n",
    "print(nBS('ccbcc'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The results make intuitive sence. The first bag has a high amount of 'a's, the second has a high amount of 'b's and the third has a high amount of 'c's. The classifier seems to confirm this intuition.\n",
    "\n",
    "Note that the simple classifier doesn't distinguish between discrete and continuous values. It just takes whatever it is given. Also, the `simple` option on the `NaiveBayesLearner` overrides the `continuous` argument. `NaiveBayesLearner(d, simple=True, continuous=False)` just creates a simple classifier."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PERCEPTRON CLASSIFIER\n",
    "\n",
    "### Overview\n",
    "\n",
    "The Perceptron is a linear classifier. It works the same way as a neural network with no hidden layers (just input and output). First it trains its weights given a dataset and then it can classify a new item by running it through the network.\n",
    "\n",
    "Its input layer consists of the the item features, while the output layer consists of nodes (also called neurons). Each node in the output layer has *n* synapses (for every item feature), each with its own weight. Then, the nodes find the dot product of the item features and the synapse weights. These values then pass through an activation function (usually a sigmoid). Finally, we pick the largest of the values and we return its index.\n",
    "\n",
    "Note that in classification problems each node represents a class. The final classification is the class/node with the max output value.\n",
    "\n",
    "Below you can see a single node/neuron in the outer layer. With *f* we denote the item features, with *w* the synapse weights, then inside the node we have the dot product and the activation function, *g*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![perceptron](images/perceptron.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementation\n",
    "\n",
    "First, we train (calculate) the weights given a dataset, using the `BackPropagationLearner` function of `learning.py`. We then return a function, `predict`, which we will use in the future to classify a new item. The function computes the (algebraic) dot product of the item with the calculated weights for each node in the outer layer. Then it picks the greatest value and classifies the item in the corresponding class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01//EN\"\n",
       "   \"http://www.w3.org/TR/html4/strict.dtd\">\n",
       "\n",
       "<html>\n",
       "<head>\n",
       "  <title></title>\n",
       "  <meta http-equiv=\"content-type\" content=\"text/html; charset=None\">\n",
       "  <style type=\"text/css\">\n",
       "td.linenos { background-color: #f0f0f0; padding-right: 10px; }\n",
       "span.lineno { background-color: #f0f0f0; padding: 0 5px 0 5px; }\n",
       "pre { line-height: 125%; }\n",
       "body .hll { background-color: #ffffcc }\n",
       "body  { background: #f8f8f8; }\n",
       "body .c { color: #408080; font-style: italic } /* Comment */\n",
       "body .err { border: 1px solid #FF0000 } /* Error */\n",
       "body .k { color: #008000; font-weight: bold } /* Keyword */\n",
       "body .o { color: #666666 } /* Operator */\n",
       "body .ch { color: #408080; font-style: italic } /* Comment.Hashbang */\n",
       "body .cm { color: #408080; font-style: italic } /* Comment.Multiline */\n",
       "body .cp { color: #BC7A00 } /* Comment.Preproc */\n",
       "body .cpf { color: #408080; font-style: italic } /* Comment.PreprocFile */\n",
       "body .c1 { color: #408080; font-style: italic } /* Comment.Single */\n",
       "body .cs { color: #408080; font-style: italic } /* Comment.Special */\n",
       "body .gd { color: #A00000 } /* Generic.Deleted */\n",
       "body .ge { font-style: italic } /* Generic.Emph */\n",
       "body .gr { color: #FF0000 } /* Generic.Error */\n",
       "body .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
       "body .gi { color: #00A000 } /* Generic.Inserted */\n",
       "body .go { color: #888888 } /* Generic.Output */\n",
       "body .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
       "body .gs { font-weight: bold } /* Generic.Strong */\n",
       "body .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
       "body .gt { color: #0044DD } /* Generic.Traceback */\n",
       "body .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
       "body .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
       "body .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
       "body .kp { color: #008000 } /* Keyword.Pseudo */\n",
       "body .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
       "body .kt { color: #B00040 } /* Keyword.Type */\n",
       "body .m { color: #666666 } /* Literal.Number */\n",
       "body .s { color: #BA2121 } /* Literal.String */\n",
       "body .na { color: #7D9029 } /* Name.Attribute */\n",
       "body .nb { color: #008000 } /* Name.Builtin */\n",
       "body .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
       "body .no { color: #880000 } /* Name.Constant */\n",
       "body .nd { color: #AA22FF } /* Name.Decorator */\n",
       "body .ni { color: #999999; font-weight: bold } /* Name.Entity */\n",
       "body .ne { color: #D2413A; font-weight: bold } /* Name.Exception */\n",
       "body .nf { color: #0000FF } /* Name.Function */\n",
       "body .nl { color: #A0A000 } /* Name.Label */\n",
       "body .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
       "body .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
       "body .nv { color: #19177C } /* Name.Variable */\n",
       "body .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
       "body .w { color: #bbbbbb } /* Text.Whitespace */\n",
       "body .mb { color: #666666 } /* Literal.Number.Bin */\n",
       "body .mf { color: #666666 } /* Literal.Number.Float */\n",
       "body .mh { color: #666666 } /* Literal.Number.Hex */\n",
       "body .mi { color: #666666 } /* Literal.Number.Integer */\n",
       "body .mo { color: #666666 } /* Literal.Number.Oct */\n",
       "body .sa { color: #BA2121 } /* Literal.String.Affix */\n",
       "body .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
       "body .sc { color: #BA2121 } /* Literal.String.Char */\n",
       "body .dl { color: #BA2121 } /* Literal.String.Delimiter */\n",
       "body .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
       "body .s2 { color: #BA2121 } /* Literal.String.Double */\n",
       "body .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */\n",
       "body .sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
       "body .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */\n",
       "body .sx { color: #008000 } /* Literal.String.Other */\n",
       "body .sr { color: #BB6688 } /* Literal.String.Regex */\n",
       "body .s1 { color: #BA2121 } /* Literal.String.Single */\n",
       "body .ss { color: #19177C } /* Literal.String.Symbol */\n",
       "body .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
       "body .fm { color: #0000FF } /* Name.Function.Magic */\n",
       "body .vc { color: #19177C } /* Name.Variable.Class */\n",
       "body .vg { color: #19177C } /* Name.Variable.Global */\n",
       "body .vi { color: #19177C } /* Name.Variable.Instance */\n",
       "body .vm { color: #19177C } /* Name.Variable.Magic */\n",
       "body .il { color: #666666 } /* Literal.Number.Integer.Long */\n",
       "\n",
       "  </style>\n",
       "</head>\n",
       "<body>\n",
       "<h2></h2>\n",
       "\n",
       "<div class=\"highlight\"><pre><span></span><span class=\"k\">def</span> <span class=\"nf\">PerceptronLearner</span><span class=\"p\">(</span><span class=\"n\">dataset</span><span class=\"p\">,</span> <span class=\"n\">learning_rate</span><span class=\"o\">=</span><span class=\"mf\">0.01</span><span class=\"p\">,</span> <span class=\"n\">epochs</span><span class=\"o\">=</span><span class=\"mi\">100</span><span class=\"p\">):</span>\n",
       "    <span class=\"sd\">&quot;&quot;&quot;Logistic Regression, NO hidden layer&quot;&quot;&quot;</span>\n",
       "    <span class=\"n\">i_units</span> <span class=\"o\">=</span> <span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">inputs</span><span class=\"p\">)</span>\n",
       "    <span class=\"n\">o_units</span> <span class=\"o\">=</span> <span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">values</span><span class=\"p\">[</span><span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">target</span><span class=\"p\">])</span>\n",
       "    <span class=\"n\">hidden_layer_sizes</span> <span class=\"o\">=</span> <span class=\"p\">[]</span>\n",
       "    <span class=\"n\">raw_net</span> <span class=\"o\">=</span> <span class=\"n\">network</span><span class=\"p\">(</span><span class=\"n\">i_units</span><span class=\"p\">,</span> <span class=\"n\">hidden_layer_sizes</span><span class=\"p\">,</span> <span class=\"n\">o_units</span><span class=\"p\">)</span>\n",
       "    <span class=\"n\">learned_net</span> <span class=\"o\">=</span> <span class=\"n\">BackPropagationLearner</span><span class=\"p\">(</span><span class=\"n\">dataset</span><span class=\"p\">,</span> <span class=\"n\">raw_net</span><span class=\"p\">,</span> <span class=\"n\">learning_rate</span><span class=\"p\">,</span> <span class=\"n\">epochs</span><span class=\"p\">)</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">predict</span><span class=\"p\">(</span><span class=\"n\">example</span><span class=\"p\">):</span>\n",
       "        <span class=\"n\">o_nodes</span> <span class=\"o\">=</span> <span class=\"n\">learned_net</span><span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">]</span>\n",
       "\n",
       "        <span class=\"c1\"># Forward pass</span>\n",
       "        <span class=\"k\">for</span> <span class=\"n\">node</span> <span class=\"ow\">in</span> <span class=\"n\">o_nodes</span><span class=\"p\">:</span>\n",
       "            <span class=\"n\">in_val</span> <span class=\"o\">=</span> <span class=\"n\">dotproduct</span><span class=\"p\">(</span><span class=\"n\">example</span><span class=\"p\">,</span> <span class=\"n\">node</span><span class=\"o\">.</span><span class=\"n\">weights</span><span class=\"p\">)</span>\n",
       "            <span class=\"n\">node</span><span class=\"o\">.</span><span class=\"n\">value</span> <span class=\"o\">=</span> <span class=\"n\">node</span><span class=\"o\">.</span><span class=\"n\">activation</span><span class=\"p\">(</span><span class=\"n\">in_val</span><span class=\"p\">)</span>\n",
       "\n",
       "        <span class=\"c1\"># Hypothesis</span>\n",
       "        <span class=\"k\">return</span> <span class=\"n\">find_max_node</span><span class=\"p\">(</span><span class=\"n\">o_nodes</span><span class=\"p\">)</span>\n",
       "\n",
       "    <span class=\"k\">return</span> <span class=\"n\">predict</span>\n",
       "</pre></div>\n",
       "</body>\n",
       "</html>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "psource(PerceptronLearner)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the Perceptron is a one-layer neural network, without any hidden layers. So, in `BackPropagationLearner`, we will pass no hidden layers. From that function we get our network, which is just one layer, with the weights calculated.\n",
    "\n",
    "That function `predict` passes the input/example through the network, calculating the dot product of the input and the weights for each node and returns the class with the max dot product."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example\n",
    "\n",
    "We will train the Perceptron on the iris dataset. Because though the `BackPropagationLearner` works with integer indexes and not strings, we need to convert class names to integers. Then, we will try and classify the item/flower with measurements of 5, 3, 1, 0.1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "iris = DataSet(name=\"iris\")\n",
    "iris.classes_to_numbers()\n",
    "\n",
    "perceptron = PerceptronLearner(iris)\n",
    "print(perceptron([5, 3, 1, 0.1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The correct output is 0, which means the item belongs in the first class, \"setosa\". Note that the Perceptron algorithm is not perfect and may produce false classifications."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LINEAR LEARNER\n",
    "\n",
    "### Overview\n",
    "\n",
    "Linear Learner is a model that assumes a linear relationship between the input variables x and the single output variable y. More specifically, that y can be calculated from a linear combination of the input variables x. Linear learner is a quite simple model as the representation of this model is a linear equation.  \n",
    "\n",
    "The linear equation assigns one scaler factor to each input value or column, called a coefficients or weights. One additional coefficient is also added, giving additional degree of freedom and is often called the intercept or the bias coefficient.   \n",
    "For example :  y = ax1 + bx2 + c .  \n",
    "\n",
    "### Implementation\n",
    "\n",
    "Below mentioned is the implementation of Linear Learner."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01//EN\"\n",
       "   \"http://www.w3.org/TR/html4/strict.dtd\">\n",
       "\n",
       "<html>\n",
       "<head>\n",
       "  <title></title>\n",
       "  <meta http-equiv=\"content-type\" content=\"text/html; charset=None\">\n",
       "  <style type=\"text/css\">\n",
       "td.linenos { background-color: #f0f0f0; padding-right: 10px; }\n",
       "span.lineno { background-color: #f0f0f0; padding: 0 5px 0 5px; }\n",
       "pre { line-height: 125%; }\n",
       "body .hll { background-color: #ffffcc }\n",
       "body  { background: #f8f8f8; }\n",
       "body .c { color: #408080; font-style: italic } /* Comment */\n",
       "body .err { border: 1px solid #FF0000 } /* Error */\n",
       "body .k { color: #008000; font-weight: bold } /* Keyword */\n",
       "body .o { color: #666666 } /* Operator */\n",
       "body .ch { color: #408080; font-style: italic } /* Comment.Hashbang */\n",
       "body .cm { color: #408080; font-style: italic } /* Comment.Multiline */\n",
       "body .cp { color: #BC7A00 } /* Comment.Preproc */\n",
       "body .cpf { color: #408080; font-style: italic } /* Comment.PreprocFile */\n",
       "body .c1 { color: #408080; font-style: italic } /* Comment.Single */\n",
       "body .cs { color: #408080; font-style: italic } /* Comment.Special */\n",
       "body .gd { color: #A00000 } /* Generic.Deleted */\n",
       "body .ge { font-style: italic } /* Generic.Emph */\n",
       "body .gr { color: #FF0000 } /* Generic.Error */\n",
       "body .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
       "body .gi { color: #00A000 } /* Generic.Inserted */\n",
       "body .go { color: #888888 } /* Generic.Output */\n",
       "body .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
       "body .gs { font-weight: bold } /* Generic.Strong */\n",
       "body .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
       "body .gt { color: #0044DD } /* Generic.Traceback */\n",
       "body .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
       "body .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
       "body .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
       "body .kp { color: #008000 } /* Keyword.Pseudo */\n",
       "body .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
       "body .kt { color: #B00040 } /* Keyword.Type */\n",
       "body .m { color: #666666 } /* Literal.Number */\n",
       "body .s { color: #BA2121 } /* Literal.String */\n",
       "body .na { color: #7D9029 } /* Name.Attribute */\n",
       "body .nb { color: #008000 } /* Name.Builtin */\n",
       "body .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
       "body .no { color: #880000 } /* Name.Constant */\n",
       "body .nd { color: #AA22FF } /* Name.Decorator */\n",
       "body .ni { color: #999999; font-weight: bold } /* Name.Entity */\n",
       "body .ne { color: #D2413A; font-weight: bold } /* Name.Exception */\n",
       "body .nf { color: #0000FF } /* Name.Function */\n",
       "body .nl { color: #A0A000 } /* Name.Label */\n",
       "body .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
       "body .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
       "body .nv { color: #19177C } /* Name.Variable */\n",
       "body .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
       "body .w { color: #bbbbbb } /* Text.Whitespace */\n",
       "body .mb { color: #666666 } /* Literal.Number.Bin */\n",
       "body .mf { color: #666666 } /* Literal.Number.Float */\n",
       "body .mh { color: #666666 } /* Literal.Number.Hex */\n",
       "body .mi { color: #666666 } /* Literal.Number.Integer */\n",
       "body .mo { color: #666666 } /* Literal.Number.Oct */\n",
       "body .sa { color: #BA2121 } /* Literal.String.Affix */\n",
       "body .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
       "body .sc { color: #BA2121 } /* Literal.String.Char */\n",
       "body .dl { color: #BA2121 } /* Literal.String.Delimiter */\n",
       "body .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
       "body .s2 { color: #BA2121 } /* Literal.String.Double */\n",
       "body .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */\n",
       "body .sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
       "body .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */\n",
       "body .sx { color: #008000 } /* Literal.String.Other */\n",
       "body .sr { color: #BB6688 } /* Literal.String.Regex */\n",
       "body .s1 { color: #BA2121 } /* Literal.String.Single */\n",
       "body .ss { color: #19177C } /* Literal.String.Symbol */\n",
       "body .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
       "body .fm { color: #0000FF } /* Name.Function.Magic */\n",
       "body .vc { color: #19177C } /* Name.Variable.Class */\n",
       "body .vg { color: #19177C } /* Name.Variable.Global */\n",
       "body .vi { color: #19177C } /* Name.Variable.Instance */\n",
       "body .vm { color: #19177C } /* Name.Variable.Magic */\n",
       "body .il { color: #666666 } /* Literal.Number.Integer.Long */\n",
       "\n",
       "  </style>\n",
       "</head>\n",
       "<body>\n",
       "<h2></h2>\n",
       "\n",
       "<div class=\"highlight\"><pre><span></span><span class=\"k\">def</span> <span class=\"nf\">LinearLearner</span><span class=\"p\">(</span><span class=\"n\">dataset</span><span class=\"p\">,</span> <span class=\"n\">learning_rate</span><span class=\"o\">=</span><span class=\"mf\">0.01</span><span class=\"p\">,</span> <span class=\"n\">epochs</span><span class=\"o\">=</span><span class=\"mi\">100</span><span class=\"p\">):</span>\n",
       "    <span class=\"sd\">&quot;&quot;&quot;Define with learner = LinearLearner(data); infer with learner(x).&quot;&quot;&quot;</span>\n",
       "    <span class=\"n\">idx_i</span> <span class=\"o\">=</span> <span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">inputs</span>\n",
       "    <span class=\"n\">idx_t</span> <span class=\"o\">=</span> <span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">target</span>  <span class=\"c1\"># As of now, dataset.target gives only one index.</span>\n",
       "    <span class=\"n\">examples</span> <span class=\"o\">=</span> <span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">examples</span>\n",
       "    <span class=\"n\">num_examples</span> <span class=\"o\">=</span> <span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">examples</span><span class=\"p\">)</span>\n",
       "\n",
       "    <span class=\"c1\"># X transpose</span>\n",
       "    <span class=\"n\">X_col</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">values</span><span class=\"p\">[</span><span class=\"n\">i</span><span class=\"p\">]</span> <span class=\"k\">for</span> <span class=\"n\">i</span> <span class=\"ow\">in</span> <span class=\"n\">idx_i</span><span class=\"p\">]</span>  <span class=\"c1\"># vertical columns of X</span>\n",
       "\n",
       "    <span class=\"c1\"># Add dummy</span>\n",
       "    <span class=\"n\">ones</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"mi\">1</span> <span class=\"k\">for</span> <span class=\"n\">_</span> <span class=\"ow\">in</span> <span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">examples</span><span class=\"p\">))]</span>\n",
       "    <span class=\"n\">X_col</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"n\">ones</span><span class=\"p\">]</span> <span class=\"o\">+</span> <span class=\"n\">X_col</span>\n",
       "\n",
       "    <span class=\"c1\"># Initialize random weigts</span>\n",
       "    <span class=\"n\">num_weights</span> <span class=\"o\">=</span> <span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">idx_i</span><span class=\"p\">)</span> <span class=\"o\">+</span> <span class=\"mi\">1</span>\n",
       "    <span class=\"n\">w</span> <span class=\"o\">=</span> <span class=\"n\">random_weights</span><span class=\"p\">(</span><span class=\"n\">min_value</span><span class=\"o\">=-</span><span class=\"mf\">0.5</span><span class=\"p\">,</span> <span class=\"n\">max_value</span><span class=\"o\">=</span><span class=\"mf\">0.5</span><span class=\"p\">,</span> <span class=\"n\">num_weights</span><span class=\"o\">=</span><span class=\"n\">num_weights</span><span class=\"p\">)</span>\n",
       "\n",
       "    <span class=\"k\">for</span> <span class=\"n\">epoch</span> <span class=\"ow\">in</span> <span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"n\">epochs</span><span class=\"p\">):</span>\n",
       "        <span class=\"n\">err</span> <span class=\"o\">=</span> <span class=\"p\">[]</span>\n",
       "        <span class=\"c1\"># Pass over all examples</span>\n",
       "        <span class=\"k\">for</span> <span class=\"n\">example</span> <span class=\"ow\">in</span> <span class=\"n\">examples</span><span class=\"p\">:</span>\n",
       "            <span class=\"n\">x</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">]</span> <span class=\"o\">+</span> <span class=\"n\">example</span>\n",
       "            <span class=\"n\">y</span> <span class=\"o\">=</span> <span class=\"n\">dotproduct</span><span class=\"p\">(</span><span class=\"n\">w</span><span class=\"p\">,</span> <span class=\"n\">x</span><span class=\"p\">)</span>\n",
       "            <span class=\"n\">t</span> <span class=\"o\">=</span> <span class=\"n\">example</span><span class=\"p\">[</span><span class=\"n\">idx_t</span><span class=\"p\">]</span>\n",
       "            <span class=\"n\">err</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"n\">t</span> <span class=\"o\">-</span> <span class=\"n\">y</span><span class=\"p\">)</span>\n",
       "\n",
       "        <span class=\"c1\"># update weights</span>\n",
       "        <span class=\"k\">for</span> <span class=\"n\">i</span> <span class=\"ow\">in</span> <span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">w</span><span class=\"p\">)):</span>\n",
       "            <span class=\"n\">w</span><span class=\"p\">[</span><span class=\"n\">i</span><span class=\"p\">]</span> <span class=\"o\">=</span> <span class=\"n\">w</span><span class=\"p\">[</span><span class=\"n\">i</span><span class=\"p\">]</span> <span class=\"o\">+</span> <span class=\"n\">learning_rate</span> <span class=\"o\">*</span> <span class=\"p\">(</span><span class=\"n\">dotproduct</span><span class=\"p\">(</span><span class=\"n\">err</span><span class=\"p\">,</span> <span class=\"n\">X_col</span><span class=\"p\">[</span><span class=\"n\">i</span><span class=\"p\">])</span> <span class=\"o\">/</span> <span class=\"n\">num_examples</span><span class=\"p\">)</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">predict</span><span class=\"p\">(</span><span class=\"n\">example</span><span class=\"p\">):</span>\n",
       "        <span class=\"n\">x</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">]</span> <span class=\"o\">+</span> <span class=\"n\">example</span>\n",
       "        <span class=\"k\">return</span> <span class=\"n\">dotproduct</span><span class=\"p\">(</span><span class=\"n\">w</span><span class=\"p\">,</span> <span class=\"n\">x</span><span class=\"p\">)</span>\n",
       "    <span class=\"k\">return</span> <span class=\"n\">predict</span>\n",
       "</pre></div>\n",
       "</body>\n",
       "</html>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "psource(LinearLearner)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This algorithm first assigns some random weights to the input variables and then based on the error calculated updates the weight for each variable. Finally the prediction is made with the updated weights.  \n",
    "\n",
    "### Implementation\n",
    "\n",
    "We will now use the Linear Learner to classify a sample with values: 5.1, 3.0, 1.1, 0.1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.4374841443932076\n"
     ]
    }
   ],
   "source": [
    "iris = DataSet(name=\"iris\")\n",
    "iris.classes_to_numbers()\n",
    "\n",
    "linear_learner = LinearLearner(iris)\n",
    "print(linear_learner([5, 3, 1, 0.1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ENSEMBLE LEARNER\n",
    "\n",
    "### Overview\n",
    "\n",
    "Ensemble Learning improves the performance of our model by combining several learners. It improvise the stability and predictive power of the model. Ensemble methods are meta-algorithms that combine several machine learning techniques into one predictive model in order to decrease variance, bias, or improve predictions.  \n",
    "\n",
    "\n",
    "\n",
    "![ensemble_learner.jpg](images/ensemble_learner.jpg)\n",
    "\n",
    "\n",
    "Some commonly used Ensemble Learning techniques are : \n",
    "\n",
    "1. Bagging : Bagging tries to implement similar learners on small sample populations and then takes a mean of all the predictions. It helps us to reduce variance error.\n",
    "\n",
    "2. Boosting : Boosting is an iterative technique which adjust the weight of an observation based on the last classification. If an observation was classified incorrectly, it tries to increase the weight of this observation and vice versa. It helps us to reduce bias error.\n",
    "\n",
    "3.  Stacking : This is a very interesting way of combining models. Here we use a learner to combine output from different learners. It can either decrease bias or variance error depending on the learners we use.\n",
    "\n",
    "### Implementation\n",
    "\n",
    "Below mentioned is the implementation of Ensemble Learner."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "psource(EnsembleLearner)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This algorithm takes input as a list of learning algorithms, have them vote and then finally returns the predicted result."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LEARNER EVALUATION\n",
    "\n",
    "In this section we will evaluate and compare algorithm performance. The dataset we will use will again be the iris one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "iris = DataSet(name=\"iris\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Naive Bayes\n",
    "\n",
    "First up we have the Naive Bayes algorithm. First we will test how well the Discrete Naive Bayes works, and then how the Continuous fares."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error ratio for Discrete: 0.040000000000000036\n",
      "Error ratio for Continuous: 0.040000000000000036\n"
     ]
    }
   ],
   "source": [
    "nBD = NaiveBayesLearner(iris, continuous=False)\n",
    "print(\"Error ratio for Discrete:\", err_ratio(nBD, iris))\n",
    "\n",
    "nBC = NaiveBayesLearner(iris, continuous=True)\n",
    "print(\"Error ratio for Continuous:\", err_ratio(nBC, iris))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The error for the Naive Bayes algorithm is very, very low; close to 0. There is also very little difference between the discrete and continuous version of the algorithm."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## k-Nearest Neighbors\n",
    "\n",
    "Now we will take a look at kNN, for different values of *k*. Note that *k* should have odd values, to break any ties between two classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error ratio for k=1: 0.0\n",
      "Error ratio for k=3: 0.06000000000000005\n",
      "Error ratio for k=5: 0.1266666666666667\n",
      "Error ratio for k=7: 0.19999999999999996\n"
     ]
    }
   ],
   "source": [
    "kNN_1 = NearestNeighborLearner(iris, k=1)\n",
    "kNN_3 = NearestNeighborLearner(iris, k=3)\n",
    "kNN_5 = NearestNeighborLearner(iris, k=5)\n",
    "kNN_7 = NearestNeighborLearner(iris, k=7)\n",
    "\n",
    "print(\"Error ratio for k=1:\", err_ratio(kNN_1, iris))\n",
    "print(\"Error ratio for k=3:\", err_ratio(kNN_3, iris))\n",
    "print(\"Error ratio for k=5:\", err_ratio(kNN_5, iris))\n",
    "print(\"Error ratio for k=7:\", err_ratio(kNN_7, iris))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how the error became larger and larger as *k* increased. This is generally the case with datasets where classes are spaced out, as is the case with the iris dataset. If items from different classes were closer together, classification would be more difficult. Usually a value of 1, 3 or 5 for *k* suffices.\n",
    "\n",
    "Also note that since the training set is also the testing set, for *k* equal to 1 we get a perfect score, since the item we want to classify each time is already in the dataset and its closest neighbor is itself."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Perceptron\n",
    "\n",
    "For the Perceptron, we first need to convert class names to integers. Let's see how it performs in the dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error ratio for Perceptron: 0.31333333333333335\n"
     ]
    }
   ],
   "source": [
    "iris2 = DataSet(name=\"iris\")\n",
    "iris2.classes_to_numbers()\n",
    "\n",
    "perceptron = PerceptronLearner(iris2)\n",
    "print(\"Error ratio for Perceptron:\", err_ratio(perceptron, iris2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Perceptron didn't fare very well mainly because the dataset is not linearly separated. On simpler datasets the algorithm performs much better, but unfortunately such datasets are rare in real life scenarios."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## AdaBoost\n",
    "\n",
    "### Overview\n",
    "\n",
    "**AdaBoost** is an algorithm which uses **ensemble learning**. In ensemble learning the hypotheses in the collection, or ensemble, vote for what the output should be and the output with the majority votes is selected as the final answer.\n",
    "\n",
    "AdaBoost algorithm, as mentioned in the book, works with a **weighted training set** and **weak learners** (classifiers that have about 50%+epsilon accuracy i.e slightly better than random guessing). It manipulates the weights attached to the the examples that are showed to it. Importance is given to the examples with higher weights.\n",
    "\n",
    "All the examples start with equal weights and a hypothesis is generated using these examples. Examples which are incorrectly classified, their weights are increased so that they can be classified correctly by the next hypothesis. The examples that are correctly classified, their weights are reduced. This process is repeated *K* times (here *K* is an input to the algorithm) and hence, *K* hypotheses are generated.\n",
    "\n",
    "These *K* hypotheses are also assigned weights according to their performance on the weighted training set. The final ensemble hypothesis is the weighted-majority combination of these *K* hypotheses.\n",
    "\n",
    "The speciality of AdaBoost is that by using weak learners and a sufficiently large *K*, a highly accurate classifier can be learned irrespective of the complexity of the function being learned or the dullness of the hypothesis space."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementation\n",
    "\n",
    "As seen in the previous section, the `PerceptronLearner` does not perform that well on the iris dataset. We'll use perceptron as the learner for the AdaBoost algorithm and try to increase the accuracy. \n",
    "\n",
    "Let's first see what AdaBoost is exactly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01//EN\"\n",
       "   \"http://www.w3.org/TR/html4/strict.dtd\">\n",
       "\n",
       "<html>\n",
       "<head>\n",
       "  <title></title>\n",
       "  <meta http-equiv=\"content-type\" content=\"text/html; charset=None\">\n",
       "  <style type=\"text/css\">\n",
       "td.linenos { background-color: #f0f0f0; padding-right: 10px; }\n",
       "span.lineno { background-color: #f0f0f0; padding: 0 5px 0 5px; }\n",
       "pre { line-height: 125%; }\n",
       "body .hll { background-color: #ffffcc }\n",
       "body  { background: #f8f8f8; }\n",
       "body .c { color: #408080; font-style: italic } /* Comment */\n",
       "body .err { border: 1px solid #FF0000 } /* Error */\n",
       "body .k { color: #008000; font-weight: bold } /* Keyword */\n",
       "body .o { color: #666666 } /* Operator */\n",
       "body .ch { color: #408080; font-style: italic } /* Comment.Hashbang */\n",
       "body .cm { color: #408080; font-style: italic } /* Comment.Multiline */\n",
       "body .cp { color: #BC7A00 } /* Comment.Preproc */\n",
       "body .cpf { color: #408080; font-style: italic } /* Comment.PreprocFile */\n",
       "body .c1 { color: #408080; font-style: italic } /* Comment.Single */\n",
       "body .cs { color: #408080; font-style: italic } /* Comment.Special */\n",
       "body .gd { color: #A00000 } /* Generic.Deleted */\n",
       "body .ge { font-style: italic } /* Generic.Emph */\n",
       "body .gr { color: #FF0000 } /* Generic.Error */\n",
       "body .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
       "body .gi { color: #00A000 } /* Generic.Inserted */\n",
       "body .go { color: #888888 } /* Generic.Output */\n",
       "body .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
       "body .gs { font-weight: bold } /* Generic.Strong */\n",
       "body .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
       "body .gt { color: #0044DD } /* Generic.Traceback */\n",
       "body .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
       "body .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
       "body .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
       "body .kp { color: #008000 } /* Keyword.Pseudo */\n",
       "body .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
       "body .kt { color: #B00040 } /* Keyword.Type */\n",
       "body .m { color: #666666 } /* Literal.Number */\n",
       "body .s { color: #BA2121 } /* Literal.String */\n",
       "body .na { color: #7D9029 } /* Name.Attribute */\n",
       "body .nb { color: #008000 } /* Name.Builtin */\n",
       "body .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
       "body .no { color: #880000 } /* Name.Constant */\n",
       "body .nd { color: #AA22FF } /* Name.Decorator */\n",
       "body .ni { color: #999999; font-weight: bold } /* Name.Entity */\n",
       "body .ne { color: #D2413A; font-weight: bold } /* Name.Exception */\n",
       "body .nf { color: #0000FF } /* Name.Function */\n",
       "body .nl { color: #A0A000 } /* Name.Label */\n",
       "body .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
       "body .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
       "body .nv { color: #19177C } /* Name.Variable */\n",
       "body .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
       "body .w { color: #bbbbbb } /* Text.Whitespace */\n",
       "body .mb { color: #666666 } /* Literal.Number.Bin */\n",
       "body .mf { color: #666666 } /* Literal.Number.Float */\n",
       "body .mh { color: #666666 } /* Literal.Number.Hex */\n",
       "body .mi { color: #666666 } /* Literal.Number.Integer */\n",
       "body .mo { color: #666666 } /* Literal.Number.Oct */\n",
       "body .sa { color: #BA2121 } /* Literal.String.Affix */\n",
       "body .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
       "body .sc { color: #BA2121 } /* Literal.String.Char */\n",
       "body .dl { color: #BA2121 } /* Literal.String.Delimiter */\n",
       "body .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
       "body .s2 { color: #BA2121 } /* Literal.String.Double */\n",
       "body .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */\n",
       "body .sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
       "body .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */\n",
       "body .sx { color: #008000 } /* Literal.String.Other */\n",
       "body .sr { color: #BB6688 } /* Literal.String.Regex */\n",
       "body .s1 { color: #BA2121 } /* Literal.String.Single */\n",
       "body .ss { color: #19177C } /* Literal.String.Symbol */\n",
       "body .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
       "body .fm { color: #0000FF } /* Name.Function.Magic */\n",
       "body .vc { color: #19177C } /* Name.Variable.Class */\n",
       "body .vg { color: #19177C } /* Name.Variable.Global */\n",
       "body .vi { color: #19177C } /* Name.Variable.Instance */\n",
       "body .vm { color: #19177C } /* Name.Variable.Magic */\n",
       "body .il { color: #666666 } /* Literal.Number.Integer.Long */\n",
       "\n",
       "  </style>\n",
       "</head>\n",
       "<body>\n",
       "<h2></h2>\n",
       "\n",
       "<div class=\"highlight\"><pre><span></span><span class=\"k\">def</span> <span class=\"nf\">AdaBoost</span><span class=\"p\">(</span><span class=\"n\">L</span><span class=\"p\">,</span> <span class=\"n\">K</span><span class=\"p\">):</span>\n",
       "    <span class=\"sd\">&quot;&quot;&quot;[Figure 18.34]&quot;&quot;&quot;</span>\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">train</span><span class=\"p\">(</span><span class=\"n\">dataset</span><span class=\"p\">):</span>\n",
       "        <span class=\"n\">examples</span><span class=\"p\">,</span> <span class=\"n\">target</span> <span class=\"o\">=</span> <span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">examples</span><span class=\"p\">,</span> <span class=\"n\">dataset</span><span class=\"o\">.</span><span class=\"n\">target</span>\n",
       "        <span class=\"n\">N</span> <span class=\"o\">=</span> <span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">examples</span><span class=\"p\">)</span>\n",
       "        <span class=\"n\">epsilon</span> <span class=\"o\">=</span> <span class=\"mf\">1.</span> <span class=\"o\">/</span> <span class=\"p\">(</span><span class=\"mi\">2</span> <span class=\"o\">*</span> <span class=\"n\">N</span><span class=\"p\">)</span>\n",
       "        <span class=\"n\">w</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"mf\">1.</span> <span class=\"o\">/</span> <span class=\"n\">N</span><span class=\"p\">]</span> <span class=\"o\">*</span> <span class=\"n\">N</span>\n",
       "        <span class=\"n\">h</span><span class=\"p\">,</span> <span class=\"n\">z</span> <span class=\"o\">=</span> <span class=\"p\">[],</span> <span class=\"p\">[]</span>\n",
       "        <span class=\"k\">for</span> <span class=\"n\">k</span> <span class=\"ow\">in</span> <span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"n\">K</span><span class=\"p\">):</span>\n",
       "            <span class=\"n\">h_k</span> <span class=\"o\">=</span> <span class=\"n\">L</span><span class=\"p\">(</span><span class=\"n\">dataset</span><span class=\"p\">,</span> <span class=\"n\">w</span><span class=\"p\">)</span>\n",
       "            <span class=\"n\">h</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"n\">h_k</span><span class=\"p\">)</span>\n",
       "            <span class=\"n\">error</span> <span class=\"o\">=</span> <span class=\"nb\">sum</span><span class=\"p\">(</span><span class=\"n\">weight</span> <span class=\"k\">for</span> <span class=\"n\">example</span><span class=\"p\">,</span> <span class=\"n\">weight</span> <span class=\"ow\">in</span> <span class=\"nb\">zip</span><span class=\"p\">(</span><span class=\"n\">examples</span><span class=\"p\">,</span> <span class=\"n\">w</span><span class=\"p\">)</span>\n",
       "                        <span class=\"k\">if</span> <span class=\"n\">example</span><span class=\"p\">[</span><span class=\"n\">target</span><span class=\"p\">]</span> <span class=\"o\">!=</span> <span class=\"n\">h_k</span><span class=\"p\">(</span><span class=\"n\">example</span><span class=\"p\">))</span>\n",
       "            <span class=\"c1\"># Avoid divide-by-0 from either 0% or 100% error rates:</span>\n",
       "            <span class=\"n\">error</span> <span class=\"o\">=</span> <span class=\"n\">clip</span><span class=\"p\">(</span><span class=\"n\">error</span><span class=\"p\">,</span> <span class=\"n\">epsilon</span><span class=\"p\">,</span> <span class=\"mi\">1</span> <span class=\"o\">-</span> <span class=\"n\">epsilon</span><span class=\"p\">)</span>\n",
       "            <span class=\"k\">for</span> <span class=\"n\">j</span><span class=\"p\">,</span> <span class=\"n\">example</span> <span class=\"ow\">in</span> <span class=\"nb\">enumerate</span><span class=\"p\">(</span><span class=\"n\">examples</span><span class=\"p\">):</span>\n",
       "                <span class=\"k\">if</span> <span class=\"n\">example</span><span class=\"p\">[</span><span class=\"n\">target</span><span class=\"p\">]</span> <span class=\"o\">==</span> <span class=\"n\">h_k</span><span class=\"p\">(</span><span class=\"n\">example</span><span class=\"p\">):</span>\n",
       "                    <span class=\"n\">w</span><span class=\"p\">[</span><span class=\"n\">j</span><span class=\"p\">]</span> <span class=\"o\">*=</span> <span class=\"n\">error</span> <span class=\"o\">/</span> <span class=\"p\">(</span><span class=\"mf\">1.</span> <span class=\"o\">-</span> <span class=\"n\">error</span><span class=\"p\">)</span>\n",
       "            <span class=\"n\">w</span> <span class=\"o\">=</span> <span class=\"n\">normalize</span><span class=\"p\">(</span><span class=\"n\">w</span><span class=\"p\">)</span>\n",
       "            <span class=\"n\">z</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"n\">math</span><span class=\"o\">.</span><span class=\"n\">log</span><span class=\"p\">((</span><span class=\"mf\">1.</span> <span class=\"o\">-</span> <span class=\"n\">error</span><span class=\"p\">)</span> <span class=\"o\">/</span> <span class=\"n\">error</span><span class=\"p\">))</span>\n",
       "        <span class=\"k\">return</span> <span class=\"n\">WeightedMajority</span><span class=\"p\">(</span><span class=\"n\">h</span><span class=\"p\">,</span> <span class=\"n\">z</span><span class=\"p\">)</span>\n",
       "    <span class=\"k\">return</span> <span class=\"n\">train</span>\n",
       "</pre></div>\n",
       "</body>\n",
       "</html>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "psource(AdaBoost)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "AdaBoost takes as inputs: **L** and *K* where **L** is the learner and *K* is the number of hypotheses to be generated. The learner **L** takes in as inputs: a dataset and the weights associated with the examples in the dataset. But the `PerceptronLearner` doesnot handle weights and only takes a dataset as its input.  \n",
    "To remedy that we will give as input to the PerceptronLearner a modified dataset in which the examples will be repeated according to the weights associated to them. Intuitively, what this will do is force the learner to repeatedly learn the same example again and again until it can classify it correctly.   \n",
    "\n",
    "To convert `PerceptronLearner` so that it can take weights as input too, we will have to pass it through the **`WeightedLearner`** function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "psource(WeightedLearner)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `WeightedLearner` function will then call the `PerceptronLearner`, during each iteration, with the modified dataset which contains the examples according to the weights associated with them."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Example\n",
    "\n",
    "We will pass the `PerceptronLearner` through `WeightedLearner` function. Then we will create an `AdaboostLearner` classifier with number of hypotheses or *K* equal to 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "WeightedPerceptron = WeightedLearner(PerceptronLearner)\n",
    "AdaboostLearner = AdaBoost(WeightedPerceptron, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "iris2 = DataSet(name=\"iris\")\n",
    "iris2.classes_to_numbers()\n",
    "\n",
    "adaboost = AdaboostLearner(iris2)\n",
    "\n",
    "adaboost([5, 3, 1, 0.1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That is the correct answer. Let's check the error rate of adaboost with perceptron."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error ratio for adaboost:  0.046666666666666634\n"
     ]
    }
   ],
   "source": [
    "print(\"Error ratio for adaboost: \", err_ratio(adaboost, iris2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "It reduced the error rate considerably. Unlike the `PerceptronLearner`, `AdaBoost` was able to learn the complexity in the iris dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}