homework_05-.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from nose.tools import *\n",
    "\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "# Write your imports here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Regression Models Lab\n",
    "## Logistic regression: problem statement, derivation, usage"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classification: Problem Statement\n",
    "In many real cases, the output variable is categorical, i.e. our model should return one of some predefined categories.\n",
    "\n",
    "There are a lot of examples:\n",
    "* Classifying images\n",
    "* Classifying diseases (is a given patient healthy or ill?)\n",
    "* Any case of \"good / bad\" classification\n",
    "* Anomaly detection (e.g. credit card fraud detection)\n",
    "* Processes which involve creating catalogs, etc.\n",
    "\n",
    "We'll start with the simplest case:\n",
    "* Only one input variable $x$\n",
    "* Binary output variable $y$, i.e. either $y = 0$ or $y = 1$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 1. Generate Some Sample Data (1 point)\n",
    "Let's imagine the simplest possible case. For example, we can think of $x$ as \"hours of studying time\" and $y$ as \"passed exam\" (0 of false, 1 if true).\n",
    "\n",
    "A class has 20 students. 12 of them studied between 1 and 3 hours and didn't pass the exam. The other 8 studied between 7 and 10 hours and passed the exam. Let's model this situation.\n",
    "\n",
    "First, to make our work easier, we can split it into two: for failed and passed students. Each student studied a random time, so let's choose this from a random uniform distribution (hint: `np.random.uniform(min, max, size)`).\n",
    "\n",
    "Create the following:\n",
    "```python\n",
    "failed_student_times = np.random.uniform(?, ?, ?)\n",
    "passed_student_times = np.random.uniform(?, ?, ?)\n",
    "all_times = np.concatenate([failed_student_times, passed_student_times])\n",
    "```\n",
    "\n",
    "Now, let's generate the outcome variable: we need 12 zeros, followed by 8 ones.\n",
    "```python\n",
    "exam_result = ...\n",
    "```\n",
    "\n",
    "**Note:** We don't need to use `numpy` arrays but they will give us many benefits later. One is that our code will be really easy and short, and another is that they are very fast (in terms of computation time)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "1926e09cac787971e16133423f28901f",
     "grade": false,
     "grade_id": "cell-9c723e1939fc3177",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "failed_student_times = np.random.uniform(1, 3, 12)\n",
    "passed_student_times = np.random.uniform(7, 10, 8)\n",
    "all_times = np.concatenate([failed_student_times, passed_student_times])\n",
    "exam_result = []\n",
    "for student_time in all_times:\n",
    "    exam_result.append(0 if student_time <= 3 else 1)\n",
    "exam_result = np.array(exam_result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "dc76662f57db4d8fbbe160bed101ec6f",
     "grade": true,
     "grade_id": "cell-77dbf808a1024c06",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "assert_is_instance(all_times, np.ndarray)\n",
    "assert_is_instance(exam_result, np.ndarray)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we now plot the student performance, we'll get something like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_exam_results():\n",
    "    plt.scatter(all_times, exam_result)\n",
    "    plt.xlabel(\"Study time (hours)\")\n",
    "    plt.ylabel(\"Exam result\")\n",
    "    plt.yticks([0, 1])\n",
    "    plt.show()\n",
    "plot_exam_results()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There's a very obvious distinction between the two classes. Once again, that's because we wanted so.\n",
    "\n",
    "How can we model the data? An example would be:\n",
    "```python\n",
    "if x < 5: # or x < 6, or something like that\n",
    "    return 0\n",
    "else:\n",
    "    return 1\n",
    "```\n",
    "\n",
    "This model works but let's look at a more realistic scenario."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 2. Generate More Realistic Sample Data (1 point)\n",
    "Now, this was a really simple view. A more involved model would include some error.\n",
    "\n",
    "First, let's ensure the test results are repeatable, even with random variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's reuse the previous example but this time:\n",
    "* Generate 20 study times between 1 and 10. Choose each number randomly from a uniform distribution (hint: this is the same as what you did before).\n",
    "* Generate the exam output variable like this: For each study time, if it's $\\le$ 3 hours, it should be 0, if it's $\\ge$ 7 hours, it should be 1. If the study time is between 3 and 7 hours, decide randomly whether it should be 0 or 1.\n",
    "* How do we decide randomly between 0 and 1? A simple way would be to generate a random number between 0 and 1: `np.random.random()`. If that number is >= 0.5, say the student passed the exam and vice versa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "e676611d84d33585bdbc288476c4abcc",
     "grade": false,
     "grade_id": "cell-9740949f4386388b",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "all_times = np.random.uniform(1, 10, 20)\n",
    "exam_result = []\n",
    "for student_time in all_times:\n",
    "    if (student_time <= 3 or student_time >= 7):\n",
    "        exam_result.append(0 if student_time <= 3 else 1)\n",
    "    else:\n",
    "        random_number = np.random.random()\n",
    "        exam_result.append(0 if random_number<=0.5 else 1)\n",
    "exam_result = np.array(exam_result)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "84402a75e10ed6dacd326da0ada9473c",
     "grade": true,
     "grade_id": "cell-56a1a993a1fe0b84",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "assert_is_instance(all_times, np.ndarray)\n",
    "assert_is_instance(exam_result, np.ndarray)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_exam_results()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now the results look more fuzzy. It's obvious that we can't model them with 100% accuracy.\n",
    "\n",
    "Still, let's try some things."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 3. Decide on a Modelling Function (2 points)\n",
    "We can see that our old approach can work somewhat. If we try to plot the prediction function, we'll see this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(all_times, exam_result)\n",
    "plt.hlines([0, 1], [1, 5], [5, 10], color = \"red\")\n",
    "plt.vlines(5, 0, 1, linestyle = \"dashed\", color = \"red\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The red line is called \"decision boundary\". We can see that we misclassified some students but we are mostly correct.\n",
    "\n",
    "However, the function has problems. First of all, it's undefined at $x = 5$ (we don't know if it's 0 or 1). Second, it has \"sharp corners\", and mathematicians hate functions with sharp corners :).\n",
    "\n",
    "We're looking for a function that kind of looks like our line. And there is such a function. It's called a **sigmoid** function. Its definition is like this:\n",
    "\n",
    "$$ \\sigma(z) = \\frac{1}{1+e^{-z}} $$\n",
    "\n",
    "Implement the previous formula in code. Note: you can use `np.exp(something)` instead of `np.e ** something` - it's much more reliable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "79cce4179f40f32dc70c0beed97bd359",
     "grade": false,
     "grade_id": "cell-5a833837981bc4a0",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "def sigmoid(z):\n",
    "    return 1/(1+np.exp(-z))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have the function (and hopefully it's correct :D), we can plot it. The plot should look similar to what's described in [this](https://en.wikipedia.org/wiki/Sigmoid_function) article."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(-10, 10, 1000)\n",
    "y = sigmoid(x) # Note that this line should work correctly\n",
    "plt.plot(x, y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This function, as you can see, has interesting properties:\n",
    "* For really large negative $x$ (say $x < -5$), it's practically 0\n",
    "* For really large positive $x$, it's practically 1\n",
    "* At 0, it's 0.5 exactly\n",
    "\n",
    "Also, it looks like our original guess and has no sharp corners. This function is also called **logistic function** and it will be our **modelling function**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "7fe48a38476e895d11e6c90914095c8f",
     "grade": true,
     "grade_id": "cell-fe10135ce3b8cff3",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "assert_almost_equal(sigmoid(-50), 0, delta = 1e-10)\n",
    "assert_almost_equal(sigmoid(0), 0.5, delta = 1e-10)\n",
    "assert_almost_equal(sigmoid(50), 1, delta = 1e-10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will need to fix an issue: $\\sigma(z)$ has continuous output, as we already saw. How do we make it binary?\n",
    "\n",
    "Simple enough; if $\\sigma \\lt 0.5$, we'll output 0 and 1 otherwise (note that this will assign class 1 to $\\sigma(0)$ but that's OK).\n",
    "\n",
    "Let's write a function that accepts a $z$ (number between 0 and 1) and decides what output label should it produce: 0 or 1. Note that this is exactly the process that we defined as \"thresholding\" some time ago."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "0a495a6adcb465a2a0701dbfa84eeb3e",
     "grade": false,
     "grade_id": "cell-72d18afc1bdbc4cd",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "def generate_output(z):\n",
    "    sigmoid_result = sigmoid(z)\n",
    "    return 0 if sigmoid_result < 0.5 else 1 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "c8de1dbddc706ac3ffa6b6da737431c9",
     "grade": true,
     "grade_id": "cell-e6e5fb40e0bb020f",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-2 0.11920292202211755 0\n",
      "-1 0.2689414213699951 0\n",
      "0 0.5 1\n",
      "1 0.7310585786300049 1\n",
      "2 0.8807970779778823 1\n"
     ]
    }
   ],
   "source": [
    "for x in np.arange(-2, 3):\n",
    "    print(x, sigmoid(x), generate_output(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 4. Use the Sigmoid Function as a Model (1 point)\n",
    "Now, we've got another issue ahead. How can we model the parameter $z$ of $\\sigma(z)$? All we know is that it should be a number.\n",
    "\n",
    "Well, this number must be somehow related to the input parameters. The simplest possible relation is linear:\n",
    "\n",
    "$$z = ax + b$$\n",
    "\n",
    "where $x$ is the number of hours, $a$ is its coefficient, and $b$ is an intercept (also called \"free term\" or \"bias term\").\n",
    "\n",
    "Therefore, we can rewrite our function $\\sigma(z)$ to be $l(x)$, like so:\n",
    "$$ l(x) = \\frac{1}{1+e^{-(ax+b)}}=\\sigma(ax+b) $$\n",
    "\n",
    "$l$ stands for \"logistic function\".\n",
    "\n",
    "This function has two properties:\n",
    "* Its value will tell us which class to choose (0 or 1)\n",
    "* It can serve as a probability: $l(x)$ is equal to the probability that the output class is 1\n",
    "\n",
    "Write a function that does exactly this. **Reuse your implementation** of the `sigmoid` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "5fb407862fc4e5a8b3bdc4dacbc39488",
     "grade": false,
     "grade_id": "cell-671cdc824b7d585c",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "def logistic_function(x, a, b):\n",
    "    return sigmoid(a*x+b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "df0ce821e8fff8db059aa511d6bc8049",
     "grade": true,
     "grade_id": "cell-92f8ba87e6c6ee5e",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5\n",
      "[0.99908895 0.99330715 0.95257413 0.73105858 0.26894142 0.04742587\n",
      " 0.00669285]\n"
     ]
    }
   ],
   "source": [
    "# The function should work with both numbers and numpy arrays\n",
    "print(logistic_function(0, 1, 0)) # Should be 0.5\n",
    "print(logistic_function(np.arange(-2, 5), a = -2, b = 3)) # Should return decreasing numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now the problem is similar to what we did before: we need to find the best parameters $a$ and $b$.\n",
    "\n",
    "Let's try out different values of $a$ and $b$, just to get a feel of what we need to do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD4CAYAAAD8Zh1EAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAZiUlEQVR4nO3de5RV9X338fd3bswQRVQGBmaAwQAGRCPJeKvBKsbF5UnEqFVxuZL6NLFpY5umhkZaSxJNmwvtk9j1aBsem5o0iS5jEkpd9KGJ2hWfVBKG0McLFKV4YYarBNBwCQN8+8c+g4eZM2fOzOy9f2ef+bzWOmufs/fvnPM5B/y42Zezzd0REZHsqwodQERE4qFCFxGpECp0EZEKoUIXEakQKnQRkQpRE+qNx4wZ462traHeXkQkk9avX/+GuzcWWhas0FtbW2lvbw/19iIimWRmr/W1TJtcREQqhApdRKRCqNBFRCqECl1EpEKo0EVEKoQKXUSkQqjQRUQqhApdRKRC9HtikZl9A/gAsNvdZxVYbsD9wELgEPDb7v6LuIOKDMTKDZ0sX7OZ7fsPM2F0A0vmnct1s5uHPDZLCn0uILbPWux7i+M7zX+NMxpqMYP9h7oq6s8obtbfBS7M7ArgV8C3+ij0hcAfEBX6JcD97n5Jf2/c1tbmOlNUkrByQydLf/A8h7uOn5zXUFvNF68/v1cJDGRslhT6XLXVBg5dJ97+b36wn7XY9wYM+Tst9Pr5KuHPaLDMbL27txVa1u8aurv/xMxaiwxZRFT2Dqw1s9FmNt7ddwwqbX8eegiWL4eqquhWXd37fqF5VVVQWwujRkW300+Ppk1N0NoKU6ZEt9raRGJLepav2dyrCA53HWf5ms29CmAgY7Ok0OfqOt575W2wn7XY99Z9fyjvU+j148hd6eL4LZdmYFve447cvF6FbmZ3AHcATJo0aXDvNm4cvOc9cOIEHD8eTfPvF5p37Fh0/+hR2LoV3nwzuh08eOprNzTARRfB3LmweDFMnz64jBLU9v2HS54/kLFZMpD8g/msg/ne4s6U9T+jJMRR6FZgXsHtOO6+AlgB0SaXQb3bBz8Y3eJw7Bjs3AmvvBLdNmyAn/4UPv95+Nzn4Kqr4L774PLL43k/ScWE0Q10FviPfcLohiGNzZK+PldfY+N6/e7XGup3Wkr+rP8ZJSGOo1w6gIl5j1uA7TG8bvJqaqClBebMgQ9/GL76Vfj5z6GjA77yFdi4Ed73Pvi934NDh0KnlRItmXcuDbXVp8xrqK0+uVNwsGOzpNDnqq02aqtOXf8a7Gct9r3F8Z0Weo2hvN5wEcca+irgTjN7lGin6IHEtp+nZcIEWLIEPvEJ+Oxn4a//Gp57Dv75n+Gss0Knk350b1ct5SiLgYzNkr4+V6F5g/mspXxvQ3mfnq+vo1xKU8pRLo8AVwJjgF3AZ4FaAHf/u9xhi/8bmE902OLt7t7v4SuZOsrl+9+HW2+Ntt0//TTU14dOJCLD1FCPclncz3IHPjHIbNlwww3w3e/CjTfCxz8ODz8cOpGISC86U7RUN9wAf/7n8M1vRpteRETKjAp9IO65B2bN0k5SESlLKvSBqKuDBx+Ezk74+tdDpxEROYUKfaDmzIGrr4Yvf1lr6SJSVlTog7FsGezaBd/5TugkIiInqdAHY86caFu6NruISBlRoQ+GGfzu78L69dEJRyIiZUCFPlg33RT9guPjj4dOIiICqNAHb+xYuOKK6CxSEZEyoEIfihtuiH7Aa9Om0ElERFToQ/KhD0XTJ54Im0NEBBX60DQ3w4wZ8NRToZOIiKjQh2zuXHjmmehqSCIiAanQh2ru3OhSduvWhU4iIsOcCn2ofvM3o+PSn3wydBIRGeZU6EN19tlw3nnw7LOhk4jIMKdCj8PFF0ebXPq5+pOISJJU6HG46CLYuxdefTV0EhEZxlTocbjoomiqHaMiEpAKPQ7nnx9d/EKFLiIBqdDjUFcHF16oQheRoFTocZk9O/opXe0YFZFAVOhxmTUL9u2DnTtDJxGRYUqFHpfzzoumL7wQNoeIDFsq9LjMmhVNX3wxbA4RGbZU6HFpbIxuWkMXkUBU6HE67zytoYtIMCr0OM2aFRW6jnQRkQBU6HGaMQPeegt27AidRESGoZIK3czmm9lmM9tiZncXWD7JzJ42sw1m9pyZLYw/agZMmxZNt2wJm0NEhqV+C93MqoEHgAXATGCxmc3sMewe4DF3nw3cAjwYd9BMmDo1mr78ctgcIjIslbKGfjGwxd23uvtR4FFgUY8xDozK3T8D2B5fxAyZOBFqa7WGLiJBlFLozcC2vMcduXn5PgfcZmYdwGrgDwq9kJndYWbtZta+Z8+eQcQtczU1MGWKCl1Egiil0K3AvJ6HcSwGHnb3FmAh8I9m1uu13X2Fu7e5e1tjY+PA02bBtGna5CIiQZRS6B3AxLzHLfTepPI7wGMA7v4sUA+MiSNg5kydGq2h69BFEUlZKYW+DphmZlPMrI5op+eqHmNeB64GMLMZRIVegdtUSjB1Khw8CLt2hU4iIsNMv4Xu7seAO4E1wCaio1leNLN7zeza3LC7gI+Z2f8HHgF+232YrqLqSBcRCaSmlEHuvppoZ2f+vGV59zcCl8cbLaOmTImmr70Gc+aEzSIiw4rOFI3bpEnRVBeMFpGUqdDj1tAAY8dGa+giIilSoSdh8mQVuoikToWeBBW6iASgQk/C5Mnw+us6Fl1EUqVCT8LkyXDkCOzeHTqJiAwjKvQkTJ4cTbXZRURSpEJPggpdRAJQoSdBhS4iAajQkzB6NJx2GnR2hk4iIsOICj0pzc0qdBFJlQo9KSp0EUmZCj0pKnQRSZkKPSnNzbB9O5w4ETqJiAwTKvSkNDdDVxdU4rVTRaQsqdCT0py7jrY2u4hISlToSVGhi0jKVOhJUaGLSMpU6EkZNw6qqlToIpIaFXpSamqgqUmFLiKpUaEnSceii0iKVOhJUqGLSIpU6ElSoYtIilToSZowAfbvh8OHQycRkWFAhZ6kpqZoumtX2BwiMiyo0JM0fnw03bkzbA4RGRZU6EnqXkNXoYtIClToSVKhi0iKVOhJamwEMxW6iKRChZ6kmpqo1HfsCJ1ERIaBkgrdzOab2WYz22Jmd/cx5iYz22hmL5rZd+ONmWFNTVpDF5FU1PQ3wMyqgQeAa4AOYJ2ZrXL3jXljpgFLgcvdfZ+ZjU0qcOao0EUkJaWsoV8MbHH3re5+FHgUWNRjzMeAB9x9H4C77443Zoap0EUkJaUUejOwLe9xR25evunAdDP7qZmtNbP5hV7IzO4ws3Yza98zXC7N1l3o7qGTiEiFK6XQrcC8nu1UA0wDrgQWAw+Z2eheT3Jf4e5t7t7W2Ng40KzZ1NQER49GPwEgIpKgUgq9A5iY97gF2F5gzD+5e5e7vwJsJip40bHoIpKSUgp9HTDNzKaYWR1wC7Cqx5iVwFUAZjaGaBPM1jiDZpYKXURS0m+hu/sx4E5gDbAJeMzdXzSze83s2tywNcBeM9sIPA0scfe9SYXOFP2ei4ikpN/DFgHcfTWwuse8ZXn3Hfjj3E3yaQ1dRFKiM0WTdsYZMGKECl1EEqdCT5qZjkUXkVSo0NOgQheRFKjQ06BCF5EUqNDT0NSkX1wUkcSp0NPQ1ARvvAFdXaGTiEgFU6Gnoakp+i2X3frNMhFJjgo9Dd3Hou/aFTaHiFQ0FXoaVOgikgIVehp0tqiIpECFnoZx46KpCl1EEqRCT0NDA4wapUIXkUSp0NOik4tEJGEq9LQ0NWmnqIgkSoWeFq2hi0jCVOhpGTdOhS4iiVKhp6WpCQ4cgMOHQycRkQqlQk+LTi4SkYSp0NOiQheRhKnQ06KzRUUkYSr0tOhsURFJmAo9LWPHRlMVuogkRIWeltpaGDNGhS4iiVGhp0knF4lIglToadLp/yKSIBV6mrSGLiIJUqGnqfv0f/fQSUSkAqnQ09TUFJ36/9ZboZOISAVSoadJJxeJSIJKKnQzm29mm81si5ndXWTcjWbmZtYWX8QKotP/RSRB/Ra6mVUDDwALgJnAYjObWWDc6cAfAj+LO2TF0Bq6iCSolDX0i4Et7r7V3Y8CjwKLCoy7D/gKcCTGfJVFp/+LSIJKKfRmYFve447cvJPMbDYw0d2fKPZCZnaHmbWbWfuePXsGHDbzzj4bqqtV6CKSiFIK3QrMO3ncnZlVAV8F7urvhdx9hbu3uXtbY2Nj6SkrRVWVrlwkIokppdA7gIl5j1uA7XmPTwdmAf9mZq8ClwKrtGO0DzpbVEQSUkqhrwOmmdkUM6sDbgFWdS909wPuPsbdW929FVgLXOvu7YkkzjqdLSoiCem30N39GHAnsAbYBDzm7i+a2b1mdm3SASuONrmISEJqShnk7quB1T3mLetj7JVDj1XBuje5nDgRbVMXEYmJGiVtTU1w7Bj88pehk4hIhVGhp01ni4pIQlToadPZoiKSEBV62nS2qIgkRIWetu419B07wuYQkYqjQk/bqFEwcqQKXURip0JPmxk0N0NHR+gkIlJhVOghNDdDZ2foFCJSYVToIajQRSQBKvQQWlpg+/bobFERkZio0ENoboajR+GNN0InEZEKokIPoTl3fRBtdhGRGKnQQ2hpiaYqdBGJkQo9hO41dB26KCIxUqGHMG5c9NO5WkMXkRip0EOoqYHx41XoIhIrFXooOhZdRGKmQg9Fp/+LSMxU6KG0tGgNXURipUIPpaUFDhyAN98MnUREKoQKPZTW1mj62mtBY4hI5VChh9Jd6K++GjKFiFQQFXooKnQRiZkKPZTGRmho0CYXEYmNCj0Us2gtXWvoIhITFXpIKnQRiZEKPSQVuojESIUeUmsr7N0Lb70VOomIVAAVekg6Fl1EYqRCD2ny5GiqzS4iEoOSCt3M5pvZZjPbYmZ3F1j+x2a20cyeM7MnzWxy/FErkI5FF5EY9VvoZlYNPAAsAGYCi81sZo9hG4A2d78AeBz4StxBK9LYsTByJGzdGjqJiFSAUtbQLwa2uPtWdz8KPAosyh/g7k+7+6Hcw7VAS7wxK5QZTJsGL70UOomIVIBSCr0Z2Jb3uCM3ry+/A/xLoQVmdoeZtZtZ+549e0pPWcmmT1ehi0gsSil0KzDPCw40uw1oA5YXWu7uK9y9zd3bGhsbS09ZyaZPjza5HD0aOomIZFwphd4BTMx73AJs7znIzN4P/Blwrbv/Op54w8C558Lx4/DKK6GTiEjGlVLo64BpZjbFzOqAW4BV+QPMbDbwdaIy3x1/zAo2fXo03bw5bA4Rybx+C93djwF3AmuATcBj7v6imd1rZtfmhi0HTgO+Z2b/YWar+ng56am70LUdXUSGqKaUQe6+GljdY96yvPvvjznX8HHmmdFP6arQRWSIdKZoOZg+HTZtCp1CRDJOhV4Ozj8fXngBvODBQyIiJVGhl4MLLoD9+2Hbtv7Hioj0QYVeDt797mj63HNhc4hIpqnQy8GsWdFUhS4iQ6BCLwejRsGUKSp0ERkSFXq5uOACFbqIDIkKvVxceGF0tqguRycig6RCLxeXXgonTsC6daGTiEhGqdDLxSWXRNNnnw2bQ0QyS4VeLs48E2bMUKGLyKCp0MvJpZfC2rU6Y1REBkWFXk4uuwz27tUPdYnIoKjQy8lVV0XTH/84bA4RySQVejmZOhXOOQfWrAmdREQySIVebubNg6ef1jVGRWTAVOjlZt48+NWv4N//PXQSEckYFXq5mTsXRoyAH/4wdBIRyRgVerk5/XT44Afh0Ufh2LHQaUQkQ1To5ejWW2H3bnjqqdBJRCRDVOjlaMECOOMMePjh0ElEJENU6OWovh5uvx2+9z3o6AidRkQyQoVerj75yejXF//mb0InEZGMUKGXq9ZWuOkmePBB2L49dBoRyQAVejn7whegqwuWLg2dREQyQIVezt75TrjrLvjWt+CJJ0KnEZEyp0Ivd8uWwezZ8OEPw3/9V+g0IlLGVOjlrr4eHnsMqqqiX2NUqYtIH1ToWTB1avSTugcPwkUXRT8LoItgiEgPNaUMMrP5wP1ANfCQu3+px/IRwLeA9wJ7gZvd/dV4ow5zF14YXUD6hhvg+uvhmmvgM5+BuXNZ+R/bWb5mM9v3H2bC6AaWzDuX62Y3A7ByQ2efywbqnpXP88jPtnHcnWozFl8yEaDXvC9cd/6Q3jf/uaNH1uIOBw53DTl/0obymQt9t1+47vyEE0ulMe9nTc/MqoGXgGuADmAdsNjdN+aN+X3gAnf/uJndAnzI3W8u9rptbW3e3t4+1PzDT1dXdCjjfffB3r0caprAE+Mv4Ofj38XmMZPZcvZEeMc7+OL1URks/cHzHO46fvLpDbXVfPH68wdcivesfJ5vr329pLGXv/MsfvH6gUG978oNnb0y5xts/qQVyl1q1r6+29sunaRSl17MbL27txVcVkKhXwZ8zt3n5R4vBXD3L+aNWZMb86yZ1QA7gUYv8uIq9CE6cgQef5x/+9IK3vPyekYdPXRy0Vt1Dew7/Sz2nzaa/VbH4doR0a1mBF3VtYysr+XGiydH2+Wrq3tPzXq93f0/fhmn/808Tu/ndju9vpaPzplSeGHuPR96ZitvHin+o2Sj6mv46JxzTnleaP/nJ1t580hXr/mj6mv52BXnFH3uV3/0EicK/KdSZcanrpkeW0YpIwsXwnvfO6inFiv0Uja5NAPb8h53AJf0Ncbdj5nZAeBs4I0eQe4A7gCYNGlSSeGlD/X1cNtt3P7CmdiJ40zev5Ppe17jnH2dNP5qH40H93HW4QOcdvQQjQf30dD1a0Z2HaH6xHGq/QRsrIbjx6OzUXtOC/hkXLmfLL74o6W+Tpldpe9jxRb2k/VTxRY+M/AskgGNjYMu9GJKKfRCq0A9VydKGYO7rwBWQLSGXsJ7Sz8mjG6gc/9hXjmrmVfOevuf9s2jGwDo3H+413OaRzfw07vnDuh93rl0Ncf72xHbz/I+3zfvee/70lN0Huid+ZTXOaOB/3f33LLaMTzny0/1+V0/85ni3/W0Py383Vab8fJfLowto5SRhP5lWcpRLh3AxLzHLUDPc9FPjsltcjkD+GUcAaW4JfPOpaG2+pR5DbXVLJl3btFlA9W9A7QoMzDj8qln01BXc/IxZjTU1bBk/rtOmXfyVlV18vbpBTOor6vFrargrb6ulk8vmPH25qEyud21YCYjRtRxoqr65G3EiDruWjCz3+fefFnrKc/rvt18WWvwz6VbQreqZA4wLGUNfR0wzcymAJ3ALcCtPcasAj4CPAvcCDxVbPu5xKd7h1uxoyviOMqle+dc0ke59Pw8WTnKpZQ/h7709d1qh6gMVL87RQHMbCHwNaAa+Ia7/4WZ3Qu0u/sqM6sH/hGYTbRmfou7by32mtopKiIycEPdKYq7rwZW95i3LO/+EeC3hhJSRESGRmeKiohUCBW6iEiFUKGLiFQIFbqISIVQoYuIVAgVuohIhVChi4hUiJJOLErkjc32AK8N8ulj6PHDX2UuS3mzlBWylTdLWSFbebOUFYaWd7K7NxZaEKzQh8LM2vs6U6ocZSlvlrJCtvJmKStkK2+WskJyebXJRUSkQqjQRUQqRFYLfUXoAAOUpbxZygrZypulrJCtvFnKCgnlzeQ2dBER6S2ra+giItKDCl1EpEJkttDNbLmZ/aeZPWdmPzSz0aEz9WRm881ss5ltMbO7Q+cpxswmmtnTZrbJzF40s9iuC50UM6s2sw1m9kToLP0xs9Fm9nju7+wmM7ssdKa+mNmncn8HXjCzR3IXsCkbZvYNM9ttZi/kzTvLzH5kZi/npmeGzNitj6yJdVdmCx34ETDL3S8AXgKWBs5zCjOrBh4AFgAzgcVmNjNsqqKOAXe5+wzgUuATZZ4X4JPAptAhSnQ/8H/d/V3AuynT3GbWDPwh0Obus4iuUnZL2FS9PAzM7zHvbuBJd58GPJl7XA4epnfWxLors4Xu7v/q7sdyD9cSXby6nFwMbHH3re5+FHgUWBQ4U5/cfYe7/yJ3/y2iwim/i3fmmFkL8D+Ah0Jn6Y+ZjQKuAP4ewN2Puvv+sKmKqgEachd8H0nvi8IH5e4/ofdF6BcB38zd/yZwXaqh+lAoa5LdldlC7+F/Av8SOkQPzcC2vMcdlHFB5jOzVqLrw/4sbJKivgb8CXAidJASnAPsAf4ht4noITN7R+hQhbh7J/BXwOvADuCAu/9r2FQlGefuOyBaOQHGBs5Tqli7q6wL3cx+nNuO1/O2KG/MnxFtLvhOuKQFWYF5ZX+MqJmdBnwf+CN3fzN0nkLM7APAbndfHzpLiWqA9wB/6+6zgYOUzyaBU+S2PS8CpgATgHeY2W1hU1WmJLqrpItEh+Lu7y+23Mw+AnwAuNrL74D6DmBi3uMWyuyfrj2ZWS1RmX/H3X8QOk8RlwPXmtlCoB4YZWbfdvdyLZ4OoMPdu//F8zhlWujA+4FX3H0PgJn9APgN4NtBU/Vvl5mNd/cdZjYe2B06UDFJdVdZr6EXY2bzgc8A17r7odB5ClgHTDOzKWZWR7RjaVXgTH0yMyPaxrvJ3f9X6DzFuPtSd29x91ai7/WpMi5z3H0nsM3Mzs3NuhrYGDBSMa8Dl5rZyNzfiasp0x24PawCPpK7/xHgnwJmKSrJ7srsmaJmtgUYAezNzVrr7h8PGKmX3Brk14iOFPiGu/9F4Eh9MrP3Ac8Az/P2duk/dffV4VL1z8yuBD7t7h8InaUYM7uQaAduHbAVuN3d94VNVZiZfR64mWhzwAbgo+7+67Cp3mZmjwBXEv0E7S7gs8BK4DFgEtH/lH7L3XvuOE1dH1mXklB3ZbbQRUTkVJnd5CIiIqdSoYuIVAgVuohIhVChi4hUCBW6iEiFUKGLiFQIFbqISIX4b+E1sjn0KNBvAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_prediction_with_sigmoid(a, b, x, y, title = \"\"):\n",
    "    plt.scatter(x, y)\n",
    "    logistic_x_values = np.linspace(-2, 12, 1000)\n",
    "    logistic_y_values = logistic_function(logistic_x_values, a, b)\n",
    "    plt.plot(logistic_x_values, logistic_y_values, color = \"red\")\n",
    "    plt.title(title)\n",
    "    plt.show()\n",
    "\n",
    "for a, b in [[2, 5], [3, -6], [-5, 0.5], [1.5, -8]]:\n",
    "    plot_prediction_with_sigmoid(a, b, all_times, exam_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can understand that $a$ controls how \"spread out\" the function is, also if $a < 0$, the function is inverted. $b$ seems to control where the \"center point\" is."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 5. Choose an Error Function (2 points)\n",
    "Now that we have an idea what our modelling function does, the next step is to choose a good error function.\n",
    "\n",
    "The error function should accept a single predicted value $\\tilde{y} = \\sigma(ax+b)$ and an actual value $y$. It should tell us whether we're right or not. Note that the sigmoid value is always between 0 and 1.\n",
    "\n",
    "**Note:** In terminology, there's a difference between \"error function\" and \"cost / loss function\". The error function is defined for one point only while the cost function is for the entire dataset.\n",
    "\n",
    "Since we have two classes, we will need to define a separate error function for each class: $error_0$ will correspond to the case where the correct class should be $0$; $error_1$ will correspond to class $1$.\n",
    "\n",
    "Our intuition is that the errors should be equal to zero if we predicted the class correctly, and greater than zero otherwise. So, for example, the error functions might look like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sigmoid_values = np.linspace(0, 1, 1000)\n",
    "error_0_values = sigmoid_values\n",
    "error_1_values = - sigmoid_values + 1\n",
    "plt.plot(sigmoid_values, error_0_values, label = \"$error_0$\")\n",
    "plt.plot(sigmoid_values, error_1_values, label = \"$error_1$\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Take $error_0$ for example. It is 0 if the predicted class is 0 and increases everywhere else.\n",
    "\n",
    "There are many choices for error functions. However, not all are created equal. For purposes we're not going to discuss, it turns out the best error function for logistic regression is this:\n",
    "$$\n",
    "error_0 = -\\ln(1-x) \\\\\n",
    "error_1 = -\\ln(x)\n",
    "$$\n",
    "\n",
    "If you're interested why this function is the best, you can look it up online. The main idea is that this function has only one minimum. When we do gradient descent, we can get stuck in a local minimum and miss the global one. This error function ensures that nasty thing won't happen.\n",
    "\n",
    "Let's implement and inspect the two functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "9ecbdc8a9fa75771cf373aa8c9b2429b",
     "grade": false,
     "grade_id": "cell-b8c755eadd32790e",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "def error_0(x):\n",
    "    return -np.log(1 - x)\n",
    "\n",
    "def error_1(x):\n",
    "    return -np.log(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "2ebfe9f3d7be1711793bd74df9fa7566",
     "grade": true,
     "grade_id": "cell-19b0edfed3b62042",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\ivan\\appdata\\local\\programs\\python\\python37-32\\lib\\site-packages\\ipykernel_launcher.py:2: RuntimeWarning: divide by zero encountered in log\n",
      "  \n",
      "c:\\users\\ivan\\appdata\\local\\programs\\python\\python37-32\\lib\\site-packages\\ipykernel_launcher.py:5: RuntimeWarning: divide by zero encountered in log\n",
      "  \"\"\"\n"
     ]
    }
   ],
   "source": [
    "assert_almost_equal(error_0(0), 0)\n",
    "assert_greater(error_0(1), 0)\n",
    "\n",
    "assert_almost_equal(error_1(1), 0)\n",
    "assert_greater(error_1(0), 0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\ivan\\appdata\\local\\programs\\python\\python37-32\\lib\\site-packages\\ipykernel_launcher.py:2: RuntimeWarning: divide by zero encountered in log\n",
      "  \n",
      "c:\\users\\ivan\\appdata\\local\\programs\\python\\python37-32\\lib\\site-packages\\ipykernel_launcher.py:5: RuntimeWarning: divide by zero encountered in log\n",
      "  \"\"\"\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWoAAAD4CAYAAADFAawfAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nO3dd3hc1bnv8e9SHXXJ6laxLFfJBTdsCHboNbQE00ICAXJMEtJ5bnJykpuTnHPhCec+CYd7ThLiEwzEJKFD6BCIwTQXuWBbbsgqtiRLGvU6KjPr/rFGsmzL1tjWnj3l/TzPPFuj2dK825J/Xn732nsprTVCCCECV4TdBQghhDg5CWohhAhwEtRCCBHgJKiFECLASVALIUSAi7Lim2ZkZOiioiIrvrUQQoSkLVu2NGutM8d6zZKgLioqoqyszIpvLYQQIUkpVXOi16T1IYQQAU6CWgghAty4Qa2UmqWU2j7q0amU+r4/ihNCCOFDj1prvQ9YAKCUigTqgBctrkuEoMHBQWpra3G5XHaXYhuHw0F+fj7R0dF2lyKCyKmeTLwYOKC1PmHTW4gTqa2tJSkpiaKiIpRSdpfjd1prWlpaqK2tZerUqXaXI4LIqfaobwH+akUhIvS5XC7S09PDMqQBlFKkp6eH9f8oxOnxOaiVUjHAtcCzJ3h9lVKqTClV5nQ6J6o+EWLCNaSHhfvxi9NzKiPqK4GtWuvGsV7UWq/WWi/RWi/JzBxzzvb4dr0AG35/el8rhBA2euT9A7xd3mDJ9z6VoL4Vq9see1+FTf9j6VsIIYQV/vhBFev2WdNN8CmolVLxwKXAC5ZUMVJNFGi3pW8hhBBW8GhNVIQ1rS2fglpr3au1Ttdad1hSxUg1UeCRoBb2c7vdJ33u69eJ8DHk9hBpUVBbcq+P0xYRCZ4hu6sQIa6qqorvf//71NXVERERwdq1a5k1axY33ngjBQUFbNu2jYsvvphPP/30qOcrV65k1apVtLS0kJuby1NPPUVGRsZxX/ezn/3M7kMUNnB7rBtRB1hQR0lQh4lfvlLO7vrOCf2epZOT+ddr5px0n8HBQb7+9a+zevVqpk2bxuuvv86vfvUrHnvsMXbu3ElJSQnr1q0DYPbs2SPP+/v7WbRoEU8++SQLFy7kwQcf5KGHHuL+++8/7utEeBryaCIjJaiFOGMvvfQS5eXl3HDDDQAMDQ2xYsUKXC4Xra2t/PznPwc47vlLL73E8uXLWbhwIQClpaW8/PLLx+3X09PDt771LWJiYrjgggu47bbbbDhKYYcwG1FLjy8cjDfytcqnn37K/fffz913333U57ds2cKyZcuIijJ/JcrLy496vnv3bubNmzey/86dOyktLT1uvxdeeIGVK1dyzTXXcPPNN0tQhwmttRlRR1hzn7vAunue9KiFxXJzc3nrrbfweDyACVytNTt37mT+/Pkj+x37PC8vj927dwNQWVnJ2rVruf3224/br7a2loKCAgAiIyP9cUgiAHi02do668NvpPUhLHbXXXfh8XgoKSlhwYIFPPjggyilxg3qr371q9TX1zNv3jxuueUW1qxZQ3p6+nH75efnU1tbCzDyj4EIfUPen3WYzPqQoBbWiouL47nnnjvu87/+9a9P+jwuLo6XXnpp3K/70pe+xLe//W1ee+01rrnmmgmoWAQDt3dIHT49au0Bjwcs6vUIYaWEhAQee+wxu8sQfjbkDWqrRtSBlYYR3p6eXJ0ohAgibre1I+oAC2rvAF/aH0KIIDIyoo4Mi1kfEtRCiOBjdY86sIJaeVsfEtRCiCAyMuvDovuNB1ZQj4yopUcthAge7rA8mSgjaiFEEBlpfVh0r48AC2oZUQshgk+YjajlZKIQIvgMhdXJRAlqIUQQOjKiDofpeZHRZusesLcOEfZkhRdxKgbcZtaHVT3qwLqEPCrWbIf67a1DhDRZ4UVMtIEhE9SxFl3wIkEt7PHGP0PDzon9njnz4MpfnXQXWeFFWGHQO6KOjrKx9aGUSlVKPaeU2quU2qOUOteSaqIcZjvksuTbCzF6hZcFCxbwox/9CIfDcVorvDQ1NR23X2VlJXfffTcrV6605wCFLYZH1DE2j6gfBt7UWq9USsUA8dZU4w1q6VGHvnFGvlaxeoWX4uJiHn30UQnqMDMS1HaNqJVSycDngUcBtNYDWut2S6oZaX3IiFpYw+oVXkR4Gj6ZGG3jTZmKASfwmFJqm1Lqj0qphGN3UkqtUkqVKaXKnE7n6VUz0vqQHrWwhtUrvIjwNHIy0aIRNVrrkz6AJcAQsMz7/GHg30/2NYsXL9anpa1G639N1nrr2tP7ehHQdu/ebXcJlmtubtb33HOPLi4u1g888MCY+4TDn0O4eXJDtZ7y41d1Q0ffaX8PoEyfIFN96VHXArVa643e588B/zzx/2QAkdL6EMEtPT2dRx55xO4yhJ9ZfTJx3O+qtW4ADimlZnk/dTGw25JqZHqeECIIWT09z9dZH98B/uyd8VEJ3GlNNTI9TwgRfAJiep7WejumV20tGVELIYLQcFBHh8VtTpUyfWoJ6pBlzpmEr3A//lDlGvLgiI5AhcUKL2DaHxLUIcnhcNDS0hK2YaW1pqWlBYfDYXcpYoK5Bt04oiMt+/6Bda8PMO0P6VGHpPz8fGprazntefYhwOFwkJ+fb3cZYoL1DbiJC7+glhF1KIqOjmbq1Kl2lyHEhDOtD+uCOgBbHzKiFkIEl74Ba1sfARjU0qMWQgSX/iE3jmjr4jQAg1pG1EKI4NI34MYRJSNqIYQIWK6wG1FHx8Ngj91VCCGEz3r73STEWjc3I/CCOjYR+rvtrkIIIXzW3T9EYlgFdUwi9HfZXYUQQvisu38o3EbUyTAgI2ohRHBwezS9A+4wG1HHJpqg9i6VJIQQgaxnYAgg3II6yWxlVC2ECAI9/d6gdoRTUMckmq30qYUQQWA4qMOsRy0jaiFE8OhymaBOCsuglhG1ECII9PS7gXAbUUvrQwgRRLpHWh/hdAm5jKiFEEFkOKiTYqMtew8JaiGEOAPdrkHA2hG1T00VpVQ10AW4gSGttXUL3calmW1fm2VvIYQQE6W9zwR1Spx1I+pT6X5fqLVutqySYY4UUJHQ12r5WwkhxJlq7x0k2RFFVGQ43T1PKTOq7pWgFkIEvrbeAVLjYyx9D1+DWgNvK6W2KKVWjbWDUmqVUqpMKVV2xouXxk+SEbUQIii09Q6SFm9d2wN8D+rztNaLgCuBe5VSnz92B631aq31Eq31kszMzDOrKm6SjKiFEEGhPVBG1Frreu+2CXgRWGplUWZELScThRCBr613wP4RtVIqQSmVNPwxcBmwy9Kq4iSohRDBob1n0PIRtS+zPrKBF5VSw/v/RWv9pqVVxadBbwtobU4uCiFEABp0e+jqHyLN7qDWWlcCZ1laxbESs81K5P1d4Ej261sLIYSvWroHAMhICoAetd8l5phtV4O9dQghxEk0dbkAyEyMtfR9AjOok4aD+rC9dQghxEk4u/oByEp2WPo+AR7UMqIWQgSuJm9QZyaF84i6W4JaCBG4hkfUGYnh2KOOTTL3pZYRtRAigDV1uUiNjyY2yro750GgBjWYmR/SoxZCBLCGDhc5FvenIZCDOilXRtRCiIBW29ZHXmqc5e8TwEGdIyNqIURAq2vvIy8tnIM6JR866sDjtrsSIYQ4TqdrkC7XUJiPqNOKwDMInfV2VyKEEMepa+sDID8t3vL3CuygBmirtrMKIYQY03BQh3frYzio22tsLUMIIcZS1+4N6rBufaTkm7UTZUQthAhAtW29xEZFWH6xCwRyUEdGQ0qeBLUQIiBVNfdQlJ6A8sOtmAM3qMG0P1qr7K5CCCGOc8DZw7SsBL+8V2AHdcZMaN5vFhAQQogAMTDk4WBrL8UZiX55v8AO6szZ0N8JnXV2VyKEECMOtvbi9miKM2VEDVklZtu01946hBBilAPObgCKM2VEDZneoHbusbcOIYQY5UhQB9iIWikVqZTappR61cqCjpKQDglZ0CRBLYQIHHsOd5GXGkeyI9ov73cqI+rvAf5PzKwSCWohREDZc7iTklz/LbztU1ArpfKBLwB/tLacMWSVgHMveDx+f2shhDhW34CbSmc3pZMDLKiB/wR+BJwwLZVSq5RSZUqpMqfTOSHFAZAzDwZ7oaVi4r6nEEKcpn2NXXg0lAbSiFopdTXQpLXecrL9tNartdZLtNZLMjMzJ6xA8habbV3ZxH1PIYQ4TeX1HQDMCbAR9XnAtUqpauAp4CKl1JOWVjVaxkyISYK6k/47IYQQfrG1pp30hBjy/XDXvGHjBrXW+ida63ytdRFwC/APrfVXLK9sWEQkTF4gQS2ECAjbDraxsDDNL/f4GBbY86iH5S2Ghl0w6LK7EiFEGGvrGaCyuYdFU1L9+r6nFNRa6/e01ldbVcwJ5S8xq7007PD7WwshxLBth9oAWFiQ5tf3DY4RdcE5Zlv9gb11CCHC2taadiIjFGcVpPj1fYMjqBMzIasUqiSohRD22VDZwtzJycTHRPn1fYMjqAGKVsChjTA0YHclQogw1OUaZNuhdpbPyPD7ewdPUE9dYS58kdkfQggbbKpqxe3RnDdNgvrEppwHKKhcZ3clQogw9GFFM7FRESya4t8TiRBMQR0/CQqWwb437K5ECBGG1u93snTqJBzRkX5/7+AJaoBZV5gpeh2y4osQwn8OOLs54Ozh4tlZtrx/cAX1zCvNdv+b9tYhhAgrf9/dCMClc3Jsef/gCurMWZA2VdofQgi/equ8gXl5KeSl+u/+HqMFV1ArBbOugqr3wdVhdzVCiDDQ1Oli28F2LivNtq2G4ApqgLlfAvcA7HnF7kqEEGHgjV0NAFxmU9sDgjGo8xab9seOZ+yuRAgRBl7YVkdJbjKzcpJsqyH4glopmH8TVK2Hznq7qxFChLCKpm4+PdTODYvybK0j+IIaYN5NgIadz9pdiRAihL24rZYIBdeeNdnWOoIzqDOmQ+G5sOVxWfRWCGGJIbeHF7fWsWJGJlnJDltrCc6gBlhyN7RWyiXlQghLvLOnkfoOF19eVmh3KUEc1KXXQnwGbH7U7kqEECHo8Y+ryUuN45IS+6blDQveoI6KhUW3w/43oP2Q3dUIIULI3oZONlS28tVzpxAZ4b+1EU8keIMaYMmdgIINv7e7EiFECHni42pioyK4eUmB3aUAwR7UqYUw70bY8hj0tNhdjRAiBBzu6OP5LXXcsDiftIQYu8sBfAhqpZRDKbVJKfWpUqpcKfVLfxTmsxU/hME+2CijaiHEmfvD+5V4tOab50+zu5QRvoyo+4GLtNZnAQuAK5RS51hb1inInAUlV8PG1dDXbnc1Qogg1tTl4q+bDvLFhXkUTIq3u5wR4wa1Nrq9T6O9D21pVafq8z+C/g746GG7KxFCBLHfrTvAoNvDvRdOt7uUo/jUo1ZKRSqltgNNwN+11hvH2GeVUqpMKVXmdDonus6Ty50P82+GDb+Djlr/vrcQIiRUNffw5IYabj67gKKMBLvLOYpPQa21dmutFwD5wFKl1Nwx9lmttV6itV6SmZk50XWO76KfgfbAugf8/95CiKD3qzf2EBsVwQ8unWl3Kcc5pVkfWut24D3gCkuqOROphbDsHtj+Fzi8w+5qhBBBZGNlC2+VN/KN86eRlWTv5eJj8WXWR6ZSKtX7cRxwCbDX6sJOy4r7ID4dXvuh3ANECOGTQbeHX7yym5xkB19fUWx3OWPyZUSdC6xTSu0ANmN61K9aW9ZpikuDy++H2s1mbrUQQozj0Q+r2HO4k19cO4e4GP+vMO6LqPF20FrvABb6oZaJMf9m2P5neOeXMPtqSLL/On0hRGA62NLLf76zn8tKs7lirn0ruIwnuK9MHItS8IWHYMgFr3wPdGDNJBRCBAaPR/OTF3cQFRHBL6+bY3c5JxV6QQ3mftWX/MLcsGnrE3ZXI4QIQGs+quKjihb+5aoSclPsWV3cV6EZ1ADLvgHFF8CbP4GWA3ZXI4QIIOX1HfzHm/u4tDSbW5cGxo2XTiZ0gzoiAq7/PUTGwPNfh6F+uysSQgSAvgE333tqO6nx0Tx4w3yUsv82puMJ3aAGSJ4M1/031G+FN35sdzVCCJtprfnJCzs44Ozm1zedxaQAuTveeEI7qAFKroHlPzDT9bautbsaIYSN1nxUzUvb67nv0pmsmGHDFdSnKfSDGuCi/2361a/dB7VldlcjhLDBxweaeeD1PVw+J5tvXRBYN10aT3gEdUQk3LAGknPhLzebRXGFEGHjs8YuvrF2C8UZCfz6pgVEBMDyWqciPIIaICEdbnve3LjpyZWyIowQYaKhw8UdazYRGx3Jmq+dTWLsuNf5BZzwCWow86tvfcrcCvWvN8NAj90VCSEs1Oka5GuPbaKjb5DH7zw7oBYDOBXhFdQAhcvghj9C3RbTBhnotbsiIYQFulyD3LFmExVN3Tzy1cXMmZxid0mnLfyCGqD0WvjiH6D6Q3jqVhh02V2REGICdfcP8bXHNrOjtoP//vLCoJrhMZbwDGqA+TfB9b+Dyvfh6dvMArlCiKDX0z/EXY9tZvuhdv7r1oVcMTfX7pLOWPgGNcCCL8M1D0PFu+YEo6vD7oqEEGegtWeA2/64kS0H23j4lgVcNS/4QxrCPagBFt9hetaHNsDjV0O3n9d7FEJMiNq2XlY+8jG7D3fyu9sWcfX8yXaXNGEkqAHmrYRbn4aWClhzmdzESYggs6+hi5W//wRnVz9r71rK5XMC997Sp0OCetiMS+D2v5n2x/9cBFXr7a5ICOGDdXubWPn7j/FozTP3nMuy4nS7S5pwEtSjFSyFr78LSTmw9otQtsbuioQQJ6C1ZvX6A9z1xGYKJsXz4r3nUZKbbHdZlpCgPtakqXD332HaRfDqD8xDpu8JEVD6Btzc98ynPPD6Xq6am8tz3zyXvNTAvvn/mQi+ayn9wZFsrmB895fw0cPm4pgbnzAhLoSwVUVTF/f+eRv7Grv44aUz+c5F04PintJnYtwRtVKqQCm1Tim1RylVrpT6nj8Ks11EJFz6byaw22rgD+fDnlfsrkqIsPb8llqu+a+PaO7u54m7lvLdi2eEfEiDb62PIeA+rXUJcA5wr1Kq1NqyAsisK+Ge9ZA+DZ7+Crz8XejvtrsqIcJKp2uQHz6znfue/ZT5+Sm8/r0VnD8zuK82PBXjtj601oeBw96Pu5RSe4A8YLfFtQWOtClw15uw7gHTCql6H65/BKaca3dlQoS89fud/Pj5HTR19fPdi2fw3YumExUZXqfXTulolVJFwEJg4xivrVJKlSmlypzOELxoJCoWLv0l3PmGef7YlfD3n8ul50JYpKd/iJ++uJPb12wiPiaS57/5OX546cywC2kApbX2bUelEoH3gfu11i+cbN8lS5bosrIQXkmlvxve/ilseRwmFcMXfgPTLrS7KiFCxrp9Tfz8b7uobevj68unct9ls3BER9pdlqWUUlu01kvGes2nf5qUUtHA88CfxwvpsBCbaO4RcscrgIK118MLq6Cn2e7KhAhq9e19fGPtFu58bDMxkRE8c8+5/PQLpSEf0uMZt0etzCnVR4E9WuvfWF9SEJn6efjmx/DBr+HDh+Czt+Gin8Gir0GkzHwUwleDbg+Pf1TNQ+/sx6M1/+vyWfzTimJiosKvzTGWcVsfSqnlwAfATsDj/fS/aK1fP9HXhHzrYyzOfWbx3OoPILMErnjAXDQjhDghrTXr9jXxwOt7qWjq5uLZWfzi2jlBuxLLmThZ68PnHvWpCMugBtAa9r4Kb/8M2qph5pVw2f8xS4AJIY6yq66DB17fw8cHWijOSOAnV5VwSUlWWMyLHsvJglr+fz6RlIKSa2DGZbDxEXj//8Jvl8LC2+D8H0NKvt0VCmG7uvY+fvP2fl7YVktqXDS/vHYOX15WSHQYzubwlYyordTdZPrXwzd3WnI3rLgPEsNnor4Qww539PHbdRU8vfkQSinuPK+Iey+cTrIj2u7SAoK0PuzWfgjefxC2/wWiHHDON+CceyEh9G7HKMSxGjtd/G5dBX/ddAiN5sYlBdx74fSQvonS6ZCgDhTNFfDeA7DrBYiOg8Vfg3O/DSl5dlcmxISra+/jf9ZX8pdNB/F4NCsX53PvhdPD8kShLySoA41zH3z4n7DjaVARcNYtsPwH5n4iQgS53fWdrF5/gFd2HEYBX1yYx3cumkFhugT0yUhQB6r2g/Dxf8HWP8FQP5RcDcu+CVM+Z05MChEktNZ8cqCFR9ZXsn6/k4SYSG5ZWshdy6dKi8NHEtSBrrsJNvwetjwGfW2QM88E9twbINphd3VCnFDfgJuXP63jT5/UUF7fSUZiLHeeV8RXlk0hJV5OEp4KCepgMdALO5+BDY+Acw/EZ8CSO81skeTQWPZehIbq5h6e3FDDs1tq6egbZHZOEl/7XBHXL8wL+8u9T5cEdbDR2txKdcMjsP9N08eeeTksugNmXGoWNRDCz9wezXv7mvjTJzW8v99JVITi8rk53HFuEWcXpYXthSoTRS54CTZKQfEF5tFaCVuegO1/hn2vQ3IeLPwKLPwqpBbYW6cIC1XNPTxbdogXttbR0OkiKymW718yg1uXFpKdLK05f5ARdbAYGoD9b5jQPvAP87npF8NZt8KsqyBGzqiLidPTP8RrOw/zbNkhNle3EaHggllZ3Lg4n0tKs+UqQgtI6yPUtNXAtifNKLuzDmKSoPRamH8TFK2Q1og4LW6PZkNlCy9tq+O1nYfpHXBTnJHAjUsK+NKiPBk9W0yCOlR5PFDzIXz6NOz+Gwx0QdJkmH8jzL8Zskplmp84Ka012w618/L2el7beRhnVz8JMZFcPX8yN52dz6JC6T37iwR1OBjsMz3sHc9AxTvgGYKMmVB6Pcy5XkJbHGVvQycvb6/nlR31HGrtIyYqgotmZXHtgslcNDtLZm7YQII63PQ0Q/mLZpRd8xFoD6TPMIFdej1kz5HQDjNaa3bWdfBWeQNvlTdS0dRNZITivOkZXHvWZC6bky03R7KZBHU4626CPa/A7peg+kNvaE83t2OddRXkLZaedogacnvYXN3GW+UNvF3eQH2Hi8gIxbKpk7hybg5XzcslPTHW7jKFlwS1MLqdsPcVKB8ObTckZJo52jOvNAv0xiTYXaU4A70DQ3xc0cJb5Q28s6eRtt5BYqMiWDEjk8vnZHNJSTZpCTF2lynGIEEtjtfXBhXvmr72Z+9AfwdExkLx+TDrSph5BSRPtrtK4YPq5h7W7Wti3T4nGypbGBjykBQbxUUlWVw+J4fzZ2aSECuXTAQ6CWpxcu5BqPnYXAW59zVorzGfz55r1n2cfjEUngtR8t/kQNA/5GZTVSv/2NvEe/ucVDX3AFCcmcCFs7K4YFYmy6amy8KwQeaMgloptQa4GmjSWs/15Q0lqIOY1uDca0K74l04uAE8gxAdD0XLYdrFJrjTp8sJST/RWnPA2c2HnzXzYUUzH1W00DfoJjYqgnOnpY+E85R0aVsFszMN6s8D3cCfJKjDUH+3WVm94l048K65pB0gpRCmXwRTzzcX2cjyYhOqocPFRxXNfFRhwrmpqx+AwknxXDArkwtnZXFOcTpxMXIiOFSc0b0+tNbrlVJFE12UCBKxiaZnPetK87y1ylzCfuAfsPN52PK4+XxmCUxdYUK7aDnET7Kt5GDU0TfIhsqWkXA+4DTtjPSEGM6dls7y6RmcNz1DVkcJUz71qL1B/erJRtRKqVXAKoDCwsLFNTU1E1SiCFjuITi8HarWm1H3wQ0w2Aso098eDu4pn4O4VLurDSjOrn42V7eyqaqVjVWt7G3oRGuIj4lk6dRJLJ+eweemZTA7J4mICGkxhYMzPpnoS1CPJq2PMDU0APVboeoDqF4PhzbBkMvcpjVrDhSec+SRkm93tX6jtaa2rW8kmDdVtVLpPQEYFx3JoimpLC1K55ziSSwsTJOTgGFKglrYY6gfajebOdsHP4HaMhjoNq8l50PhMjObpGCZuVoyRC68GXJ72NvQxbZD7WzxhnN9hwuAZEcUZxdNYulU85iblyJ3ohOA3I9a2CUq1vSri5ab5+4haNwFhzaa4K75GHY9b16LSYKCs6HgHLOdvCho2iXN3f1srWlj26F2tta0saO2g75BNwAZibEsmzqJe7zBPCtbWhni1Pky6+OvwAVABtAI/KvW+tGTfY2MqIVPtDYL/A4H98GN0LQb8P5Opk+HvCXmMve8xZAz1/a53INuD3sOd7LtYDtbD7ax7WA7B1t7AYiKUMyZnMzCwjQWFqayqDCN/LQ4ufuc8Ilc8CKCR1871G+Dui1QtxXqyqC70bwWGWMW/s1bfCTA06dZNp97yO3hgLOHHbXt7KrrYEddB7vrO+kf8gCQnRzLolGhPDcvRe46J06bBLUIXlqbxRHqtpged91WE+SD5mQcjhTIPcv7WGC2k6ZBxKn1fd0eTaWzmx21HeysM4/d9Z0jLYyEmEjm5qUwLy+FBd5gzk1xyGhZTBjpUYvgpZSZIZKSD6XXmc953Obqybot5nH4U9i4GtzmohBiEs3IO2f+kRDPnAWR5jaeg24PB5zd7Dncyc7aTnbWtVNe30nvgAnl+JhI5kxO5talhczPT2FuXgrFGQnSWxa2kRG1CA3uQXDuM6E9/GjYOTLyHoqIoT6mmF2eIjb05bFrqIB9ugB3dAJzJpuR8ry8FObnp1CcmUikhLLwMxlRi5DnUVFURxaxJzKdPZFL2B3ZyT7VhqO/mjmqmrkR1SzUNZzPh1wV2Q3eVrJOnYJKnQuJpeCYAxFzgGmM7CBEAJCgFkFFa01Dp4v9jd181tjF/sYu9jd2s6+ha6SfHBmhmJaZwNnFmZTkTqMkN5mS3GQyk2K9M01qoHE3NJWjGsuhsdys8K7NSUKiHJA528ztHn5kzZH7mQjbSOtDBCStNc6ufvY3drO/sYvPmrrY19DFZ03ddLmGRvbLSIxhRlYSs3OTKMlNpjQ3melZiac++2Kwz7ROGsvNFMHGXSbMe5qO7JOQaQI8c7bpeQ9/nJAhdxIUZ0xaHyJgaa1p6urnQJMJ5P1NwyPlbjr6Bkf2S4uPZkZ2EtctmH7eHuwAAAs+SURBVMys7CRmZCcxMzuJSRO1Wkl0HExeYB6jdTeNCu/d5iTmjqehv/PIPnFpx4S3d5uUKwEuJoQEtfAL16Cb6pYeDjT1UOns5oCzm8rmHiqdPXT3Hxkhp8RFMzM7kS/Mz2VmViIzvaGckRhjz1S4xCzzmHbhkc9pDV2HTWg79x3Z7v4b9D1+ZL/YZG9oz4KMWWZV+PTpkDZlZAaKEL6Q1oeYMMPtigpnN5XOHhPG3m1dex+jf9UmpziYlpVIcUaCd5vIjOxEspJig3dustZmBXjn3uNDfHQLJSIK0opMaB/7SMqRUXiYktaHmDBaa9p7B6lu6aGmpZfqlh6qm3vGHB3HRUdSnJnAwsI0Vi7OpzgzkWmZCUzNSCA+JgR/9ZQyJxwTM80tXkfrbYWWA9BSAS2febcHoPI9c4fBYTGJ5mrL9OmQPsO79T53JPv1cETgCMG/LeJMaa1p7h6gpqWH6pbeo7fNPXSOOpmnFExOiWNqRgI3LMrzhnEixZkJ5CQ75CKRYfGTzKPg7KM/7/GYKy9bKo5+1JbBrhcYue8JQGI2pE2FSVOP38any0g8hEnrI0x5PJrGLhc1xwWx2fZ4r9IDiFCQnxbPlPR4itITmJIez9SMBKakJ5CfFif3t7DKoAvaqkeNwCugtRraqky4jxabbNopY4V4cl7I3EI2lEnrIwxprWnrHeRQay+H2no51Nrn3fZS19ZHbXsfA96bCwFERyoKvGG8dOokitLjmZKRQFF6AnmpcXIzeztEOyBrtnkca9Bl5oO3Vpl1LNuqzMeN5bD3dbMg8bDIGEidcnR4p06B1ELzkJZKwJOgDmI9/UNHQnhUINd6A3n0qBggNT6agrR4ZucmcWlpNvmT4inyjpJzUxxEyQ3sg0e048iMkmN53GbE3Vp1JMDbvIFe8wkMdB29f1zakdBOnXJ0iKcWmnUzha0kqAOU1ppO1xD17X0jj9r2Pmq9I+Patj5aewaO+pq46EgKJsVRkBbPOcXp5KfFUTApnoK0eAomxZHkkClhYSEi8kjIcv7Rr2kNvS1mNN5+8MijrQac++Gzd2Co7+iviZtkvlfalFFhPirIYxL8dmjhSoLaJoNuD42dLurbXdS391HnDeO6kWB2HTWDAkx7Ii/VhO+cySmjgths0xNsmmssgodS5krKhAxzP+9jDU8xbD8I7dVHh3nTHtj/1tGzVMCcyEzJh5QC0w9PyYeUvCPPk3KkR36GJKgt0tE3eNRouM4byMNh3NjpwnPMedy0+Ggmp8YxJT2Bz03LYHKqg7zUeO82jozEWJlFIaw1eoph/hhB7vFAj9Mb3jVHth11prVStf7oqzYBVCQkTzYBPhLk+Uc/j0uTWSsnIUF9ijweTWvvAA0dLvPoHHs71mg4NyWOyakOzp2WTl5qHJO9D/OxIzTnFovQEhEBSdnmcexUw2GuDhPcHbXQWWu2w8/ryswVnKNPdgJExx8f5Ml5kJwLSZPN1pEatmEuyTDKoNtDU1c/DR19NHT0c7jDjHwPd7hGtk2d/Qy4PUd9XYSCrCQHOSkOpmcmsny6GQ0PB3G+jIZFOHGkmEd26divD4/KjwvyQ+Yk6GdvH1l+bbSouKODOynXjNRHb5NyQvLy/LAI6uGr6Zq6+mnqMmHb0Ok6LoSbu/s5dlp5bFQEuSkOspMdLJmSRnaKg9xkE8o5KXHkJDvISIyRGRNC+Gr0qJwx2isAQ/3mfiqdh6Gr3rs9DJ31Zntok9m6B475QmXucnhUoI8R7I6UoBqd+xTUSqkrgIcxd1P/o9b6V5ZW5SOPR9PSMzASvke25uPGzn6cXeZx7CgYzA2AcryhW5KT7A1f7yPZQW6Kg5S4aDlBJ4S/RcWaC3jSik68j9bm0vyRID9m23HIrHDf13r810bHmys9k3JOss0xV5MGwN//cYNaKRUJ/Ba4FKgFNiulXtZa77aqqEG3h+bu/qNCd6wgbu4ewH3sGTnMfOGspFiykhwUZySQmWw+zkqKJTvZbLOSY6UnLEQwUwoS0s0jZ96J9xt0mdH36BF552HoboCuRnPv8Yp3j59fDhAR7Q3ubBPcJ9omZEKkdXniy3deClRorSsBlFJPAdcBExrUWmuu+e8Paehw0dIzcFwLQilIT4gh0xu4s3OSTOgmx5KVFDvy+cykWLmkWQhxRLTDXI05aerJ9xvoga4G0x8fa9tWBQc/GXuEriIgPsPcQOuuNyf8EHwJ6jzg0KjntcCyY3dSSq0CVgEUFhaeciFKKWZkJTEvL3VkxDt6FJyeGEO09IGFEFaJSfDeqXDayfcbGjDhPRLk3pF5d4NlpfkS1GM1aI7rN2itVwOrwdyU6XSKeejmBePvJIQQdoqKgdQC8/ATX4aotcDoivKBemvKEUIIcSxfgnozMEMpNVUpFQPcArxsbVlCCCGGjdv60FoPKaW+DbyFmZ63RmtdbnllQgghAB/nUWutXwdet7gWIYQQY5BpFEIIEeAkqIUQIsBJUAshRICToBZCiABnySrkSiknUHOaX54BNE9gOcFAjjn0hdvxghzzqZqitc4c6wVLgvpMKKXKTrRkeqiSYw594Xa8IMc8kaT1IYQQAU6CWgghAlwgBvVquwuwgRxz6Au34wU55gkTcD1qIYQQRwvEEbUQQohRJKiFECLA2RbUSqkrlFL7lFIVSql/HuP1WKXU097XNyqlivxf5cTx4Xh/qJTarZTaoZR6Vyk1xY46J9J4xzxqv5VKKa2UCvqpXL4cs1LqJu/Pulwp9Rd/1zjRfPjdLlRKrVNKbfP+fl9lR50TRSm1RinVpJTadYLXlVLq/3n/PHYopRad8Ztqrf3+wNwu9QBQDMQAnwKlx+zzLeAR78e3AE/bUasfj/dCIN778TeD+Xh9PWbvfknAemADsMTuuv3wc54BbAPSvM+z7K7bD8e8Gvim9+NSoNruus/wmD8PLAJ2neD1q4A3MKtjnQNsPNP3tGtEPbJgrtZ6ABheMHe064AnvB8/B1ysVACs2356xj1erfU6rXWv9+kGzEo6wcyXnzHAvwP/Abj8WZxFfDnmfwJ+q7VuA9BaN/m5xonmyzFrINn7cQpBvkKU1no9MMYKtyOuA/6kjQ1AqlIq90ze066gHmvB3LwT7aO1HgI6gHS/VDfxfDne0e7G/IsczMY9ZqXUQqBAa/2qPwuzkC8/55nATKXUR0qpDUqpK/xWnTV8OeZfAF9RStVi7mv/Hf+UZptT/fs+Lp8WDrCALwvm+rSobpDw+ViUUl8BlgDnW1qR9U56zEqpCOAh4Gv+KsgPfPk5R2HaHxdg/tf0gVJqrta63eLarOLLMd8KPK61/rVS6lxgrfeYPdaXZ4sJzy67RtS+LJg7so9SKgrzX6aT/XcjkPm0QLBS6hLgp8C1Wut+P9VmlfGOOQmYC7ynlKrG9PJeDvITir7+Xv9Naz2ota4C9mGCO1j5csx3A88AaK0/ARyYmxeFqglfENyuoPZlwdyXgTu8H68E/qG9nfogNO7xetsAf8CEdLD3LWGcY9Zad2itM7TWRVrrIkxf/lqtdZk95U4IX36vX8KcOEYplYFphVT6tcqJ5csxHwQuBlBKlWCC2unXKv3rZeB27+yPc4AOrfXhM/qONp45vQrYjzlj/FPv5/4N85cVzA/zWaAC2AQU23221+LjfQdoBLZ7Hy/bXbPVx3zMvu8R5LM+fPw5K+A3wG5gJ3CL3TX74ZhLgY8wM0K2A5fZXfMZHu9fgcPAIGb0fDfwDeAbo37Gv/X+eeyciN9ruYRcCCECnFyZKIQQAU6CWgghApwEtRBCBDgJaiGECHAS1EIIEeAkqIUQIsBJUAshRID7/y3Ftq/vED8kAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# This will produce errors because log(0) is infinity; we can just ignore them for now\n",
    "sigmoid_values = np.linspace(0, 1, 1000)\n",
    "plt.plot(sigmoid_values, error_0(sigmoid_values), label = \"$error_0$\")\n",
    "plt.plot(sigmoid_values, error_1(sigmoid_values), label = \"$error_1$\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These error functions not only work. They have an **additional property** that makes them special. Focus on $error_0$ for  example. Besides being $0$ when the predicted class is $0$, it's also equal to $\\infty$ when we get the class totally wrong.\n",
    "\n",
    "That's how you punish an algorithm for being wrong :)!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One more question: how do we decide whether we should use $error_0$ or $error_1$? We look at the original $y$ (`exam_result` in our case). If $y = 0$, we'll use $error_0$ and vice versa. This will combine our two error functions into one convenient error function.\n",
    "\n",
    "Write this convenient function. It should accept an input value $z \\in (-\\infty; \\infty)$ and an expected output value $y$ (0 or 1).\n",
    "\n",
    "First, it should pass $z$ through the sigmoid function to get $\\sigma(z)$. After that, based on $y$, it should choose the correct function and return the error.\n",
    "* If $y = 0$, return $error_0(\\sigma(z))$\n",
    "* If $y = 1$, return $error_1(\\sigma(z))$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "cc16f57595525e68013d968698083505",
     "grade": false,
     "grade_id": "cell-d34ce23b84cd1dcc",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "def get_error(z, y):\n",
    "    sigmoid_result = sigmoid(z)\n",
    "    return error_0(sigmoid_result) if y == 0 else error_1(sigmoid_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's test this function to see that it works. If we pass a negative value for $z$, the sigmoid function will be approximately zero, so it predicts class 0. If $y = 0$, congrats, we have almost zero error. If $y = 1$, we'll get punished."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "89062b5cdfbcf4dba13ac0e4f80d59e4",
     "grade": true,
     "grade_id": "cell-78e4aee5f7010ec8",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.539889921682063e-05\n",
      "10.000045398899218\n"
     ]
    }
   ],
   "source": [
    "print(get_error(-10, 0)) # Almost zero\n",
    "print(get_error(-10, 1)) # Very large (approximately equal to 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 6. Calculate the Cost Function from the Error Function (1 point)\n",
    "Now, we have an error function which accepts a real number $z$ and an expected class and returns the prediction error. Now we have to repeat what we did in step 4 and rewrite the entire thing to use $x$, the input value.\n",
    "\n",
    "That's really simple. We should just take $x, y$, and the parameters $a, b$. All four parameters are real numbers. From them, we need to calculate $z = ax+b$. This $z$ is what we need to pass to `get_error(z, y)`.\n",
    "\n",
    "Write a function that does this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "4785d979c0b59107942400db95703c4d",
     "grade": false,
     "grade_id": "cell-7da0ed8e17557d5e",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.006715348489118056\n"
     ]
    }
   ],
   "source": [
    "def compute_error_function(a, b, x, y):\n",
    "    z = a * x + b\n",
    "    return get_error(z, y)\n",
    "    \n",
    "print(compute_error_function(-5, 0, 1, 0)) # Should be about 0.007"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The total cost function is the sum of all errors. Write a function that accepts `data_x` and `data_y` - arrays of points, and also `a` and `b`. For each point, compute the error function. Sum all error functions to get the total cost."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "350e8521e233ebcc96caa3edce3efcf0",
     "grade": false,
     "grade_id": "cell-f6a7f0ad3bb7f5a8",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "def compute_total_cost(a, b, data_x, data_y):\n",
    "    z = a * data_x + b\n",
    "    zipped = zip(z, data_y)\n",
    "    total_cost = 0\n",
    "    for predicted, expected in zipped:\n",
    "        total_cost += get_error(predicted, expected)\n",
    "    return total_cost"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's go back and see what total costs we should get. We saw that the last function approximation looked most reasonable. It should have the smallest error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "f808a100908c88a00becb0ea81a7e02a",
     "grade": true,
     "grade_id": "cell-aefbf00d7ba63fa2",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEICAYAAABPgw/pAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nO3deZgU5bn38e89M2zKqoDKJsQgHuKCyiuJxhyXRNCjoMYoGJccEzXGJXnjqweiR3PMYo4kxuTo0eC+EIUgwqgYFDHGuERHiRogIMGogMjIKjAsM3O/fzxFbHp6umuGnqnunt/nuuqa7qpnqu+umfl1zVNPVZm7IyIixa8s6QJERCQ/FOgiIiVCgS4iUiIU6CIiJUKBLiJSIhToIiIlQoHexplZRzNzM+uXdC0ismsU6AXIzDamTPVmVpPy/Os5vneUmS1prVqbysweMbNrm9B+/7TtsTH6ALo0y/ccYWYvRm0/NLNL4qzLzMrM7L/M7AMz22BmD5rZ7mnrPtHM/mJmm8zsfTMbE83/nJk9YWbVZrbGzJ40s/0y1GZRbbVp8//bzP5qZnVmNj5t2ajo9yC17rNSlk81s5VRzX8zs/NSlh1tZnOjmqrN7GEz652yvJOZ3W1mq8xstZnNMLO9Y657mJm9YWZro/XPNrP946zbzDpk+FnUm9nExn6uEoO7ayrgCfgH8OUmtB8FLGlC+46AA/1a6f08Aly7C99/AFAL9Glk+T5ANXAm0B7oChwQZ13AxcDbQJ/o+54CfpPSfhiwEvgyUA70AgZFy44Czgd6RK97E/CXDK/5TeCPQG3a/AuAkcDvgfFN+ZkCnwPapzyuBg6Mnp8CnA50AXYHJgMzUr73OqAqei+dgCnAb2Ouew9gX8CACuAq4NW46057D92BGuCI1vg9LNUp8QI05fgBZQj06I/jNuBDYBkwEWgH7Bn9UdQDG6Npzyhs/gysB1YAvwQqonVlDXSgJ/BAFGRrgSkpyy4F/g6sBqYDe0Xzy4Fboz/+9cCbwBDgCmA7sDWq7XfN2B43Ak9lWX4zcGdz1gU8AVye8vy4qM4dgTYduCbmuvtE23X3lHl7AouBL5IW6CltptHEQE9rOxT4GBjdyPIjgeqU5/cCN6Q8/yrwZlPXHQX694E1zVz3xcDCJP7GSmlSl0tx+i/gYOAg4HDgGOBqd18NnAYsdffO0bSaEKKXEfaojibstX0r5mtNIeyBHQDsRfggwcxOAv4zer2+hD/0h6LvOTmqaz/CHuvZwFp3/zXwKPCjqLavReu628xuzlWImZUB5wD3Z2n2eWCDmb0a/as/w8z6xlyXRVPq892BQSnrrjCz+VFXzv1m1q2ROr4EvOfum1Lm3UT4MP04S/2N6W9mH5nZUjObaGad0t7P3WZWA8wnfMg+k6Wu+SnP7wSOMbO9zawzMI7wn0msdUddJ+sIH9ITCR+Ssded4nyy/1wljqQ/UTRln8i8h74cOC7l+Rjgb9HjnHtzwHjg4ehxo3vohCDbBnTJsGwyO+99dSf8Z7A3cBLhj/8IwNK+r9ldLsBXgHVAxyxt3icE5qHRe/sN8GycdRE+9OYD/QkfRL+Pts2hhP866oF3gM8QumQeB+7OsO6BhP9oTk+ZdySh+6GMqKunkfoz7aH3ib6nDPgs8DLwqwzfWw78K/ADoDzD8sMJ/2WNSJnXg/Ah60Ad8BrQtRnr7kL4D+yEZqx7MKHrq2/Sf2/FPmkPvciYmRFC872U2e8R9pIb+56hZvZUtIe3gdC32TPGy/UHVrn7JxmW9Umtwd3XARuiOp4C7iaE6Udm9r/RHtquOp/Q5bMlS5saQlfOvKjdDcCx6Xu0jazrdmAm8CLwFp/uiS5z9zrCh9td7r7U3TcAPyN8eP1TdNDvaWCiu0+P5pUD/wtc5u71TX3T7r7C3f/m7vXuvgSYAJyRoV2duz8P7E/oq0+t618IXUoXu/ufUxbdRQjTPQj/jcyO2sVed7T8E+AOYIqZ9WjKugk/i2fdfXnjW0HiUKAXGQ+7NCsJB6N2GEDYa4ewN5TuTuANYD9370oIOcvQLt0HQO9GwnhFag1R10NXYLkHN7v7oYSuoUOA72apLycz60Lo3sn1b/lbGV5jp+eNrSsKrR+4+wB370/YG3/X3aujJm9nq9/MegJzCAf+fpGyqBehe2yGma0EXgDKo9EjR+R4P5k42X9+FYTurh117Uf4cPqBu09Na3sIcI+7r40+3G4Fjs7yAbzTutOUEfbUd4ySybnuaAflXNTdkhcK9OL0MHC9me0ZDUG7hk/7rz+iYQh3Ada7+0Yz+xxwYZwXcfd3CSMybjWzbmbW3sy+lFLDhWZ2oJl1BP4bmOvuK83s82Y23MwqgE2EPdu6lPo+04z3/DXCh8VLOdrdC5wZ1dWesG3muntNrnWZWS8zGxgNLTyI0Of9w7R1f8vMBlgYzngV0R5ntFf6DPB7d0/9HoBVhP9chkXTaYTtMQyYF31/u2g7lhH66TtG/fyY2XEWnSdgZvsCPyX8J4GZ9TGzM8xsdzOrMLOTCQcf56a0nwv8t7vfm2F7vQZ8w8y6RNvrEsKH2MYY6z7RzA42s/LoA/0Wwgf9O7nWnfL6xxK66x7LUJs0VdJ9PpqyT2TuQ9+N0D2wkvAHdDOfjsQwQrivJvQR7wEcTxhdsRH4AyEQ5kTtc41y6UXoL18FrCHqe4+WXQEsjebPAPaJ5o8C/hq9XjVwH7BbtGwoYU93HfBINO8+4JYc2+F5MowwIQwh/Dht3nej7bKGEBR9Yq7rQEIYbQbeJWXES8q2vTHatqsIAd81WnZxtB03pk29M7xOgz50wrEFT5vGRssmRO9nM+EYwc1Eo2cIXV8vEEYT7RhR9I2U9d6Yoa6PU5b3Jhz4ro5+Js8Dh8Zc99ej36tN0faoBIbGWXdKm/uJOSpJU+7Joo0qIiJFTl0uIiIlQoEuIlIiFOgiIiVCgS4iUiIqknrhnj17+sCBA5N6eRGRovT6669/7O69Mi1LLNAHDhxIVVVVUi8vIlKUzOy9xpapy0VEpEQo0EVESoQCXUSkRCjQRURKhAJdRKREKNBFREqEAl1EpEQo0EVESkTOE4vM7B7CTX9XufuBGZYb8CvCrbg2E66X/Ea+CxVpihnzljNx9iJWrKuhT/dOXDVyCKcemvkufU1pW0wyvS8gb+8123bLxzZNXUe3Tu0wg3Wbt5fUzyjfcl4PPbpDzUbggUYC/STgckKgjyDcvHZErhcePny460xRaQkz5i1nwvS3qdle9895ndqVc+PpBzUIgaa0LSaZ3le7cgOH7fWf/s03971m227ALm/TTOtPVQo/o+Yys9fdfXimZTn30N39j2Y2MEuTMYSwd+AVM+tuZvu4+4fNqlZkF02cvahBENRsr2Pi7EUNAqApbYtJpve1va7hzltz32u27bbjcfqym2fN59QBHWHzZti0qeHXHY+3beOD38/nG5u20K6uloq6WtrXh68V9XW0r6ulor6WTk84DOkJ9fX5mXbs3Db2NduyOG1SH//whzB2bFM2eSz5uJZLX8LNhHdYFs1rEOhmdhFwEcCAAQPy8NIiDa1YVxN7flPaFpOm1N+c97piXQ2406NmA3tvXM1en6xhr42r2fuT1fTetIZuNRvpvuUTum/ZSPeaT+i25RO6bKuBa+Ot//KUx3VWRm1ZOdvKK6gtq6C2vJxtZe2oLS+HzV2hvBzKyuJPFRUN55mFrzuYZf6abVmcNjse77lnvA3RRPkI9Ex3H8/Yj+Puk4BJELpc8vDaIg306d6J5RlCqk/3TrvUtpg09r4aa5vV9u2wcCG8+SYsXgyLFzP7hTfo+/Eydt++pUHztbt3Y3WHLqzr1IWVnfdgUc8BrO/YhfoePfjWyYfC7ruHabfdPn284/luu0GHDnzl1pd5/5PtbC8rp76sPGNZfbt34sXxx8V6j21FPgJ9GdA/5Xk/wg1tRRJx1cghGftwdxwUbG7bYpLpfTXWh97gva5YAX/4A7zwArzxRgjyrVvDsrIyGDSIrp8ZwKP9Psc/uvRmZZc9Wdl5T9b36MUV534Jb9e+8f71mF07l44+lAnT36Y+Sx96sf+MWkI+Ar0SuMzMHiEcFF2v/nNJ0o7+4DijLJrStpg09r4yzTv1wN7wzDMwYwbMmRP2wgG6doXDD4fLLoPDDoNhw+Czn4X27dkb6DpvObPT1jUmZbvtyjZNr1+jXOKJM8rlYeAYoCfwEXA90A7A3e+Ihi3eCowiDFv8d3fPOXxFo1xEElRfD3PnwgMPwOOPw7p1odvj2GPhmGPCNGxY6J+WgrKro1zG5VjuwKXNrE1EWlN1NUyaBHffDe++C927w5gxcPrp8JWvQKfiPnbQ1iV2xyIRaUXvvQe/+AXcdRfU1MBxx8FPfgKnnQYdOyZdneSJAl2klK1ZAz/6Edx2WxgDfe65cPXVcMABSVcmLUCBLlKK6urg9tvhuutg/Xq44ILwuH//3N8rRUuBLlJqFi0KAf7SS3D88XDzzXDwwUlXJa1AV1sUKRXu4YDnsGGwYAHcf38YjqgwbzO0hy5SCjZtgksugQcfhBNOgPvug332SboqaWUKdJFit2IF/Nu/hTM6b7gBrrlm5+uSSJuhQBcpZgsXwqhRYTTLk0/CiScmXZEkSIEuUqxefz2cDNShAzz/fDg9X9o0BbpIMZo3L4R5t27hFP5Bg5KuSAqAAl2k2Lz9dgjzzp3huedg4MCkK5ICoSMnIsVkxYrQT96hg8JcGtAeukix2LQJTjklnPn5pz/BfvslXZEUGAW6SDGor4dzzoG//CVc7vaQQ5KuSAqQAl2kGEycGG5A8atfwUknJV2NFCj1oYsUuhdfDCcLnXkmXH557vbSZinQRQrZ6tUwdmw4+HnnnTvfPV4kjbpcRArZJZfAqlXw8svhHp8iWSjQRQrVo4/C734HP/2pzgKVWNTlIlKIPv4YvvMdOPxwuOqqpKuRIqE9dJFC9L3vwdq14XrmFfozlXi0hy5SaJ5/HiZPhvHjdXMKaRIFukghqa2FK66AffeFCROSrkaKjP6XEykkd94Jb70VDoZ26pR0NVJktIcuUijWrIFrr4Vjj4WvfjXpaqQIKdBFCsVPfwrr1oXT+3UCkTSDAl2kECxfDrfdBueeCwcdlHQ1UqQU6CKF4Mc/hro6uP76pCuRIqZAF0na0qVw111w4YW6lZzskliBbmajzGyRmS0xs/EZlg8ws+fMbJ6ZvWVmur6nSFw33BBOHrrmmqQrkSKXM9DNrBy4DTgRGAqMM7Ohac2uBaa6+6HAWOB/812oSEn6xz/goYfCRbj69Em6GilycfbQjwCWuPtSd98GPAKMSWvjwI5LwXUDVuSvRJES9vOfQ1kZXHll0pVICYgT6H2BD1KeL4vmpfohcI6ZLQNmARmvwm9mF5lZlZlVVVdXN6NckRKyahXcfTecdx70Tf+TEmm6OIGeaUCspz0fB9zn7v2Ak4AHzazBut19krsPd/fhvXr1anq1IqXk17+GrVt1NUXJmziBvgzon/K8Hw27VL4JTAVw95eBjkDPfBQoUpI++SSMOz/9dBgyJOlqpETECfTXgMFmNsjM2hMOelamtXkfOB7AzP6FEOjqUxFpzH33hbNCr7466UqkhOQMdHevBS4DZgMLCaNZ5pvZDWY2Omp2JXChmb0JPAx8w93Tu2VEBKC+Hm69FUaMgCOOSLoaKSGxrrbo7rMIBztT512X8ngBcFR+SxMpUc88A4sXh+GKInmkM0VFWtutt0Lv3nDGGUlXIiVGgS7SmpYuhSefhIsvhg4dkq5GSowCXaQ13XYblJfDt7+ddCVSghToIq2lpgbuuScMVdRp/tICFOgirWX69DBU8eKLk65ESpQCXaS13HNPuDzuMcckXYmUKAW6SGtYuhTmzoULLggX4xJpAfrNEmkN994bgvwb30i6EilhCnSRllZXF071HzkS+vVLuhopYQp0kZb29NOwbFnobhFpQQp0kZZ2773QsyeMHp27rcguUKCLtKT166GyEsaNg/btk65GSpwCXaQlPfZYuInF17+edCXSBijQRVrS5Mmw3366TK60CgW6SEv58MMw9vzss8Ey3clRJL8U6CItZcqUcDOLs89OuhJpIxToIi1l8mQ47DA44ICkK5E2QoEu0hIWL4aqKh0MlValQBdpCb/9beg3Hzs26UqkDVGgi+SbOzzySLiqoq57Lq1IgS6Sb/Pnw6JFcOaZSVcibYwCXSTfpk0L3S2nnZZ0JdLGKNBF8m3aNPjSl2CvvZKuRNoYBbpIPi1cGLpczjgj6UqkDVKgi+TTo4+Gr6efnmwd0iYp0EXyado0OOoojW6RRCjQRfLlnXfgzTfV3SKJUaCL5Iu6WyRhCnSRfJk2DUaMgAEDkq5E2igFukg+LF0Kr7+u7hZJVKxAN7NRZrbIzJaY2fhG2pxpZgvMbL6Z/Ta/ZYoUuOnTw9evfjXZOqRNq8jVwMzKgduArwDLgNfMrNLdF6S0GQxMAI5y97Vm1rulChYpSJWVcMghMGhQ0pVIGxZnD/0IYIm7L3X3bcAjwJi0NhcCt7n7WgB3X5XfMkUK2Mcfw4svwujRSVcibVycQO8LfJDyfFk0L9X+wP5m9qKZvWJmozKtyMwuMrMqM6uqrq5uXsUiheaJJ8Kdicak7+eItK44gZ7pZoie9rwCGAwcA4wD7jKz7g2+yX2Suw939+G9evVqaq0ihamyEvr2DXcnEklQnEBfBvRPed4PWJGhzUx33+7u7wKLCAEvUtpqamD27NDdohtBS8LiBPprwGAzG2Rm7YGxQGVamxnAsQBm1pPQBbM0n4WKFKRnn4XNm9XdIgUhZ6C7ey1wGTAbWAhMdff5ZnaDme04CjQbWG1mC4DngKvcfXVLFS1SMCoroUuXcHcikYSZe3p3eOsYPny4V1VVJfLaInlRXx/6zo8+GqZOTboaaSPM7HV3H55pmc4UFWmu116DlSvV3SIFQ4Eu0lwzZ0J5OZx0UtKViAAKdJHmmzkz3GquR4+kKxEBFOgizbNkCSxYoO4WKSgKdJHmqIxG7up0fykgCnSR5pg5Ew46SBfjkoKiQBdpqtWr4U9/UneLFBwFukhTPfmkLsYlBUmBLtJUM2dCnz5w+OFJVyKyEwW6SFNs2aKLcUnBUqCLNMVzz8GmTRrdIgVJgS7SFJWV0LkzHHdc0pWINKBAF4nLPQT6yJHQoUPS1Yg0oEAXieuNN2DFCjjllKQrEclIgS4SV2UllJXpYlxSsBToInE9/jgceSTofrhSoBToInF88AHMm6fRLVLQFOgicTz+ePiqQJcCpkAXiaOyEgYPhiFDkq5EpFEKdJFcNmyAuXO1dy4FT4EuksvTT8P27Qp0KXgKdJFcHn8c9tgjjHARKWAKdJFsamvD5XJPOgkqKpKuRiQrBbpINi+/HG5ooe4WKQIKdJFsKiuhXbtw/RaRAqdAF8mmshKOPRa6dk26EpGcFOgijVm0CBYvVneLFA0FukhjdpwdevLJydYhEpMCXaQxlZVwyCGw775JVyISS6xAN7NRZrbIzJaY2fgs7c4wMzez4fkrUSQB1dXw4ou69rkUlZyBbmblwG3AicBQYJyZDc3QrgtwBfDnfBcp0uoqK6G+Hk4/PelKRGKLs4d+BLDE3Ze6+zbgEWBMhnY/Am4CtuSxPpFkTJ8OAwfCsGFJVyISW5xA7wt8kPJ8WTTvn8zsUKC/uz+RbUVmdpGZVZlZVXV1dZOLFWkVGzbAnDlw2mlglnQ1IrHFCfRMv9H+z4VmZcAvgStzrcjdJ7n7cHcf3kt3fZFCNWsWbNum7hYpOnECfRnQP+V5P2BFyvMuwIHAH8zsH8DngUodGJWi9dhj0Ls3fOELSVci0iRxAv01YLCZDTKz9sBYoHLHQndf7+493X2guw8EXgFGu3tVi1Qs0pK2bAl76KeeCuXlSVcj0iQ5A93da4HLgNnAQmCqu883sxvMTKfQSWmZMwc2bgz95yJFJtb1QN19FjArbd51jbQ9ZtfLEknI9Onhui3HHZd0JSJNpjNFRXaorQ3jz085Bdq3T7oakSZToIvs8MIL4drn6m6RIqVAF9lh+nTo2BFGjUq6EpFmUaCLANTVwbRpcOKJsPvuSVcj0iwKdBEI3S0rV8JZZyVdiUizKdBFAKZMgd1207XPpagp0EVqa+HRR0OYq7tFipgCXeS558L1z9XdIkVOgS4yZQp07hwOiIoUMQW6tG3btoXhimPGQKdOSVcjsksU6NK2zZkDa9equ0VKggJd2rYpU6BbNzjhhKQrEdllCnRpuzZtCqNbzjgDOnRIuhqRXaZAl7brscdCqJ9/ftKViOSFAl3argceCDeCPuqopCsRyQsFurRNy5eHA6Lnngtl+jOQ0qDfZGmbJk8G9xDoIiVCgS5tjzvcf3+4CfTgwUlXI5I3CnRpe+bNgwUL4Lzzkq5EJK8U6NL23HNPuMXcmWcmXYlIXinQpW3ZvBkefDCMPd9jj6SrEckrBbq0LVOnwoYNcPHFSVcikncKdGlbJk2CAw6Ao49OuhKRvFOgS9vx9tvw8stw0UVglnQ1InmnQJe2Y9KkcDBUo1ukRCnQpW1IPRi6555JVyPSIhTo0jY89BCsXw/f/nbSlYi0GAW6lD53uOUWOOww+OIXk65GpMVUJF2ASIubPRsWLgxXV9TBUClh2kOX0nfLLbDPPrrNnJS8WIFuZqPMbJGZLTGz8RmWf9/MFpjZW2b2rJntm/9SRZphwYKwh37ppWGEi0gJyxnoZlYO3AacCAwFxpnZ0LRm84Dh7n4wMA24Kd+FijTLzTdDx446M1TahDh76EcAS9x9qbtvAx4BxqQ2cPfn3H1z9PQVoF9+yxRphvffD/3mF1wAPXsmXY1Ii4sT6H2BD1KeL4vmNeabwFOZFpjZRWZWZWZV1dXV8asUaY6JE8MIl//4j6QrEWkVcQI907AAz9jQ7BxgODAx03J3n+Tuw919eK9eveJXKdJUK1fCnXeGG0APGJB0NSKtIs6wxWVA/5Tn/YAV6Y3M7MvANcC/uvvW/JQn0ky/+AVs3w7jGxzDFylZcfbQXwMGm9kgM2sPjAUqUxuY2aHAb4DR7r4q/2WKNMGqVXD77TBuHHz2s0lXI9Jqcga6u9cClwGzgYXAVHefb2Y3mNnoqNlEoDPwOzP7i5lVNrI6kZb3ox/Bli3wn/+ZdCUirSrWmaLuPguYlTbvupTHX85zXSLN8/e/wx13wLe+BUOGJF2NSKvSmaJSWq65JpxAdP31SVci0uoU6FI6qqpgyhT4/vfDqf4ibYwCXUpDfT1897vQqxdcdVXS1YgkQldblNLwwAPw0ktw773QtWvS1YgkQnvoUvzWroWrr4Yjj9Tt5aRN0x66FL8JE2D1anj6aSjTPoq0Xfrtl+I2Zw785jfwve/BsGFJVyOSKAW6FK8NG+Cb34T994cf/zjpakQSpy4XKV5XXgnLlsGf/gSdOiVdjUjitIcuxenhh+Guu8LB0C98IelqRAqCAl2Kz+LFcNFFcNRRcMMNSVcjUjAU6FJcNm6Er30NOnQIe+nt2iVdkUjBUB+6FI/6ejjnHPjrX2HWLOjfP/f3iLQhCnQpHhMmwMyZ8Otfw8iRSVcjUnDU5SLF4ec/h5tugksugcsuS7oakYKkQJfCd/vt4YJbZ50F//M/YJlucysiCnQpbJMmwXe+A6ecAg8+COXlSVckUrAU6FKY3MPZnxdfDCeeCFOnakSLSA4KdCk827fDpZeGe4Kee244ENqxY9JViRQ8jXKRwrJyJZx5JrzwQug3/9nPdAVFkZgU6FI45s4N48zXrYPJk+Hss5OuSKSoaNdHkrdpE1x+ORx/PHTpAq+8ojAXaQYFuiTHHaZNg899Dm69NVzTfN48OPjgpCsTKUoKdEnGq6/CsceG67J06wZ//CP88pew225JVyZStBTo0nrc4fnn4YQTYMQImD8f7rgD3ngDjj466epEip4OikrL27AhHOS84w546y3o3fvT0/g7d066OpGSoUCXlrFpEzz1VOgjf+KJ8HzYsHAa/3nnqWtFpAUo0CU/6uvDZW2ffTYMP3z2WaipgV694OtfD/f+/D//R9dhEWlBCnRpOndYsQJefx2qqsLXV1+Fjz8OywcPhgsugDPOgC9+ESr0aybSGmL9pZnZKOBXQDlwl7v/LG15B+AB4HBgNXCWu/8jv6VKY2bMW87E2YtYsa6GPt07cdXIIZx6aN+cy7LaujWE9ooV8P778M47/OXZV+Gddxi0Zjndtm4CoL6sjCV79OetvQ/hzyMOpveYUVx14Qmfvu7vZzftddNq7r5bO9xhfc32Jq+ntTV7WwPXznibh//8AXXulJsxbkR/fnzqQS1csZQac/fsDczKgcXAV4BlwGvAOHdfkNLmO8DB7v5tMxsLnObuZ2Vb7/Dhw72qqmpX62/zZsxbzoTpb1Ozve6f8zpVlPGz0QdQvmULN02fh2+poeP2rXSq3UqP+m18Z9iejOhRBmvX7jytWQMffgjLl8Pq1Tu9Tr0ZK7r04t0efXh3j778fc9+vL3XZ1nYexA17Xe+zspR++3BG++v37mmduXcePpBOQMu0/tJFXc9rS3jzyFmrdfOeJuHXnm/wfxzPj9AoS4NmNnr7j4847IYgf4F4IfuPjJ6PgHA3W9MaTM7avOymVUAK4FenmXlzQ70l16COXPCv/07Vp/6Ne68prZv6Xn19VBXB7W1TZre/Wg9vr2W9nW1dKzdSsfabXTcvpUKr4+3PcvLoXt36NEjTH36fDr17fvPr0Pve4fNFe3jrbMRfbt34sXxx2Vtc9TP5rJ8Xc0ur6e1NVZ3nFr3mzCLugx/KuVm/P3Gk/JWo5SGbIEep8ulL/BByvNlwIjG2rh7rZmtB/YEPk4r5CLgIoABAwbEKr6BF1+E669vfLnZpwfeUr9mmtfU9i05zyz0NeeaOnbc6fmCbdXUlpVTW15OTUUHtlS0p6ZdR7ZWtI8ed2BLRYfoa1i2vmNnZv1wdAjwLl1iHajcXPFezja5rMgR1Pls09oaqylOrZnCPNt8kcbECfRMf+3pv2lx2uDuk4BJEPbQY7x2Q1YjmBcAAAVmSURBVFdeGSbYORTbqJ9m2TMEGl+2775Nep1ys10OmD5RTbna5NpDj7Oe1tZY3XFqbWzblrfx321pujhnii4DUm+v3g9Y0VibqMulG7AmHwU2UFb26aRfeK4aOYRO7Xa+i0+nduVcNXJI1mVNNW5E/9yNIkftt0ezXzdTzc1ZT2vblW3d2LZtyjYXgXh76K8Bg81sELAcGAukXwqvEjgfeBk4A5ibrf9c8mfHAbdsoyuaO/Ii1Y6Dc+kjMTLN+/GpBzV7xEf6+ymWUS5xfg6NaWzb6oCoNFXOg6IAZnYScAth2OI97v4TM7sBqHL3SjPrCDwIHErYMx/r7kuzrVOjXEREmm5XD4ri7rOAWWnzrkt5vAX42q4UKSIiu0ZXWxQRKREKdBGREqFAFxEpEQp0EZESoUAXESkRCnQRkRKhQBcRKRGxTixqkRc2qwaae8WnnqRd+KvAFVO9xVQrFFe9xVQrFFe9xVQr7Fq9+7p7r0wLEgv0XWFmVY2dKVWIiqneYqoViqveYqoViqveYqoVWq5edbmIiJQIBbqISIko1kCflHQBTVRM9RZTrVBc9RZTrVBc9RZTrdBC9RZlH7qIiDRUrHvoIiKSRoEuIlIiijbQzWyimf3NzN4ys8fMrHvSNaUzs1FmtsjMlpjZ+KTrycbM+pvZc2a20Mzmm9l3k64pFzMrN7N5ZvZE0rXkYmbdzWxa9Du70My+kHRNjTGz/xv9DvzVzB6ObmBTMMzsHjNbZWZ/TZm3h5k9Y2bvRF97JFnjDo3U2mLZVbSBDjwDHOjuBwOLgQkJ17MTMysHbgNOBIYC48xsaLJVZVULXOnu/wJ8Hri0wOsF+C6wMOkiYvoV8Ht3PwA4hAKt28z6AlcAw939QMJdysYmW1UD9wGj0uaNB55198HAs9HzQnAfDWttsewq2kB396fdvTZ6+grh5tWF5AhgibsvdfdtwCPAmIRrapS7f+jub0SPPyEETuHdvDNiZv2AfwPuSrqWXMysK/Al4G4Ad9/m7uuSrSqrCqBTdMP33Wh4U/hEufsfaXgT+jHA/dHj+4FTW7WoRmSqtSWzq2gDPc0FwFNJF5GmL/BByvNlFHBApjKzgYT7w/452UqyugW4GqhPupAYPgNUA/dGXUR3mdnuSReVibsvB34OvA98CKx396eTrSqWvdz9Qwg7J0DvhOuJK6/ZVdCBbmZzon689GlMSptrCN0Fk5OrNCPLMK/gx4iaWWfgUeB77r4h6XoyMbOTgVXu/nrStcRUARwG3O7uhwKbKJwugZ1Efc9jgEFAH2B3Mzsn2apKU0tkV6ybRCfF3b+cbbmZnQ+cDBzvhTegfhnQP+V5PwrsX9d0ZtaOEOaT3X160vVkcRQw2sxOAjoCXc3sIXcv1OBZBixz9x3/8UyjQAMd+DLwrrtXA5jZdOBI4KFEq8rtIzPbx90/NLN9gFVJF5RNS2VXQe+hZ2Nmo4D/AEa7++ak68ngNWCwmQ0ys/aEA0uVCdfUKDMzQh/vQne/Oel6snH3Ce7ez90HErbr3AIOc9x9JfCBmQ2JZh0PLEiwpGzeBz5vZrtFvxPHU6AHcNNUAudHj88HZiZYS1YtmV1Fe6aomS0BOgCro1mvuPu3EyypgWgP8hbCSIF73P0nCZfUKDP7IvAC8Daf9kv/wN1nJVdVbmZ2DPD/3P3kpGvJxsyGEQ7gtgeWAv/u7muTrSozM/sv4CxCd8A84FvuvjXZqj5lZg8DxxAuQfsRcD0wA5gKDCB8KH3N3dMPnLa6RmqdQAtlV9EGuoiI7Kxou1xERGRnCnQRkRKhQBcRKREKdBGREqFAFxEpEQp0EZESoUAXESkR/x/qCqa6y8wpZwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for a, b in [[2, 5], [3, -6], [-5, 0.5], [1.5, -8]]:\n",
    "    total_cost = compute_total_cost(a, b, all_times, exam_result)\n",
    "    plot_prediction_with_sigmoid(a, b, all_times, exam_result, \"Total cost: \" + str(total_cost))\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 7. Perform gradient ascent (1 point)\n",
    "Now we've gone really far. What remains is to try to find the unknown coefficients $a$ and $b$.\n",
    "\n",
    "We're not going to cover the details of the derivation of the gradients. If you're interested how this works, you can look it up online. The method is fairly common in statistics and is called \"maximum likelihood estimation\", i.e. we try to estimate the parameters $a$ and $b$ so that the prediction $\\tilde{y}$ is as close as possible to the observed variable $y$.\n",
    "\n",
    "Here's an important detail, though. Because of how these calculations go, we need to **maximize**, not minimize the target function. The method is called **gradient ascent**. When we update the values, we add, not subtract, the new gradients.\n",
    "\n",
    "$$\n",
    "a = a + \\nabla J_a \\\\\n",
    "b = b + \\nabla J_b\n",
    "$$\n",
    "\n",
    "The implementation of `perform_gradient_ascent()` for logistic regression is given to you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def perform_gradient_ascent(a, b, data_x, data_y, learning_rate):\n",
    "    y_predicted = sigmoid(a * data_x + b)\n",
    "    errors = data_y - y_predicted\n",
    "    a_gradient = np.sum(data_x * errors)\n",
    "    b_gradient = np.sum(errors)\n",
    "    new_a = a + learning_rate * a_gradient\n",
    "    new_b = b + learning_rate * b_gradient\n",
    "    return new_a, new_b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use that to perform 3 000 iterations. Start from $a = 0,\\ b = 0$. At each iteration, update $a$ and $b$. Print the final values at the end. Use `all_times` and `exam_result` as your variables. Use a learning rate $\\alpha = 0.01$.\n",
    "\n",
    "If you wish, you can call `compute_total_cost(a, b, data_x, data_y)` and even plot the learning curve. This will give you a good idea whether your model worked or not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "bf029cf1087c2b1cc96548feb87b9311",
     "grade": false,
     "grade_id": "cell-1486b3cbc3fe053c",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "def train_model(data_x, data_y):\n",
    "    model_a = 0\n",
    "    model_b = 0\n",
    "    learning_rate = 0.01\n",
    "    for step in range(3001):\n",
    "        model_a, model_b = perform_gradient_ascent(model_a, model_b, data_x, data_y, learning_rate)\n",
    "    return model_a, model_b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = 0.9391189871712119; b = -5.568388798795233\n"
     ]
    }
   ],
   "source": [
    "a, b = train_model(all_times, exam_result)\n",
    "print(\"a = {}; b = {}\".format(a, b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "e9ea50d469d2f1288a8152045cd0a205",
     "grade": true,
     "grade_id": "cell-9cd155d1d279863a",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "assert_is_not_none(a)\n",
    "assert_is_not_none(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can compare our implementation to something else. An algorithm that we know works for sure, is the `scikit-learn` implementation.\n",
    "\n",
    "The next cell performs logistic regression using `scikit-learn`. You should observe that the parameters are almost the same as those we got. This means that our implementation works well.\n",
    "\n",
    "The `C` parameter is related to something we haven't discussed called **regularization**. A large number means no regularization is applied, which is what we did. A more detailed discussion is out of the scope of this lab."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = 0.9404412084622914; b = -5.576708242006672\n"
     ]
    }
   ],
   "source": [
    "model = LogisticRegression(C = 1e9, solver='liblinear')\n",
    "model.fit(all_times.reshape(-1, 1), exam_result)\n",
    "print(\"a = {}; b = {}\".format(model.coef_[0, 0], model.intercept_[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Problem 8. Test your model (1 point)\n",
    "Let's create a `predict()` function. It should accept `a` and `b`, and the training data (`all_times` in our case). Its job is to predict the output class. To do this, it should use the already defined `generate_output()` function. To make things easier, this function is provided for you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(a, b, x_data):\n",
    "    return generate_output(a * x_data + b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's now call `predict()` for every input value and compare our outputs to the original ones."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicted: [0 1 1 1 0 0 0 1 1 1 0 1 1 0 0 0 0 0 0 0]\n",
      "Actual:    [1 1 1 0 0 0 0 1 0 1 0 1 1 0 0 0 0 0 1 0]\n"
     ]
    }
   ],
   "source": [
    "exam_result_predicted = np.array([predict(a, b, time) for time in all_times])\n",
    "print(\"Predicted:\", exam_result_predicted)\n",
    "print(\"Actual:   \", exam_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A metric for how good our classification is, is called **accuracy**. It's the ratio of guessed classes to all classes.\n",
    "\n",
    "$$A = \\frac{\\text{number of correct guesses}}{\\text{number of total results}}$$\n",
    "\n",
    "Write a function called `calculate_accuracy` which accepts the predicted exam results and the actual exam results and returns the accuracy score."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "99d83a7c543363fe521f1d88c8946c9f",
     "grade": false,
     "grade_id": "cell-321117662720ef67",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "def calculate_accuracy(predicted, actual):\n",
    "    correct_guesses_count = np.sum(predicted == actual)\n",
    "    return correct_guesses_count / len(actual)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "62034ce5d5171f3e19f1ea3af2b973a5",
     "grade": true,
     "grade_id": "cell-5cdae793298156a5",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "print(calculate_accuracy(exam_result_predicted, exam_result))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, if we want to play a little, we can plot correct and incorrect results. This is left as an exercise to the reader :).\n",
    "\n",
    "### Additional notes: OOP\n",
    "We're not looking at object-oriented programming in this course, but we can wrap everything we did in a class. I am including this just for fun. The class contains only vary basic input checks. A real-life scenario will include much more validation.\n",
    "\n",
    "Also, in this class, I'm calling the functions `train_model()`, `predict()`, and `calculate_accuracy()` directly because I know they're already written. A real class won't simply reuse them, they will be part of the class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class OneVariableLogisticRegression(object):\n",
    "    def __init__(self):\n",
    "        self.is_trained = False\n",
    "        \n",
    "    def train(self, x, y):\n",
    "        assert_is_instance(x, np.ndarray)\n",
    "        assert_is_instance(y, np.ndarray)\n",
    "        assert_equal(x.ndim, 1)\n",
    "        assert_equal(y.ndim, 1)\n",
    "        \n",
    "        self.is_trained = True\n",
    "        self.a, self.b = train_model(x, y)\n",
    "    \n",
    "    def predict(self, x):\n",
    "        if not self.is_trained:\n",
    "            raise RuntimeError(\"The model is not trained\")\n",
    "        return np.vectorize(predict)(self.a, self.b, x)\n",
    "    \n",
    "    def score(self, y_predicted, y_actual):\n",
    "        return calculate_accuracy(y_predicted, y_actual)\n",
    "    \n",
    "# Usage\n",
    "model = OneVariableLogisticRegression()\n",
    "model.train(all_times, exam_result)\n",
    "print(\"a = {}; b = {}\".format(model.a, model.b))\n",
    "print(\"Predicted:\", model.predict(all_times))\n",
    "print(\"Accuracy: {0:.3f}\".format(model.score(model.predict(all_times), exam_result)))"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}