lesson3_naivebayes_exercises.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Run this every time you open the spreadsheet\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "from collections import Counter\n",
    "import lib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load the content of the boxes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Load the data.\n",
    "# This function returns box_a and box_b, both lists of colors of the balls in each box\n",
    "box_a, box_b = lib.get_box_contents()\n",
    "\n",
    "print \"Number of balls in box A: %d\" % len(box_a)\n",
    "print \"Number of balls in box B: %d\" % len(box_b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python concepts\n",
    "\n",
    "Let's review and look at some new Python concepts before we implement the box and ball examples.\n",
    "\n",
    "### Dictionaries\n",
    "In Python, a _dict_ is a collection of items in which each element can be accessed by a _key_. The _key_ is typically a string and the items can be of any data type, e.g., booleans, integers, strings. Each key can be used for only one item.\n",
    "\n",
    "You can create dictionaries like this:\n",
    "```\n",
    "west_coast_state_capitals = {\"California\": \"Sacramento\", \"Oregon\": \"Salem\", \"Washington\": \"Olympia\"}\n",
    "prices = {\"spaghetti\": 2.50, \"milk\": 2.00, \"peanut butter\": 2.75, \"avocado\": 0.85, \"bread\": 3.25}\n",
    "```\n",
    "\n",
    "To access a value in a dictionary, use the name of the dictionary and put they _key_ in squared brackets:\n",
    "\n",
    "```\n",
    "west_coast_state_capitals[\"California\"] # returns \"Sacramento\"\n",
    "prices[\"milk\"] # returns 2.00\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Exercise 1.\n",
    "# Create a dictionary called \"authors\" that maps the following book titles to their authors.\n",
    "#\n",
    "# Harry Potter - J.K. Rowling\n",
    "# The Casual Vacancy - J.K. Rowling\n",
    "# The Hunger Games - Suzanne Collins\n",
    "# Never Let Me Go - Kazuo Ishiguro\n",
    "# The Catcher in the Rye - J.D. Salinger\n",
    "#\n",
    "# Then print the author of \"The Catcher in the Rye\" and \"Harry Potter\" using your dictionary.\n",
    "\n",
    "#### YOUR CODE STARTS HERE ####\n",
    "\n",
    "\n",
    "\n",
    "#### YOUR CODE ENDS HERE ####\n",
    "\n",
    "print \"CORRECT\" if authors[\"Harry Potter\"] == \"J.K. Rowling\" else \"INCORRECT\"\n",
    "print \"CORRECT\" if authors[\"The Casual Vacancy\"] == \"J.K. Rowling\" else \"INCORRECT\"\n",
    "print \"CORRECT\" if authors[\"Never Let Me Go\"] == \"Kazuo Ishiguro\" else \"INCORRECT\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Adding, updating, and deleting items from dictionaries\n",
    "\n",
    "You can also add, change and delete items after you created an dictionary. \n",
    "\n",
    "For example, the following code creates an empty dictionary _prices_ and then adds two items to it.\n",
    "\n",
    "```\n",
    "prices = {}\n",
    "prices[\"milk\"] = 2.00\n",
    "prices[\"avocado\"] = 0.85\n",
    "\n",
    "print prices # outputs {'avocado': 0.85, 'milk': 2.0}\n",
    "```\n",
    "\n",
    "To update an item in a dictionary, simply assign a new value to it:\n",
    "\n",
    "```\n",
    "prices = {}\n",
    "prices[\"milk\"] = 2.00\n",
    "prices[\"avocado\"] = 0.85\n",
    "print prices # outputs {'avocado': 0.85, 'milk': 2.0}\n",
    "\n",
    "\n",
    "prices[\"milk\"] = 2.25\n",
    "print prices # outputs {'avocado': 0.85, 'milk': 2.25}\n",
    "```\n",
    "\n",
    "Tto delete an item from a dictionary, use the _del_ keyword as in the following snippet:\n",
    "\n",
    "```\n",
    "prices = {}\n",
    "prices[\"milk\"] = 2.00\n",
    "prices[\"avocado\"] = 0.85\n",
    "print prices # outputs {'avocado': 0.85, 'milk': 2.0}\n",
    "\n",
    "del prices[\"milk\"]\n",
    "print prices # outputs {'avocado': 0.85}\n",
    "```\n",
    "\n",
    "\n",
    "#### Iterating through dictionaries\n",
    "\n",
    "You can also iterate through all items in a dictionary with a for-loop.\n",
    "When you loop through a dictionary, the key is assigned to the loop variable\n",
    "during each iteration.\n",
    "\n",
    "```\n",
    "prices = {\"spaghetti\": 2.50, \"milk\": 2.00, \"peanut butter\": 2.75}\n",
    "\n",
    "for product in prices:\n",
    "   print product, prices[product]\n",
    "   # Sidenote: You can print multiple variables in the same line\n",
    "   # by separating them with a comma.\n",
    "\n",
    "   \n",
    "```\n",
    "\n",
    "This program outputs something like: (order may vary)\n",
    "\n",
    "```\n",
    "spaghetti 2.5\n",
    "milk 2.0\n",
    "peanut butter 2.75\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Imagine you are running a store that sells spaghetti, milk, peanut butter, avocados, and bread, and you\n",
    "# store the prices for these products in the following dictionary.\n",
    "\n",
    "prices = {\"spaghetti\": 2.50, \"milk\": 2.00, \"peanut butter\": 2.75, \"avocado\": 0.85, \"bread\": 3.25}\n",
    "\n",
    "# Exercise 2(a).\n",
    "\n",
    "# Your distributor increased prices on all products by 25 cents, so you'll have to increase your prices \n",
    "# by 25 cents as well. Increase every value in the prices dictionary by 25 cents.\n",
    "\n",
    "#### YOUR CODE STARTS HERE ####\n",
    "\n",
    "for product in prices:\n",
    "    ......\n",
    "    \n",
    "\n",
    "\n",
    "#### YOUR CODE ENDS HERE ####\n",
    "\n",
    "print prices\n",
    "\n",
    "print \"CORRECT\" if prices[\"spaghetti\"] == 2.75 else \"INCORRECT\"\n",
    "print \"CORRECT\" if prices[\"milk\"] == 2.25 else \"INCORRECT\"\n",
    "print \"CORRECT\" if prices[\"bread\"] == 3.50 else \"INCORRECT\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Exercise 2(b).\n",
    "\n",
    "# You added bananas to your inventory and you sell them for 95 cents. Add a new entry \n",
    "# for bananas to the prices dictionary.\n",
    "\n",
    "#### YOUR CODE STARTS HERE ####\n",
    "\n",
    "    \n",
    "#### YOUR CODE ENDS HERE ####\n",
    "\n",
    "print prices\n",
    "print \"CORRECT\" if prices[\"bananas\"] == 0.95 else \"INCORRECT\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Exercise 2(c).\n",
    "\n",
    "# You are no longer selling peanut butter. Remove the entry for peanut butter from prices.\n",
    "\n",
    "#### YOUR CODE STARTS HERE ####\n",
    "\n",
    "    \n",
    "#### YOUR CODE ENDS HERE ####\n",
    "\n",
    "print prices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Counter\n",
    "\n",
    "Python comes with a special dictionary type, the `Counter` type, which makes it easier to work with counts.\n",
    "\n",
    "A Counter works just like a dictionary but instead of giving an error when you use a key for which no entry exists, it will return 0.\n",
    "\n",
    "To use Counters, you first have to run the following import statement.\n",
    "\n",
    "```\n",
    "from collections import Counter\n",
    "```\n",
    "\n",
    "Let's create a Counter to keep track of how many birds I've seen. Below, I create a new empty Counter called `bird_counter`. Note that if I ask the counter how many sparrows I've seen, it returns 0 even though `\"sparrow\"` is not in the keys.\n",
    "\n",
    "```\n",
    "bird_counter = Counter()\n",
    "print bird_counter[\"sparrow\"] # outputs 0 \n",
    "```\n",
    "\n",
    "I just spotted a finch! Let's increment the counter.\n",
    "\n",
    "```\n",
    "bird_counter[\"finch\"] += 1\n",
    "print bird_counter[\"finch\"] # outputs 1\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Exercise 3.\n",
    "# Write code that counts how many of each type of fruit there are in the fruit basket. \n",
    "# Use a Counter to store the counts and print the final Counter object.\n",
    "\n",
    "# Hint: Use a for-loop to iterate through all the items in fruit_basket.\n",
    "\n",
    "from collections import Counter\n",
    "fruit_basket = [\"apple\", \"banana\", \"plum\", \"apple\", \"apricot\", \"plum\", \"apple\", \"apple\", \"apricot\", \"apricot\"]\n",
    "\n",
    "#### YOUR CODE STARTS HERE ####\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "#### YOUR CODE ENDS HERE ####"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Turning lists into Counters\n",
    "\n",
    "Counters come with several other useful features. One of them is that you can automatically turn a list into a counter. For example, the following snippet counts how many of each letter there are in the list my_letters.\n",
    "\n",
    "```\n",
    "my_letters = [\"a\", \"b\", \"b\", \"c\", \"c\", \"c\", \"d\", \"d\", \"d\", \"d\"]\n",
    "letter_counter = Counter(my_letters)\n",
    "\n",
    "print letter_counter # outputs Counter({'d': 4, 'c': 3, 'b': 2, 'a': 1})\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Exercise 4.\n",
    "# Re-implement the program from Exercise 3 without using a for-loop.\n",
    "\n",
    "from collections import Counter\n",
    "fruit_basket = [\"apple\", \"banana\", \"plum\", \"apple\", \"apricot\", \"plum\", \"apple\", \"apple\", \"apricot\", \"apricot\"]\n",
    "\n",
    "#### YOUR CODE STARTS HERE ####\n",
    "\n",
    "\n",
    "\n",
    "#### YOUR CODE ENDS HERE ####"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iterating through counters\n",
    "\n",
    "You can iterate through a Counter just like a dictionary. If you use a for-loop with a Counter, it will loop through all keys.\n",
    "\n",
    "\n",
    "```\n",
    "prices = Counter({\"spaghetti\": 2.50, \"milk\": 2.00, \"peanut butter\": 2.75})\n",
    "\n",
    "for product in prices:\n",
    "  print product\n",
    "\n",
    "```\n",
    "\n",
    "This program will print something like: (the order may vary)\n",
    "\n",
    "```\n",
    "spaghetti\n",
    "milk\n",
    "peanut butter\n",
    "```\n",
    "\n",
    "You can also get a list of all values stored in a Counter using the _.values()_ method. \n",
    "\n",
    "```\n",
    "prices = Counter({\"spaghetti\": 2.50, \"milk\": 2.00, \"peanut butter\": 2.75})\n",
    "\n",
    "vals = prices.values()\n",
    "\n",
    "print vals # outputs [2.5, 2.0, 2.75] (the order may vary)\n",
    "\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Exercise 6.\n",
    "\n",
    "# The following counter stores how many rooms of each type a hotel has.\n",
    "\n",
    "hotel_rooms = Counter({\"1 queen-sized bed\": 25, \"1 king-sized bed\": 14, \n",
    "                       \"2 queen-sized beds\": 12, \"Honeymoon suite\": 1, \n",
    "                       \"Presidential suite\": 1})\n",
    "\n",
    "# Write some code that prints each room type and how many rooms of each type there are. e.g., \"Presidential suite 1\"\n",
    "\n",
    "\n",
    "#### YOUR CODE STARTS HERE ####\n",
    "\n",
    "\n",
    "#### YOUR CODE ENDS HERE ####\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Computing the sum of a list of numbers\n",
    "\n",
    "Sometimes it can also be really useful to compute the sum of a list of numbers. For example, assume that the following list stores the weights of products in a package and you want to compute the total weight of the package.\n",
    "\n",
    "```\n",
    "weights = [3, 4, 5, 1, 2, 9, 12, 11]\n",
    "```\n",
    "\n",
    "Python comes with a function `sum` that allows you to quickly sum over a list of numbers.\n",
    "\n",
    "```\n",
    "total_weight = sum(weights)\n",
    "print total_weight # outputs 47\n",
    "\n",
    "```\n",
    "\n",
    "\n",
    "You can also use this function together with the values of a Counter. For example, the following code computes how much it would cost if one bought every item in the prices Counter.\n",
    "\n",
    "```\n",
    "prices = Counter({\"spaghetti\": 2.50, \"milk\": 2.00, \"peanut butter\": 2.75})\n",
    "\n",
    "vals = prices.values()\n",
    "\n",
    "total = sum(vals)\n",
    "\n",
    "print total # outputs 7.25\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Exercise 6(a).\n",
    "# Compute the sum of all numbers from 1 to 10 and assign to the variable \"total\"\n",
    "\n",
    "#### YOUR CODE STARTS HERE ####\n",
    "\n",
    "numbers = range(1,11)\n",
    "total = ...\n",
    "\n",
    "#### YOUR CODE ENDS HERE ####\n",
    "\n",
    "print total \n",
    "print \"CORRECT\" if total == 55 else \"INCORRECT\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Exercise 6(b).\n",
    "# Store the counts of each type of pet in a Counter and use that counter to compute the total number of pets.\n",
    "# Save the result in the variable \"total\"\n",
    "\n",
    "my_pets = ['cat', 'lizard', 'cat', 'dog', 'cat', 'snake', 'dog', 'cat', 'dog', 'parrot']\n",
    "\n",
    "#### YOUR CODE STARTS HERE ####\n",
    "\n",
    "pet_counter = ...\n",
    "\n",
    "total = ...\n",
    "\n",
    "\n",
    "#### YOUR CODE ENDS HERE ####\n",
    "\n",
    "print total \n",
    "print \"CORRECT\" if total == 10 else \"INCORRECT\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dividing integers in Python\n",
    "\n",
    "One of the pecularities of Python (and some other programming languages) is that if you divide two integers, it will always return the results rounded down to the next integer and never a decimal number.\n",
    "\n",
    "For example, if you compute 1/2, it will return 0.\n",
    "\n",
    "This can be particularly problematic when we are dealing with fractions or percentatages, as we often do when we compute probabilities. The easiest way to get around this is by turning one of the two numbers into a decimal number with the function _float_. This will change the representation of the number from an integer to a decimal number and when you then run the division, it will return a decimal. For example, consider the following two divisions:\n",
    "\n",
    "\n",
    "```\n",
    "res1 = 1/10\n",
    "\n",
    "res2 = float(1)/10\n",
    "\n",
    "print res1\n",
    "print res2\n",
    "\n",
    "```\n",
    "\n",
    "This program will produce the following output:\n",
    "\n",
    "```\n",
    "0\n",
    "0.1\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Exercise 7.\n",
    "# Divide each number in the following list by 2 and print it.\n",
    "\n",
    "numbers = [3,5,6,7,9]\n",
    "\n",
    "#### YOUR CODE STARTS HERE ####\n",
    "\n",
    "for number in numbers:\n",
    "    ......\n",
    "    \n",
    "#### YOUR CODE ENDS HERE ####\n",
    "\n",
    "# The output should be 1.5, 2.5, 3.0, 3.5, 4.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Exercise 8.\n",
    "# Compute the fraction of each type of animal (e.g., the fraction of lizards = 1/10 = 0.1) \n",
    "# and store them in the counter \"fractions\".\n",
    "\n",
    "my_pets = ['cat', 'lizard', 'cat', 'dog', 'cat', 'snake', 'dog', 'cat', 'dog', 'parrot']\n",
    "\n",
    "#### YOUR CODE STARTS HERE ####\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "#### YOUR CODE ENDS HERE ####\n",
    "\n",
    "print \"Testing: fraction of cats = %.1f\" % fractions[\"cat\"]\n",
    "print \"CORRECT\" if fractions[\"cat\"] ==.4 else \"INCORRECT\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Applying Bayes rule: Which box did a ball come from?\n",
    "\n",
    "In this exercise, we are interested in figuring out from which of the two boxes a ball of a certain color most likely came from. We are using Bayes rule to compute the probbaility of box A and box B given a ball of certain color and then we compare which one of these two probabilities is bigger.\n",
    "\n",
    "\n",
    "**Step 1**: Inspect the data. How many different colors are there? How many balls of each color are in box A and in box B?\n",
    "\n",
    "Hint: Turn the two lists `box_a` and `box_b` into Counters and print them.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#### YOUR CODE STARTS HERE ####\n",
    "\n",
    "\n",
    "\n",
    "#### YOUR CODE ENDS HERE ####"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Step 2**: Compute the probability of each color in box A and each color in box B, i.e., compute $P(color\\mid \\mbox{box A})$ and $P(color \\mid \\mbox{box B})$ for each of the five colors. Store them in the counters `p_box_a` and `p_box_b`.\n",
    "\n",
    "For example, you can compute the probability of picking a red ball from box 1 as:\n",
    "\n",
    "$$P(red\\mid \\mbox{box A}) = \\frac{\\mbox{number of red balls in box A}}{\\mbox{total number of balls in box A}}$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#### YOUR CODE STARTS HERE ####\n",
    "\n",
    "# Hint: This is very similar to Exercise 8.\n",
    "\n",
    "p_box_a = ...\n",
    "p_box_b = ...\n",
    "\n",
    "\n",
    "...\n",
    "...\n",
    "...\n",
    "\n",
    "    \n",
    "#### YOUR CODE ENDS HERE ####\n",
    "\n",
    "print p_box_a\n",
    "print p_box_b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Step 3**: Now that we have the conditional probabilities for each color, we can apply Bayes rule to compute which box a ball of a certain color most likely came from. Fill in the blanks in this function.\n",
    "\n",
    "As a reminder, the probability $P(box\\mid color)$ is proportional to\n",
    "\n",
    "$$P(box \\mid color) \\propto P(box) \\times P(color\\mid box)$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#### YOUR CODE STARTS HERE ####\n",
    "\n",
    "def likeliest_box(color):\n",
    "    \n",
    "    \n",
    "    # The probability that someone picked a ball from box A or from box B\n",
    "    # If we set both of these to 0.5, then this means that a box was chosen completely at random\n",
    "    # Modify these values to see how the likelihood of the two boxes changes.\n",
    "    prior_box_a = 0.5\n",
    "    prior_box_b = 0.5\n",
    "    \n",
    "\n",
    "    # P(box A | color) is proportional to P(color | box A) * P(box A)\n",
    "    # Hint use the prior_box_a variable and the p_box_a counter from the cell above.\n",
    "    p_box_a_color = ...\n",
    "    p_box_b_color = ...\n",
    "    \n",
    "    \n",
    "    # Which of the two boxes is likelier? Complete the following if statement\n",
    "    # such that likely_box is assigned Box A if the ball came most likely from Box A\n",
    "    # and Box B if it most likely came from the other box.\n",
    "    if __________________:\n",
    "        likely_box = \"Box A\"\n",
    "    else:\n",
    "        likely_box = \"Box B\"\n",
    "        \n",
    "    return likely_box\n",
    "\n",
    "#### YOUR CODE ENDS HERE ####\n",
    "\n",
    "\n",
    "\n",
    "print \"Balls in Box A:\"\n",
    "print Counter(box_a)\n",
    "print \"Balls in Box B:\"\n",
    "print Counter(box_b)\n",
    "\n",
    "print \"\"\n",
    "\n",
    "colors = [\"red\", \"green\", \"blue\", \"yellow\", \"orange\"]\n",
    "\n",
    "for color in colors:\n",
    "    print \"A %s ball most likely came from %s\" % (color, likeliest_box(color))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Which box did a sequence of balls most likely come from?\n",
    "\n",
    "Now we are interested in a different question. We know that someone drew several balls from a single box, but we don't know from which one of the two. In other words, given a **list** of balls, we want to determine their likeliest origin.\n",
    "\n",
    "The conditional probabilities remain the same, so all you have to do for this exercise is rewrite the *likeliest_box* function below.\n",
    "\n",
    "As a reminder, $P(box \\mid color_1, color_2, color_3, ...)$ is proportional to\n",
    "\n",
    "$$P(box \\mid color_1, color_2, color_3, ...) \\propto P(box) \\times P(box \\mid color_1) \\times P(box \\mid color_2) \\times P(box \\mid color_3) \\times ...$$\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#### YOUR CODE STARTS HERE ####\n",
    "\n",
    "\n",
    "def likeliest_box(colors):\n",
    "    \n",
    "    \n",
    "    # The probability that someone picked a ball from box A or from box B\n",
    "    # If we set both of these to 0.5, then this means that a box was chosen completely at random\n",
    "    # Modify these values to see how the likelihood of the two boxes changes.\n",
    "    prior_box_a = 0.5\n",
    "    prior_box_b = 0.5\n",
    "    \n",
    "\n",
    "    # P(box A | color1, color2, color3, ...) is proportional to \n",
    "    #      P(box A) * P(color1 | box A)  * P(color2 | box A) * P(color3 | box A) * ...\n",
    "    # Hint use the prior_box_a variable and the p_box_a counter from above.\n",
    "    p_box_a_colors = ...\n",
    "    p_box_b_colors = ...\n",
    "    \n",
    "    for color in colors:\n",
    "        ...\n",
    "        ...\n",
    "        \n",
    "    # Which of the two boxes is likelier? Complete the following if statement.\n",
    "    if __________________:\n",
    "        likely_box = \"Box A\"\n",
    "    else:\n",
    "        likely_box = \"Box B\"\n",
    "        \n",
    "    return likely_box\n",
    "\n",
    "#### YOUR CODE ENDS HERE ####\n",
    "\n",
    "\n",
    "\n",
    "print \"Balls in Box A:\"\n",
    "print Counter(box_a)\n",
    "print \"Balls in Box B:\"\n",
    "print Counter(box_b)\n",
    "\n",
    "print \"\"\n",
    "\n",
    "sequences = [[\"red\"], [\"green\"], [\"blue\"], [\"yellow\"], [\"orange\"],\n",
    "            [\"red\", \"red\", \"green\"],\n",
    "            [\"red\", \"green\", \"green\"],\n",
    "            [\"blue\", \"red\", \"green\", \"yellow\", \"blue\", \"yellow\", \"yellow\"],\n",
    "            [\"yellow\", \"orange\"],\n",
    "            [\"yellow\", \"green\"],\n",
    "            [\"yellow\", \"green\", \"green\", \"green\", \"green\"]]\n",
    "\n",
    "for seq in sequences:\n",
    "    print \"The sequence %s most likely came from %s\" % (\", \".join(seq), likeliest_box(seq))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Optional Challenge:  More boxes!\n",
    "\n",
    "Up until now, we always assumed that there were just 2 boxes. But all of this can be extended to more boxes as well!\n",
    "\n",
    "Re-implement the computation of probabilities for four boxes and implement a new *likeliest_box* method that can deal with more than two boxes.\n",
    "\n",
    "This is a very challenging and open-ended problem. Think about how you could solve this and feel free to talk this through with us before you start implementing it.\n",
    "\n",
    "Hint: One useful function for *likeliest_box* might be the *argmax* function (https://docs.scipy.org/doc/numpy/reference/generated/numpy.argmax.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from numpy import argmax\n",
    "\n",
    "number_of_boxes = 4\n",
    "\n",
    "boxes = lib.get_box_contents(n_boxes = number_of_boxes)\n",
    "\n",
    "for i, box in enumerate(boxes):\n",
    "    print \"Box %d has %d balls.\" % (i + 1, len(box))\n",
    "    \n",
    "    \n",
    "#### YOUR CODE STARTS HERE ####\n",
    "\n",
    "# Estimate the conditional probabilities for each box.\n",
    "\n",
    "\n",
    "\n",
    "#### YOUR CODE ENDS HERE ####\n",
    "\n",
    "\n",
    "def likeliest_box(colors):\n",
    "\n",
    "    #### YOUR CODE STARTS HERE ####\n",
    "\n",
    "    priors = []\n",
    "    for box in boxes:\n",
    "        priors.append(1.0 / len(boxes))\n",
    "    \n",
    "    scores = []\n",
    "    \n",
    "    ...\n",
    "    \n",
    "    likeliest_box = ...\n",
    "    \n",
    "    return \"Box %d\" % likeliest_box\n",
    "  \n",
    "    #### YOUR CODE ENDS HERE ####\n",
    "\n",
    "\n",
    "sequences = [[\"red\"], [\"green\"], [\"blue\"], [\"yellow\"], [\"orange\"],\n",
    "            [\"red\", \"red\", \"green\"],\n",
    "            [\"red\", \"green\", \"green\"],\n",
    "            [\"blue\", \"red\", \"green\", \"yellow\", \"blue\", \"yellow\", \"yellow\"],\n",
    "            [\"yellow\", \"orange\"],\n",
    "            [\"yellow\", \"green\"],\n",
    "            [\"yellow\", \"green\", \"green\", \"green\", \"green\"]]\n",
    "\n",
    "for seq in sequences:\n",
    "    print \"The sequence %s most likely came from %s\" % (\", \".join(seq), likeliest_box(seq))\n"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [conda root]",
   "language": "python",
   "name": "conda-root-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}