Bhargav_Solanki_assignment_03.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Please fill in your name and that of your teammate.\n",
    "\n",
    "You:Bhargav Solanki\n",
    "\n",
    "Teammate: Carmen Sangro Prieto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Welcome to the third lab. There is much to go through today so we will keep extra concepts to a minimum. There is no new library introduced at this lecture as we will keep using `numpy` for the heavy lifting, `scikit-learn` for the algorithms, and `seaborn` / `matplotlib` for plotting. Careful about reusing variable names in the notebook and computing cells out of order: frequent calls to `Kernel -> Restart and Run All` can save you from headaches.\n",
    "\n",
    "The assignment starts getting math-heavy. Here's a new tool to aid you with the debugging. Explicitly `import IPython` at the beginning of a notebook (or Python file) to have access to the computational Python kernel. You can then call `IPython.embed()` at an arbitrary place in your code (say, inside a loop) and it will pause the computation and drop you into an interactive console. You can then evaluate Python code in the context where it was called. Here is an example:\n",
    "\n",
    "```python\n",
    "import numpy as np\n",
    "for i in range(10):\n",
    "    guess = np.random.normal()\n",
    "    function_that_fails_because_of(guess, i)\n",
    "```\n",
    "\n",
    "Let's say your function fails for `i==9`, how would you find the error? Typically you may want to edit the code and print `guess` and `i` to see what is happening, but it is slow and passive. What if you want to try to pass `i+1` and see if that works? What if you want to try a few other random numbers with the same `i`? Enter `IPython.embed()`:\n",
    "\n",
    "```python\n",
    "import numpy as np\n",
    "import IPython\n",
    "for i in range(10):\n",
    "    guess = np.random.normal()\n",
    "    if i==9: IPython.embed()\n",
    "    function_that_fails_because_of(guess, i)\n",
    "```\n",
    "\n",
    "If you execute this code, the cell output will show an interactive console in your output cell. Here you can send commands to be interpreted by the Python kernel of the notebook. You could then try something like the following lines for example (one at a time):\n",
    "\n",
    "```python\n",
    "i #=> prints value of i\n",
    "guess  #=> prints value of guess\n",
    "function_that_fails_because_of(guess, i) #=> fails and shows you the error\n",
    "function_that_fails_because_of(guess, i+1) #=> change parameters: will it work?\n",
    "function_that_fails_because_of(guess, i-1) #=> what about this one?\n",
    "guess = np.random.normal() #=> overwrites the value of `guess` in the kernel\n",
    "function_that_fails_because_of(guess, i) #=> will this work this time?\n",
    "```\n",
    "\n",
    "As you can see you can test your code in the context of the function (or, here, loop), find the code that works, then you can go ahead and copy+paste in your actual code. If you need to exit the console and resume the computation (with whatever change you executed, as the kernel is the same) just type `exit()`.\n",
    "\n",
    "_Bonus:_ you can ask the kernel to drop you into a _debugger_ session every time you get an error. This can be tricky with Jupyter Notebooks, so use with caution, but can also be a lifesaver if you are willing to learn about [postmortem debugging](https://medium.com/instamojo-matters/become-a-pdb-power-user-e3fc4e2774b2). You do that by adding the following lines on top of your code (need to execute them only once):\n",
    "\n",
    "```python\n",
    "# DEBUG: uncaught exceptions drop you into ipdb for postmortem debugging\n",
    "import sys, IPython; sys.excepthook = IPython.core.ultratb.ColorTB(call_pdb=True)\n",
    "```\n",
    "\n",
    "After this line, if you encounter an error or uncaught exception in your code, rather than terminating you will be dropped in an `ipdb` (fancier version of `pdb`) console where you can interrogate the program about the conditions causing the crash.\n",
    "\n",
    "Good hunting!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How to pass the lab?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below you find the exercise questions. Each question awarding points is numbered and states the number of points like this: **[0pt]**. To answer a question, fill the cell below with your answer (markdown for text, code for implementation). Incorrect or incomplete answers are in principle worth 0 points: to assign partial reward is only up to teacher discretion. Over-complete answers do not award extra points (though they are appreciated and will be kept under consideration). Save your work frequently! (`ctrl+s`)\n",
    "\n",
    "**You need at least 22 points (out of 33 available) to pass** (66%)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Fundamentals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's make sure some of the core points are clear before addressing the specific algorithms.\n",
    "\n",
    "#### 1.1 **[1pt]** Write the equation of the Gaussian density. Use Latex inside the Markdown cell.\n",
    "\n",
    "I suggest you type it out rather than copy+paste from the Internet: the goal of this question is to _force_ you to read one term at a time, and understand which is clear to you and which is not.\n",
    "For example, the equation you will write here a norm, while our later applications of the formula do not, since we will actually be using the [Gaussian](https://en.wikipedia.org/wiki/Normal_distribution) Probability Density Function [(PDF)](https://en.wikipedia.org/wiki/Probability_density_function) equation instead. Do you understand why? Did you study this before?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$f(x)= {\\frac{1}{\\sigma\\sqrt{2\\pi}}}e^{- {\\frac {1}{2}} (\\frac {||x-\\mu||}{\\sigma})^2}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.2 **[1pt]** Explain why we maximize the log-likelihood rather than the likelihood. In particular, what is the advantage in using the $\\log$ rather than another operation?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If there is multiplication involved, its harder to maximize. Instead we use logs, to so we can add. $x.y -> log(xy) --> logx + log(y)$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.3 **[1pt]** Why the equation maximizing the log-likelihood of a Gaussian does not include the parameter $\\sigma$?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\sigma$ is $w$ independent and is also a constant. Hence we ignore it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.4 **[1pt]** Explain the meaning of i.i.d. (in English), using the simplest words you can."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I.I.D. stands for independently and identically distributed. In simple words, they are random samples. \n",
    "#### Idendtically: \n",
    "Sample taken from same distribution.\n",
    "#### Independently :\n",
    "There are no global trends."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.5 **[2pt]** Write the equation of the Bayes' Rule (use Latex). Then write below how to read it in English."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$ P(y|x) = \\frac{P(x|y).P(y)}{P(x)} $"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Linear Regression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.1 **[2pt]** Explain the meaning of $y_i = \\langle w, x_i \\rangle + \\epsilon_i, \\;\\; \\epsilon \\sim \\mathcal{N}(0, \\sigma^2)$ (in English). Utilize the word 'prototype'."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$y_i = \\langle w, x_i \\rangle + \\epsilon_i$   Here $\\epsilon_i$ is the error or noise term that his homoskedastic, that is the error term is also from the same distribution, also we ensure that the value is within the range 0 to standard deviation for each observation. That being said, we now assume that $y_i$ will be picked from the same distribution, the prototype, of the total distribution. $\\langle w, x_i \\rangle $ is the Weights and x coordinates  in vector space. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Enough theory, let's get our hands in there. Since we are working with a regression task, let us generate some data from an underlying linear function with some noise.  \n",
    "_[think: the process below is (correct but) unnecessary convoluted: would you be able (yet) to simplify it? Always prefer simpler code!]_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-10.0, 1.0, -24.7155822902512)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "trg_fn = lambda x: 2*x - 1 # hi I'm lambda, remember me?\n",
    "some_noise = lambda: np.random.normal(0,2) # Gaussian noise with mu=0, sigma=2\n",
    "# Below we add a 1 to every row as the bias (constant) input\n",
    "# Think about each part and discuss if you do not understand something yet!\n",
    "data = np.array([[x, 1, trg_fn(x) + some_noise()] for x in np.linspace(-10, 10, 50)])\n",
    "#print(data)\n",
    "*x, y = data.transpose() # easier using splat and numpy: do you understand it?\n",
    "x = np.array(x).transpose() # back to *rows* with input features and bias input\n",
    "x[0][0], x[0][1], y[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.2 **[1pt]** Write a (Python) function that takes a data point in input and returns the squared error Loss. Test it by using a constant prediction model $y = 1$ and compute the Risk over all the data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$E_i = [y_i - (\\langle w, x_i \\rangle + b)]^2$\n",
    "\n",
    "$ \\\\  \n",
    "= [y_i - (\\langle w, x_i \\rangle) - b)^2$\n",
    "\n",
    " Given that y = 1 , we know $w$ is [0, 0, .., 0] hence $\\langle w, x_i \\rangle$ is 0 \n",
    " Hence, \n",
    " \n",
    "$ = [y_i - 1]^2 $\n",
    "\n",
    "Using that information"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7872.45328068631"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We know that y = 1 so, we dont use x\n",
    "def calculate_least_sqaure(point, label):\n",
    "    return pow(label - 1, 2)\n",
    "\n",
    "def calculate_risk(points, labels):\n",
    "    total_risk = 0\n",
    "    for i in range(0, len(points)):\n",
    "        total_risk += calculate_least_sqaure(points[i], labels[i])\n",
    "    return total_risk\n",
    "calculate_risk(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[IMPORTANT]: A few tips before we proceed:\n",
    "- Numpy's linear algebra library provides matrix inversion, but you should use instead the pseudo-inverse to cope with singular covariance matrices: `np.linalg.pinv()`\n",
    "- Numpy's array provides inner product with the function `dot()`\n",
    "- Typically `dot()` will find the right direction for one-dimensional arrays, which means that you should never need to transpose them\n",
    "- Using `dot()` with matrices instead *always* requires you to `transpose()` to the right orientation! Write the math and keep track of what you are doing.\n",
    "- Remember that matrix product is not commutative: `A.dot(B)` is NOT equal to `B.dot(A)`. Refresh also how `A.dot(B)` requires the number of columns of `A` to be the same as the number of rows of `B`, and the result will have the same number of rows of `A` and the number of columns of `B`.\n",
    "- Linear regression uses a closed-form solution, **not a loop**, and you will not use the implementation of the loss above in the rest of the assignment (because it is implicit in the algorithm's solution)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.3 **[2pt]** Write a function that takes in input a list of data points and a list of labels, and returns the $w$ vector using the closed-form solution of Linear Regression. Test it on the data above and print the computed $w$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 2.02205481 -0.55068072]\n"
     ]
    }
   ],
   "source": [
    "def calculate_weights(points, labels):\n",
    "    #print(points)\n",
    "    x_transpose = np.transpose(points)\n",
    "    new_labels = [ [val,1] for val in labels]\n",
    "    #print(x_transpose)\n",
    "    mult = np.dot(x_transpose, points)\n",
    "    #print(mult)\n",
    "    #print(\"###\")\n",
    "    inverse = np.linalg.pinv(mult)\n",
    "    #print(inverse)\n",
    "    #print(\"###\")\n",
    "    temp = np.dot(inverse, x_transpose)\n",
    "    #print(temp)\n",
    "    result = np.dot(temp, labels)\n",
    "    #print(result)\n",
    "    return result\n",
    "#print(x)\n",
    "w = calculate_weights(x, y)\n",
    "print(w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.4 **[2pt]** Predict the labels for all points using your Linear Regression implementation and the `w` vector from the previous question. For each data point, print the triplet of  `(label, prediction, loss)`. Then compute and print the (squared error) Risk over the dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember that you need to build the linear model (careful handling the bias), then you are doing _regression_ not *classification*, which means you are predicting the value $\\hat{y}$ based on your $x$. You should get back $m$ and $q$ close to $2$ and $-1$, and the risk roughly proportional to the square of the expected error multiplied by the number of points (or close below that).  \n",
    "_[think: what is the expected error? Do you understand why? You can generate the points and compute the risk multiple times to verify your hypothesis]_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "label = -20.7838435905172, y_cap = -20.771228809157318, loss =0.000159132708757644\n",
      "label = -18.029448856373314, y_cap = -19.945900315726195, loss =3.672786196055789\n",
      "label = -15.017805132811464, y_cap = -19.120571822295073, loss =16.832694508336292\n",
      "label = -20.61357149629874, y_cap = -18.295243328863947, loss =5.374645491921563\n",
      "label = -21.738014205015332, y_cap = -17.469914835432824, loss =18.216672228630603\n",
      "label = -13.824151792221114, y_cap = -16.644586342001706, loss =7.954851049596047\n",
      "label = -14.116568239291807, y_cap = -15.81925784857058, loss =2.8991519055458994\n",
      "label = -12.010663241810084, y_cap = -14.993929355139457, loss =8.899876702939343\n",
      "label = -17.64683149544249, y_cap = -14.168600861708335, loss =12.098088341446713\n",
      "label = -16.83275812356937, y_cap = -13.343272368277212, loss =12.176510836386882\n",
      "label = -13.11739620003551, y_cap = -12.517943874846088, loss =0.35934309017500393\n",
      "label = -15.780929941760284, y_cap = -11.692615381414965, loss =16.71431594433154\n",
      "label = -10.336572866071798, y_cap = -10.867286887983843, loss =0.2816573730540588\n",
      "label = -10.510925379185528, y_cap = -10.04195839455272, loss =0.2199300326755877\n",
      "label = -6.606441462828855, y_cap = -9.216629901121596, loss =6.813083683397101\n",
      "label = -9.972482045419778, y_cap = -8.391301407690472, loss =2.5001322091300535\n",
      "label = -5.510027748979991, y_cap = -7.565972914259351, loss =4.226910522635576\n",
      "label = -5.887948656035161, y_cap = -6.740644420828229, loss =0.7270900672960348\n",
      "label = -5.495158810218844, y_cap = -5.9153159273971045, loss =0.17653200311554657\n",
      "label = -5.23741480441098, y_cap = -5.08998743396598, loss =0.021734829556327124\n",
      "label = -4.394176336316252, y_cap = -4.26465894053486, loss =0.01677475580999385\n",
      "label = -3.8507292234863244, y_cap = -3.439330447103737, loss =0.16924895320909003\n",
      "label = -4.6030717352481565, y_cap = -2.614001953672611, loss =3.956398595976988\n",
      "label = -0.6248941831430079, y_cap = -1.7886734602414893, loss =1.354382205803864\n",
      "label = 2.257961719427353, y_cap = -0.9633449668103673, loss =10.376816766799841\n",
      "label = 2.808287140860644, y_cap = -0.13801647337924527, loss =8.680704987283036\n",
      "label = -0.40404068393031944, y_cap = 0.6873120200518767, loss =1.1910507244892512\n",
      "label = -0.9188402491120884, y_cap = 1.5126405134830025, loss =5.912098698870004\n",
      "label = 3.761241467933008, y_cap = 2.3379690069141246, loss =2.0257044982947487\n",
      "label = 6.115776297750616, y_cap = 3.1632975003452466, loss =8.717131049128254\n",
      "label = 1.3129149710024293, y_cap = 3.9886259937763717, loss =7.159429477393977\n",
      "label = 8.50905956345204, y_cap = 4.813954487207495, loss =13.653801524488204\n",
      "label = 1.8539229632814584, y_cap = 5.639282980638615, loss =14.328950461006174\n",
      "label = 4.463505090760633, y_cap = 6.464611474069738, loss =4.004426757320445\n",
      "label = 4.388861973962049, y_cap = 7.28993996750086, loss =8.416253524595174\n",
      "label = 11.567718942043069, y_cap = 8.115268460931985, loss =11.919414324524157\n",
      "label = 5.650289910302923, y_cap = 8.940596954363107, loss =10.826120444192068\n",
      "label = 11.43994754126248, y_cap = 9.76592544779423, loss =2.8023499694198253\n",
      "label = 8.992100839936162, y_cap = 10.591253941225355, loss =2.557290641362845\n",
      "label = 11.611135185558922, y_cap = 11.416582434656476, loss =0.03785077288370914\n",
      "label = 10.655868157889445, y_cap = 12.241910928087599, loss =2.515531668897832\n",
      "label = 12.808810062400944, y_cap = 13.067239421518721, loss =0.06678573365402488\n",
      "label = 14.104808176382534, y_cap = 13.892567914949844, loss =0.04504592857301666\n",
      "label = 17.406016300399678, y_cap = 14.717896408380964, loss =7.2259885538667\n",
      "label = 14.494302082787641, y_cap = 15.543224901812096, loss =1.1002390802702087\n",
      "label = 16.603848801298696, y_cap = 16.368553395243218, loss =0.05536392811081225\n",
      "label = 17.814355792798832, y_cap = 17.193881888674337, loss =0.38498786569949284\n",
      "label = 19.121145351449357, y_cap = 18.01921038210546, loss =1.2142606766629365\n",
      "label = 17.882467304076474, y_cap = 18.844538875536582, loss =0.9255817086117208\n",
      "label = 20.70632485777608, y_cap = 19.669867368967704, loss =1.0742441261069675\n",
      "[ 2.02205481 -0.55068072]\n"
     ]
    }
   ],
   "source": [
    "def my_loss(y_i, y_cap):\n",
    "    return pow(y_i -y_cap,2)\n",
    "\n",
    "def predict(points, labels, w):\n",
    "    risk = 0\n",
    "    predictions = []\n",
    "    for i in range(0, len(points)):\n",
    "        point_x = points[i]\n",
    "        label = labels[i]\n",
    "        y_cap = np.dot(w, point_x) \n",
    "        predictions.append(y_cap)\n",
    "        loss = my_loss(label, y_cap)\n",
    "        print(f\"label = {label}, y_cap = {y_cap}, loss ={loss}\")\n",
    "        risk += loss\n",
    "    #print(risk)\n",
    "    return risk, predictions\n",
    "w_cap = calculate_weights(x, y)\n",
    "risk, predictions = predict(x, y, w_cap)\n",
    "print(w_cap)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.5 **[2pt]** Plot the data and the model.\n",
    "\n",
    "You should be able to partially reuse the printing code from the last lab (particularly plot and params-to-boundary conversion), but feel free to customize it as you need.\n",
    "I will keep repeating this for a while more: careful with the bias!  \n",
    "(Think: you can plot the model's predictions very easily if you use linear algebra, do you understand what is `x.dot(w)`?)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-10.          -9.59183673  -9.18367347  -8.7755102   -8.36734694\n",
      "  -7.95918367  -7.55102041  -7.14285714  -6.73469388  -6.32653061\n",
      "  -5.91836735  -5.51020408  -5.10204082  -4.69387755  -4.28571429\n",
      "  -3.87755102  -3.46938776  -3.06122449  -2.65306122  -2.24489796\n",
      "  -1.83673469  -1.42857143  -1.02040816  -0.6122449   -0.20408163\n",
      "   0.20408163   0.6122449    1.02040816   1.42857143   1.83673469\n",
      "   2.24489796   2.65306122   3.06122449   3.46938776   3.87755102\n",
      "   4.28571429   4.69387755   5.10204082   5.51020408   5.91836735\n",
      "   6.32653061   6.73469388   7.14285714   7.55102041   7.95918367\n",
      "   8.36734694   8.7755102    9.18367347   9.59183673  10.        ]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAegAAAFoCAYAAACc4GjUAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABJd0lEQVR4nO3deUBU1d8G8Id1AMUQEzUXFHcTwbTcJZdIUNTUSgvNXctwS01RM3dzSSJft9xyy11xgxA3UBAVN0h/LuGeIgrIPgwz9/3DhkSGYWDuLAzP56+YuXPvuU7yeM4953vMBEEQQEREREbF3NANICIiooIY0EREREaIAU1ERGSEGNBERERGiAFNRERkhCwN3QAlhUKBjIwMWFlZwczMzNDNISIi0jlBECCTyVCuXDmYm+fvMxtNQGdkZODWrVuGbgYREZHeNWjQAPb29vleM5qAtrKyAvCqkdbW1qKdNy4uDk2bNhXtfIZiKvcB8F6Mlanci6ncB8B7MUZi30dOTg5u3bqVl4GvM5qAVg5rW1tbQyKRiHpusc9nKKZyHwDvxViZyr2Yyn0AvBdjpIv7UPVol5PEiIiIjBADmoiIyAgxoImIiIwQA5qIiMgIMaCJiIiMEAOaiIjICDGgiYiIjBADmoiIqAhSmRwp6VLUqN0AKelSSGVynV/TaAqVEBERGaOUtGzsPnEbx6IfIEuaC1uJJTxb1UK/zvXhYG+js+syoImIiAqRkpaNSYERSEjKzHstS5qLoPB4nIt7iiVjO6CijkKaQ9xEREQqSGVy7DlxO184vy4hKRP7Tt5Bjo6GuxnQREREKmRJcxEa/UDtMaHR95EpzdXJ9RnQREREKggKAVlFhG9mdi4EhaCT62sV0CtWrED37t3RvXt3LF68GAAQGRkJHx8feHp6Yvny5aI0koiISN/MzM1gK1E/VcvOxhJm5gV3ohJDiQM6MjISZ86cwf79+3HgwAH89ddfOHz4MPz9/bFy5UocPXoUcXFxOH36tJjtJSIi0gvlbG11PFs5w66IEC+pEgd05cqVMXXqVFhbW8PKygp169bFvXv34OzsjJo1a8LS0hI+Pj4ICQkRs71ERER6IbGyQL/O9VHF0U7l+1Uc7dCnUz1YW1no5PolDuj69evD3d0dAHDv3j0EBwfDzMwMlStXzjvGyckJCQkJWjeSiIjIEBzsbbBkbAf06uiSN9xtZ2OJ3h51dbrECgDMBEHQ6un27du3MWrUKPj5+cHCwgIRERFYsmQJAODs2bPYsGED1q9fX+R5pFIp4uLitGkKERGR6CwsLPBWRUfYlXcAYAZAQGZ6Cl4mJ0EuF2eJVdOmTSGRSPK9ptXAeUxMDMaOHQt/f390794d58+fR2JiYt77iYmJcHJy0rqR2raxRYsWop3PUEzlPgDei7EylXsxlfsAeC9iksrkyJK+mnGtnPwlKebQ9P3797F69WrMnz8f5pUqAM7qn09r1C41ndMSB/STJ08wZswYLF++HG3atAEAuLm54e7du7h//z5q1KiBw4cPo2/fviW9BBERkda0LdUpCAK2bNkCPz8/CIKAadOmoUKFCjpvd4kDev369ZBKpVi0aFHea/3798eiRYvg5+cHqVQKDw8PdOvWTZSGEhERFZe2pTqfP3+O0aNHY+/evWjfvj0mT56sl3AGtAjoGTNmYMaMGSrfO3jwYIkbREREJAZNS3UO9GqsciZ2SEgIhgwZghcvXmDRokWYNGkSrly5ouNW/4eVxIiIyCSVtFRnZmYmxowZAy8vL1SqVAnnz5/H999/DwsL3SynKgwDmoiITFJJSnWeP38ezZs3x8qVKzFx4kRcvHgxb0mxvjGgiYjIJBWnVGdubi7mzJmDtm3bIjMzE8ePH8eyZctgY6O7dc5FYUATEZFJ0rRU5+MHd9G+fXvMmjULn3/+OWJjY9G5c2c9tbJwDGgiIjJJRZXqdKpoi9S7p/DB+y1w69Yt7NixA9u2bYODg4N+G1oIBjQREZV6UpkcKelSJKdmIyVdCqnsVYWvwkp1dmr2Fh5GLMfE8X5o164dLl66go+79y7weUPSzRYcREREelJUIZKK9jYY5N0E/bo0gKAQcOTwQYwf+xUyMjIQGBiILwcNw95Tf+NYdGyJCpnoCgOaiIhKLU0LkVhbWSA7KwPjx4/Hxo0b8d5772Hr1q2oVqOOVoVMdIlD3EREpFNSmRw1atcXffhY00IkOTI5IiIi4Obmht9//x3Tp09HVFQUXOo10PjzhsAeNBER6Yy2dbDV0aQQSXDkHcSd/h2/LF+GOnXqICIiAm3btn3VtnSpRoVM+naur7M9n9VhQBMRkU5oWwe7KEUVIkl7/gDhwcuRmngXI0aMwLJly2Bvb6/x54GChUz0iUPcREQkuuIMP5dUYYVIBEGB+JiDiNj2HaQZSdi2Yw/Wrl2bL5zVff51ykImhsCAJiIi0ZW0DnZxqCpEkpWWiHN7ZuH66Q2oXLs5Fq4KQr8+vTX+/Js8WznDrogQ1xUGNBERiU4fw8evFyIRBAGPb5zG6c3jkPL0Npp9NAbdB8/F4E9aFfr8uKhCJlUc7dCnUz2DPH8G+AyaiIh0QDl8rC6kNR0+lsrkyJK+CnPleSX/hqaDvQ38fd9Ff99huHwmBBWrNUSb3pPQp1tr9OlUr8hn3MpCJntP3EbovxPZ7Gws4dnKWaPP6xIDmoiIRKccPg4Kjy/0GE2Gj4uaBX7s2DEMGTIECQkJmPHDbIwdNxFW1lawk1hq3PN9s5CJmblZsT6vKwxoIiISnXL4+FzcU5UTxTQZPlY3C/zM5fuQJARj7eqVaNy4MQ4ePIj33nuvxO21trIweCC/iQFNREQ6oc3wsbpZ4CkJd3BqUwDSkx5hzLd+WLL4J9ja2uryVgyCAU1ERDqjHD72ae8MaytrjYePVc0CVyjk+PvCPtyK2gFr27fQccBczFs4Gba2El3egsEwoImISKesrSzw6N5ttGjRQuPPvDkLPCPlCa4EByD5yU2807A9mnYeBWtbe4MVEdEHBjQRERkd5WztzGwZHsaF4a9T62Fmbo7m3hNRvVFHAIYtIqIPDGgiIjI6thJLtG5YDovnTEFC/AVUqukK925jYWtfOe8YQxYR0QfTvTMiIiq1/gw+goWThiM5JQVNPhyKOs17wMzsv9pahi4iog8MaCIiMhppaWmYMGEC1q9fD3d3dwQdCcH1J1ZGV0REHxjQRERkFM6ePYtBgwbh7t27mDZtGn788UdYW1ujpUxudEVE9IEBTUREBpWTk4PZs2dj0aJFqFWrFsLDw9G+ffu8942xiIg+MKCJiMhgrl+/Dl9fX1y+fBlDhgxBQEAAKlSoYOhmGQXuZkVERHqnUCgQGBiIFi1a4OHDh9i/fz82bNjAcH4Ne9BERKRXjx49wpAhQxAWFobu3bvj/1atwVsV30ZyanaB3arKMgY0ERHpzY4dO/D1118jJycHa9aswaf9B2LPyTs4Fn1F5W5VZRkDmoiIdC41NRVffvkltm/fjtatW2PLli14u0qNQnerOhf3FEvGdjD5pVTq8Bk0ERGVmFQmR0q6FMmp2UhJl0Iqkxc45vjx4xgwYAB27tyJOXPmICIiAjWd6xS6WxUAJCRlYt/JO8hRcb6ygj1oIiIqkZS0bOw+cRvH/i0i8ubwdFZWFvz9/REQEABnZ2dERUXh/fffBwCkp0sL7Fb1ptDo++jbuX6ZXGIFMKCJiKgEUtKy1Q5PD/SwxzejhuH69ev49ttv0b9//7xwBgruVqVKZnauSe9WVRQOcRMRUbFIZfJCh6cFhRxnQ7agS6cOSE5ORkhICH799VfY2OR/lqycra2Oqe9WVRT2oImIqFiypLkqh6czXybgcnAAkv+5gRqN2uN0yE64OL+j8hzK4fCg8PhCr2Pqu1UVpezeORERlcibw9OCIODRXycQd/I3mJmbw91rAqo36oiKFR0LPYfEygL9OtfHubinKnviZWG3qqIwoImIqFiUw9NZ0lxIM1/i2rGVSPg7GpVqNIV7t3GwrVBZo+FpB3sbLBnbAXtP3C6Tu1UVhQFNRETFohyeXrtpJ66GrkCuNAONOw6GS4ueeXs2azo8XdHeBoO8m5TJ3aqKwoAmIqJikUmzcCboF1w4sB72b9dG676zUaFy7bz3izs8XVZ3qyoKA5qIiAollcmRJc3N691eu3IRw4YMxt9//42x4yeiUbsvcPLSUw5P6wADmoiIVHq9EElGZjbuXtyD/0XtQo0aNXDq1Cl07NgROTI5BnTL5fC0DjCgiYiogNcLkaQnPcbl4OV4mXAHNZp0wod9xsK1+QcAODytSwxoIiLKR1mI5OmLDNy/Gozr4ZtgYSlBix5TUK1BWyRnAvtO3sFAr8YMZx1iQBMRUT5Z0lwEhV3G+UMBSLx/GZVrvwc3z29hU/6/dc1lvU62PjCgiYgonwP79uLPdd9CnitF0y6j4NysG8zM8q9pLut1svWBAU1ERACAly9fws/PD1u2bEHFavXh1m08ylesrvLYsl4nWx8Y0EREhFOnTuGrr77C48ePMWPmD6ju1gtHIh8WenxZr5OtD/zTJSIqw7KzszFjxgz8/PPPqFevHs6ePYtWrVohJS0bF//3gnWyDYgBTUSkA28W+LCVWEJigEBT145r167B19cXsbGxGD16NJYuXYpy5coBYJ1sY8CAJiIS2esFPrKkuXm1q/t1rg+HYgSbYyUnpKRLSxzyhbXjEw8XbPhtJWbMmAFHR0ccPXoUXl5eBT7POtmGxYAmIhLR6wU+lLKkuQgKj8e5uKdYMraDRr3PlLRsHLucjLAL10oU8oW1449DUZg5/ks8vReLTz75BGvXrsXbb79d6HlYiMRwzA3dACIiU6Es8KHquS0AJCRlYt/JO8iRydWeRxmuh87czdt3WRnykwIjkJyWXex2CIKAR9dPInzLeDz/5w6GjJuHP3bsUhvOZFgMaCIikWRJcxEa/UDtMaHR95H5b+iqIkbIv9mOnKxUxBxejCshv6BC5TroODAAGeXckZWj/h8KZFgc4iYiEomgEPJ6vIUpqsCHpiGvrorX6+14djcGV0NXICcrDY06DELdFr1gZm7BQiOlAAOaiEgkyolc6kK6qAIfYoS8mbkZrMxycSlsHe5fDYF9pVr44JOZeMvJJV87zM3NjGa2ORXEgCYiEolyIldQeHyhxxRV4EOMkI+7dgmRf3yHhH8ewKVFLzRs9yUsLK3zHTPAsyEUgoDNR69rPducdIPPoImIRCKxskC/zvVRxdFO5fuaFPhQhqQ6hYW8TCbD7Nmz8WHHDrA0l8Nr6E9o4jGkQDi7VH8LHZvXwOTACBwMjy/RRDTSPQY0EZGIlAU+enV0ge2/IWpnY4neHnU1WmJV0pC/desW2rdvjx9//BEDBgxAXGwstgX4qWzHnJGtse+k9rPNSbc4xE1EJDJtC3woQ3738VsIO/9QbRUvQRCwZs0afPfdd5BIJNi5cyc+++yzvPdVtSNThIlopHsMaCIiHdC2wEdFext81NwBn3VtWGjIP3nyBMOGDUNwcDA8PT2xYcMGVK+ef/cpVe3IyJJpPRGNdE/rIe709HT06NEDjx49AgBERkbCx8cHnp6eWL58udYNJCIqq5KeJ8KhvAQVK9jAobwkX9Du27cPrq6uOHnyJAIDAxEcHFwgnAujnIimDreTNDytAvrq1asYMGAA7t27B+DVrij+/v5YuXIljh49iri4OJw+fVqMdhIREYDU1FQMHjwYffv2Re3atXH58mX4+fnB3FzzX+faTEQj/dEqoHft2oVZs2bByckJwKudUZydnVGzZk1YWlrCx8cHISEhojSUiKisCw8PR7NmzbBlyxbMnDkTUVFRaNSoUbHPI8Zsc9I9rf55NH/+/Hw/P3v2DJUrV8772cnJCQkJCdpcgoiozJNKpfjhhx+wZMkSuLi44MyZM2jTpo1W5+R2ksZP1PELhUIBM7P/nlkIgpDvZ03ExcWJ2SQAQExMjOjnNARTuQ+A92KsTOVeTOU+AGDnzp344YcfcOvWLXzyySeYMGECrK2tRblHCwsLdHF3hE/7DgDMAAjITE/B/b//h3i5+EusTOV70dd9iBrQVatWRWJiYt7PiYmJecPfmmratCkkEolobYqJiUGLFi1EO5+hmMp9ALwXY2Uq92Iq96FQKPDdd99h5cqVcHBwwKFDh9CjRw/dX7hSBcBZ/fPpkjCV70Xs+5BKpYV2TEUtVOLm5oa7d+/i/v37kMvlOHz4MDp27CjmJYiITN6DBw/QtWtXBAQEoFu3boiNjVUZzlKZHCnpUiSnZiMlXQopC4uYFFF70BKJBIsWLYKfnx+kUik8PDzQrVs3MS9BRGSyBEHA9u3bMWbMGMjlcsycOROzZ89W+agwJS0bu0/cZh1tEyZKQJ84cSLvv9u0aYODBw+KcVoiojIjKSkJX3/9NXbt2oV27dph8+bNSE5OLjScJwVG5CvVqayjfS7uqUYlRcn4sRY3EZkUCwuLUjf0GxoaCldXV+zbtw8LFizA6dOn4eLiovJYqUyOPSdYR7ss4Cp0IjIp1WvVKzVbKGZmZuL777/HihUr0KRJExw+fBjNmzdX+5ks1tEuMxjQRGQyUtKyMW1VVKkY+o2JiYGvry/+97//Ydy4cVi4cCFsbW2L/JygEFhHu4zgEDcRmYTSMvSbm5uLefPmoXXr1khPT0dYWBgCAgI0CmeAdbTLEgY0EZkETYd+M4voferSnTt30LFjR8ycOROffvoprl27hi5duhTrHKyjXXYwoInIJBjz0K8gCPjtt9/g7u6OGzduYPv27di+fTsqVqxY7HOxjnbZwYAmIpNgrEO/CQkJ6NmzJ0aOHInWrVsjNjYWAwYM0OqcyjravTq65N2znY0lenvUNarn7KQdjoEQkUlQDv0GhccXeoy+h36DgoIwYsQIpKamIiAgoNjbQqpT0d4Gg7yboF+XBhAUAszMzWAnsWTP2YSwB01EJsGYhn7T0tIwfPhw9O7dGzVq1MClS5cwbtw40cJZydrKAg7lJahYwQYO5SUMZxPDgCYik+Fgb4MFX7c26NDv2bNn4e7ujo0bN8Lf3x/nzp1DkyZNdH5dMj0c4iYik/LPg78xyNtV70O/OTk5mD17NhYtWgRnZ2eEh4ejXbt2Or0mmTYGNBGZFLlcDmsrC70O916/fh2+vr64fPkyhg0bhuXLl8Pe3l5v1yfTxCFuIqISUigU+OWXX/Dee+/h0aNHOHDgANatW8dwJlGwB01EVAKPHj3CkCFDEBYWhh49emDdunWoUqWKoZtFJoQ9aCKiYtqxYwdcXV0RFRWFNWvW4ODBgwxnEh0DmohIQ8nJyfjiiy8wYMAANGrUCFeuXMHIkSNV7tlMpC0GNBGRBsLCwuDq6ordu3dj3rx5iIiIQL169QzdLDJhDGgiMjpSmRwp6VIkp2YjJV0KqQF3oMrKysL48ePx0UcfoXz58oiKisL06dNhackpPKRb/D+MiIxKSlo2dp+4jWPRD5Alzc0r4dmvc3046LnG9OXLl+Hr64vr16/Dz88PixYtgp2d6kplRGJjD5qIjEZKWjYmBUbgYHh83s5UWdJcBIXHY1JgBJLTsvXSDrlcjoULF6JVq1ZISUnBn3/+icDAQIYz6RUDmoiMglQmx54Tt5GQlKny/YSkTOw7eQc5Oh7ujo+Ph4eHB/z9/dG7d29cu3YNnp6eOrmWMQ3lk/HhEDcRGYUsaS5Cox+oPSY0+j76dq6vkyphgiBg48aNGDduHCwsLLB161Z88cUXOpuhbUxD+WScGNBEZBQEhZA3rF2YzOxcCApB9Gs/e/YMI0eORFBQEDp16oRNmzahVq1aol9HSTmU//pogXIo/1zcU+7pTAA4xE1ERsLM3CxvB6rC2NlYwsxc3B7toUOH4OrqiuDgYCxbtgxhYWE6DWdjGcon48eAJiKjoBziVcezlTPsighxTaWnp2PkyJHo2bMnqlatiosXL2LixImi79n8Jk2H8jOLGE0g08eAJiKjILGyQL/O9VHFUfVM6SqOdujTqZ4oz5+joqLg7u6OdevWYfLkyTh//jxcXV21Pq8mDDmUT6ULA5qIjIaDvQ2WjO2AXh1d8oa77Wws0dujrijPZWUyGWbOnIn27dsjNzcXp06dwuLFiyGRSMRovkYMNZRPpQ8niRGRUalob4NB3k3Qr0sDCAoBZuZmsJNYat1z/t///gdfX1/ExMRg8ODB+OWXX1ChQgWRWq055VB+UHh8oceIOZRPpRd70ERkdKytLOBQXoKKFWzgUF6iVTgLgoAVK1agefPmuHfvHvbu3YuNGzcWGc66WqOsz6F8Kt34TzQiMln//PMPhgwZgtDQUHh5eWH9+vWoVq1akZ/TZI2yVCZHljQ3r5dvK7GERMNQVQ7l7z1xG6H/XsPOxhKerZzRp1M9LrEiAAxoIjJRu3fvxqhRoyCVSrFq1SqMGjVKo6IjRa1R/nl8RygUgtZFRnQ1lE+mgwFNRCYlLS0NAwcOxNatW/HBBx9gy5YtaNCggUafLWqNcma2DOlZMvywJkqUIiPWVhYMZCoUn0ETkck4deoU+vfvjz/++AOzZ8/G2bNnNQ5noOg1yl0/eDW5i0VGSB8Y0ESkd2JPwMrOzsakSZPQuXNnSCQSREZG4ocffij2ns1FrVFu2+wdnLz4UO05WGSExMIhbiLSK7E3ibh69Sp8fX0RFxeHb775BgMGDMAHH3xQorYpJ3sVFtJWFuYsMkJ6wx40EemNmPs9y+VyLF68GO+//z6eP3+Oo0eP4v/+7/9ga2tb4vYVVW5UJlewyAjpDQOaiPRCzE0i7t27h86dO+P777+Hj48PYmNj4eXlpXUbi1qjfPVWIjw/0F+9cCrbGNBEpBdibBIhCAJ+//13NGvWDJcvX8amTZuwZ88evP3226K1U1250Y9bO6NfFxYZIf3gP/OISC+03STi+fPnGDVqFPbt24eOHTvi999/R+3atXXQ0qLXKLPICOkDA5qI9KKoCVhA4c9vg4ODMXToUCQlJWHJkiWYMGECLCx020tVt0aZRUZIHzjETUT56KoGdUn2e87IyMA333wDb29vvP3227hw4QImTZqk83DWhJj1wolUYQ+aiAAAtra2oi+Bep1yAta5uKcqJ4q9+fz2/Pnz8PX1xZ07dzBp0iTMnTsXNjYcPqaygz1oIgIAVK5aS7QlUIXRZL9nmUyG2bNno23btpBKpThx4gSWLFnCcKYyhz1oIoJUJsd+DUpYDvRqrPVQrrrnt7du3cLAgQNx/vx5DBw4EIGBgXBwcNDqekSlFXvQRGVIYc+Xs6S5CDuvvxKWbz6/tbI0x6pVq+Du7o47d+5g165d2Lx5M8OZyjT2oInKCHXPlwUBBith+eTJEwwbNgzBwcHw9PTExo0b8c4774h+HaLShj1oojKgqBKbAmCQEpZ79+6Fq6srTp48iRUrViAkJIThTPQvBjSRidOkxObN+0n4SI8lLF++fImvvvoK/fr1Q506dXD58mWMGTMGZmb6q2Gtq+VkRGLhEDeRidOkxOa6oDgs9uuA6L80WwKljfDwcAwaNAgPHz7EzJkzMXPmTFhZWWl93uLQ5XIyIrGwB01k4jQpsfksOQsQFEUugdKGVCrFlClT8OGHH8LKygpnz57FnDlzDBLOul5ORiQG9qCJTJymJTZz5XJUcSinkxKWsbGx8PX1xbVr1zBy5EgsW7YM5cuXL/H5pDI5sqS5eW20lVhCokEbNd1RS4zlZETaYkATmTjl8G1QeHyhx3i2ckZmegpQqYLaGtTFpVAosHz5cvj7+8PBwQGHDh1Cjx49tDqnNsPTmu6o1bdzfQY0GRyHuIlMXFF7HCufL79MThL1ug8ePECXLl0wadIkeHt7Iy4uTpRwLmp4Wl2dbm131CLSJwY0URmgSYlNuVycWcyCIGDr1q1wdXXFxYsXsWHDBuzbtw+VK1fW6ryaDk+/VdGx0HMoh8PV0cVyMqKS4BA3URmhjy0SX7x4ga+//hq7d+9Gu3btsHnzZri4uIhybk2Hp3u061Do+5oO94u1nIxIG+xBE5Uhutwi8c8//4SrqysOHDiAhQsX4vTp06KFM6D58DRQeO9X0+F+Pn8mY8CAJiKtZGZmws/PD926dUPFihURHR2NqVOnir5ns6bD04D658eaDPcTGQOO4xBRiV28eBG+vr64efMmJkyYgAULFuhsW8jizkZXRx/D/UTaYg+aiIotNzcXc+fORZs2bZCRkYGwsDD8/PPPOt2zWezZ6Loc7icSAwOaiIrlzp076NChA3744Qd89tlnuHbtGrp06aKXa+tzNjqRoXGIm4g0IggCfvvtN0yYMAHW1tb4448/0L9/f723g8PTVFbopAd96NAheHt7w9PTE9u2bdPFJYhIjxISEtCzZ0+MGjUKbdu2RWxsrEHCWYnD01QWiN6DTkhIwPLly7Fv3z5YW1ujf//+aNWqFerVqyf2pYhIDw4cOIARI0YgPT0dgYGBGD5yNKQyBZJTs4tVB5uIikf0gI6MjETr1q3h4OAAAPj4448REhKCb7/9VuxLEZEOpaWlYfz48diwYQOaN2+OrVu34p2aLtga8j9u00ikB6IPcT979ixfST8nJyckJCSIfRkiUkEqkyMlXYrk1GykpEshlZVswtSZM2fg5uaGTZs2Yfr06Th37hzeqenCbRqJ9Ej0HrRCoYCZ2X+VfARByPdzUeLi4sRuEmJiYkQ/pyGYyn0AvBex2draonLVWth/Oh5hFx7m9W67flATn3R0QeLTB8jKyiryPOfOncPatWvx+++/o1q1ali7di3c3d3x+J8EHLuSrLYO9p7jt9C1uQOSnieKfXvFZgzfiVh4L8ZHX/chekBXrVoVFy9ezPs5MTERTk5OGn++adOmkEgkorUnJiYGLVq0EO18hmIq9wHwXnRBucvT6wGaJc3FoYi7OP9XgkYVsnbt2oWFCxfiypUrGD58OH7++WfY29u/On+6FGHnr6n9fNiFh/isa0O88071Eu3VLBZj+U7EwHsxPmLfh1QqLbRjKnpAt23bFr/++iuSkpJga2uL0NBQzJ07V+zLENG/NN3laaBXY5WznRUKBQIDA/H999/jrbfeQlBQEHr27JnvGE3qYFerVA5yhYDNR6/zGTWRCEQP6CpVqmDChAkYNGgQZDIZ+vXrh2bNmol9GSL6l6a7PPXtXL9AQD969AiDBw/G8ePH0aFDB+zevRtVqlQp8HllT7iwkLa3s8L4/s0x5deCvfig8Hici3vKOtdExaSTQiU+Pj7w8fHRxamJ6A2a7vIkKPJvIvHHH3/gm2++gUwmw2+//QZ3d3eV4QwUXQe76we18Gf0/RL34omoIJb6JCrlNN3lycz81WTN5ORkDBgwAF988QUaN26c98xZ3WTOoupgd3SvgeMXHqptQ2j0fWQW8Q8JIvoPA5qolFP2btXxbOUMO4klwsLC4Orqij179mDevHkIDw/XuIiQujrYFStIStSLJ6LCsRY3USmn7N2ei3uqcoi5iqMdvFpXx5TJ3+GXX35Bo0aNEBQUVKKZqIXVwc78d0KYupB+vRdPREVjQBOZAGXvdu+J2wj9dwa1nY0lPFs5o27FNHT9sB1u3LgBPz8//PTTT7C1tS3xtaytLAo8RxYAjfZqtitiKJ6I/sO/LUQm4s3erUJQYGXgzxg9ZzacnJzw559/wtPTUyfX1qQX36dTPU4QIyoGBjSRCVH2buPj4zFw4EBERkbis88+w6pVq+Do6KjTa6vrxffpVI9LrIiKiQFNZEIEQcCGDRswfvx4WFhYYNu2bRgwYECxyu1qg3s1E4mHAU1kIp49e4YRI0bg4MGD6NSpEzZt2oRatdTP7tYFVc+oiaj4uMyKyAQcOnQIrq6u+PPPP/Hzzz8jLCzMIOFMROJhQBOVYunp6Rg5ciR69uyJatWq4eLFi5gwYQLMzflXm6i0499iolIqMjISbm5uWLduHb7//ntER0ejadOmhm4WEYmEAU1UyshkMsyYMQMdOnSAQqHA6dOnsWjRIlG3aSUiw+MkMaJS5MaNGxg4cCBiYmIwZMgQBAQEoEKFCoZuFhHpAHvQRKWAQqHAr7/+ivfeew/37t3D3r17sWHDBoYzkQljD5rIyD1+/BhDhgzBsWPH4O3tjfXr16Nq1aqGbhYR6Rh70ERGbNeuXXB1dcXZs2exevVqHD58mOFMVEYwoImMUEpKCnx9ffH555+jQYMGuHLlCkaNGqW3imBEZHgMaCIjIpXJcfBICN5t2hQ7duzAD7N+xJkzZ1C/fn1DN42I9IwBTWQkniamwKffUPTq4YWXmQI+9F2Cms37ID2r8D2Wich0cZIYkRGIOBuNnn0+R8qz+3B280KTjoNhYSVBUHg8zsU9xZKxHbgbFFEZwx40kZ5IZXKkpEuRnJqNlHQppDI55HI55i9YiE4ftkdWRio++OQHuHYZBQur/4qOJCRlYt/JO8iRyQ3YeiLSN/agifQgJS0bu0/cxrF/90m2lVjivdoWOPj7PERFnkX1hm3xbufRsLZVva45NPo++nauz12iiMoQBjSRjqWkZWNSYAQSkjIBvNqz+dalP7F/2TqYmZlh5ep1OHKzktoZ2pnZuYAgQCqTI0uam7fXsq3EEhKGNpFJYkAT6ZBUJseeE7fzwjknKxXXjq3E0zvn4Fj9Xbh7jUOP3p/h5C/hyJIWPhnsXRdHKARg89Hr+Xrhnq1qoV/n+nDg82kik8OAJtKhLGkuQqMfAAAS4i/iWugKyKTpaNxxMFze84GZuQVOxTyEZ6taCAqPV3kOezsrjP28Oab8+l8vXHluTiIjMl2cJEakQ4JCQFp6OmLDVuPCgXmwtnsL7b9Yirote8PM/NXQdHDUPfTpVB9VHO1UnqNXx7o4euZuvnB+HSeREZkmBjSRSFTN0o6JuYAzWyfi/rU/4dKiN9p/sRQVKtfO9zm5QoCVpTmWjO2AXh1dYCt5NbBlZ2OJ3h518VErZ4Sef6D22qHR95GpZoiciEofDnETieDNWdoSSyDnfgiO7vkNbzk6ofWnc/B2TVeVn/Vs5QyJlQXs7awxyLsJ+nVpkDcJzE5iiYwsmdrn08CrSWSCQtDFrRGRgTCgqUwQY/azqnNYW1sXmKWdnvQYEcEBeJlwG41aeiJ432bM23xN5RB1FUc79OlUL2/5lLWVRYGlVJn/TghTF9J2NpYwM2edbiJTwoAmk6dqDXJxZz8Xdo6+H9bLm6UtCALuXwvB9dMbYWEpwXs9puCdBm1xJT4NS/w6YO/J2wj99/N2NpbwbOWMPp3qFTm5S3mtwiaRAa964XYS/nUmMiX8G00m7c3eLVD82c/qzvHhezURGv0A2elJuBq6Aon3LqGyc3O4fewHm/KOAIA/Qm+iU4uaKoevNSk8IrGyQL/O9XEu7qlGvXAiMg0MaDJZb65BfpNy9vNAr8YQAJVD4EWdw8wMiI8Nx7WwVZDnStG080g4u3nlKzqSmZ0LhUJQOXytKQd7GywZ2wF7T5SsF05EpQ8DmkzW62uQC3P7YTLSs2TYe1L1EDjMzAo9h0yage/GjUbM4Z14q0o9NPeagPKO1QscJ9bz4Yr2NiXuhRNR6cOAJpMlKAS1E6vs7aww6pNmaguA/PRte5XnePEwDlf+/AXS9CR4fzoKeOcjmFuo/usk5vNhbXrhRFS6cB00mSzlUHVhun5QCyHn7qsdAs/Mzs13DnmuDNfDNyFq90yYmVuiy6DF+L+An1CtsupNLvh8mIhKigFNJks5VF2Yts3ewcmLD9WeQ1mGEwBSE+/hzPbJiL94AM7NPkbHgcshcayLK7cTscRPdZERluAkopLiEDeVCiVZx1zU7GeJlUWRBUCCo+7hl4ke+G31r7h4bCOsJOXxfu8ZqOLSEsCrHrLHezX4fJiIRMeAJqOnzTpmdbOf3yovKbIASGpyAvr08sb5iHC4t+qMWq2HQWFRLu8cPu2d83rIfD5MRGJiQJNRE2Mdc2G9WwEotACIIAh4fOMUboavh6WFGTZu3IgBX/giK0ee7xzX/4qFk6O7yHdNRMSAJiNWnHXMRfVcC+vdqhoCz8lKRWzYajy5HYnWbdpi+7atqFOnDgBAYp3/r4xczh2kiEg3OEmMjJYm65i13cVJOQSunOD17O4lhG8Zj2d3z2PW7Lk4ExGeF85ERPrEHjQZraLWMQPi7OJU0d4G/T6sjeijK3F+/2o0atwEm38Pxfvvt9DqvERE2mAPmoxWUeuYAXGqdF24cAGtPmiJdWtXY/z48bh8KYbhTEQGx4Amo1XUOmZAuypdubm5mDNnDtq0aYPMzEwcP34cy5cvh40N1y0TkeExoMloKdcxV3G0U/m+NlW6bt++jfbt22PWrFno378/YmNj0blzZ22bTEQkGgY0GbU3J3EB2lXpEgQBa9asgbu7O27evIkdO3Zg69atcHBw0EHriYhKjpPEyOiJVaXr6dOnGD58OI4cOYKPPvoIGzduRPXqBXefIiIyBgxoKhW0rdJ14MABjBgxAunp6QgMDMSYMWNgbs4BJCIyXvwNRSYtNTUVQ4cOxSeffIJatWrh0qVL8PPzYzgTkdHjbykyWREREXBzc8Pvv/+O6dOnIyoqCo0bNzZ0s4iINMKAJpOTk5ODadOmwcPDA+bm5oiIiMC8efNgbW1t6KYREWmMz6DJpPz111/w9fXFlStXMGLECPz8888oX768oZtFRFRs7EGTSVAoFAgICECLFi3w+PFjBAUFYe3atQxnIiq12IOmUu/hw4cYPHgwTpw4AR8fH6xbtw5OTk6GbhYRkVbYg6ZSbfv27XB1dUV0dDTWrVuHoKAghjMRmQQGNJVKSUlJGDBgAL788ku8++67uHr1KoYNGwYzM+02ziAiMhYMaCp1jh07hmbNmmHPnj2YP38+Tp8+jbp16xq6WUREomJAU6mRlZWFcePGwdPTExUqVEB0dDT8/f1hacmpFERkehjQVCpcunQJLVq0QGBgIMaNG4eYmBi89957hm4WEZHOMKDJqOXm5mLBggVo1aoVXr58idDQUAQEBMDW1jbfcVKZHCnpUiSnZiMlXQqpTG6gFhMRiYNjg2S0/v77bwwaNAiRkZH4/PPPsXLlSjg6OhY4LiUtG7tP3Max6AfIkubCVmIJz1a10K9zfTgUcztKIiJjoXUPOiAgAL/++mvez6mpqRg5ciS8vLzw5ZdfIjExUdtLUBkjCALWrVsHNzc3/PXXX9i+fTt27NhRaDhPCozAwfB4ZElzAQBZ0lwEhcdjUmAEktOy9d18IiJRlDig09LS4O/vj40bN+Z7PSAgAC1btkRwcDA+/fRTzJ8/X+tGUun25vCzY6XC1yknJCSgV69eGDFiBFq1aoXY2FgMGDCg0PPuOXEbCUmZqs+VlIl9J+8gh8PdRFQKlXiI+/jx46hduzaGDBmS7/VTp05h27ZtAIAePXpgzpw5kMlksLKy0q6lVCqpGn7u+kFNfFapct7ws1QmR5Y0F0cPH8I4v2+QlpaK5cuXY+zYsWq3hcyS5iI0+oHa64dG30ffzvW12kuaiMgQzARBELQ5gXJ428/PDwDQtGlTXLlyJW/pS8eOHbF7925UqVJF7XmkUini4uK0aQoZEQsLC1SvVQ/TVkWp7OFWcbTD4m/bQi4X8EdILAIW/4i7V0PhUMUF4/yXYIyvJxKfPkBWVlah16hRuwGGLzhRZFvW+XfGo3u3tLofIiJdatq0KSQSSb7XiuxBBwcHY+HChflec3FxwaZNmzS6qCAIantBmjRSGzExMWjRooVo5zOU0nYfUpkcW45eL3T4OTNbhmyZgFHT1+HEzkXIfPkMdd/vg4ZtByDmvgWmrYrCkrEdUFHNJK+UdClsJZZ5z55VsbOxhERirbM/u9L2vahjKvdiKvcB8F6Mkdj3oa5zWmRAe3l5wcvLS+OLOTk54fnz56hatSpyc3ORkZEBBwcHjT9PpqGo4ecPm1fD0FET8Of+DbC1fxttPpuHSjXezXtf+fx4oFfjQoenlbO1g8LjC72OZytn2Em4WIGISh/R10F7eHjgwIEDAICjR4+iZcuWfP5cBgkKodCebdqLh/hl1hD8uW8dajbphI4DA/KFs1Jo9H1kqukdS6ws0K9zfVRxtFP5fhVHO/TpVI/Pn4moVBK9azFu3DhMnToV3bt3h729PZYuXSr2JagUMDM3KzD8LAgK3Lt8FDciNuOtt+zRwmcqqtVvXeg5MrNzISjUT5FwsLfBkrEdsPfEbYT+OxHNzsYSnq2c0adTPbVD5ERExkzrgFZODlNycHDA6tWrtT0tlXJvDj9npb3A1dBAPL9/FU51WmLPzs34dX98kc+PzcyL3p2qor0NBnk3Qb8uDSAoBJiZm8FOYsmeMxGVanw4RzqhHH4+F/cUl6NCERu2Cgp5Lly7fo1arp74J8Ucnh/UQlCEOM+Pra0sGMhEZFIY0KQzQm4WXl5dj0tHdsLxnYZo9vE4OFWrha7v18THrZ0BAOf+elroMiw+PyaisowBTTpx/PhxDB48GE+ePMGsWT/i2/GTYGFuATNzMyS/SMgrUsLnx0REqjGgSVTZ2dnw9/fH8uXL0bBhQ0RFReH999/Pd8zfNxNRx7kWAD4/JiIqDAO6lFOWyVSGm63EEhIDhduVK1fg6+uLv/76C2PGjMHixYthZ6d6CdTr+PyYiKggBnQpZizbLMrlcixduhQzZ87E22+/jeDgYHTr1k1v1yciMkUM6FJKuc3i6xOslNssnot7WmSZTLHcvXsXgwYNwpkzZ9CvXz+sXr0alSpV0vl1iYhMneiVxEj3jGGbRUEQsHHjRjRr1gzXrl3Dli1bsGvXLoYzEZFIGNClkKbbLKork6mNxMRE9O3bF0OHDkXLli0RGxsLX19fmJkVXVSEiIg0w4AuhdTVuVbSpExmSRw5cgSurq44cuQIli5diuPHj6NWrVqiX4eIqKxjQJdCytna6mhaJlNTGRkZGD16NHr06IEqVarg4sWL+O6774q1lSgREWmOv11LIeVsbXXE2mZRKpMj7GQEmjVzw9q1a/Hdd5Nw/vx5uLq6an1uIiIqHAO6FNLXNouJSWnoN3AMPLt8iCeJqfD4YgEadRiErBzxh86JiCg/LrMqpXS9zeKFS9fg3fNTPH98CzWadMK7nYbDSlJO78u4iIjKKgZ0KaaLMpmCIODXFf+HyZMmQzC3QoseU1CtQdt8xyiXcQ30aswKYEREOsKALuXELJP5zz//YOjQofjzzz9R1aUFmnYdA5vyjiqPDY2+j76d6zOgiYh0hAFtQMZUR3vPnj0YNWoUsrKysHTZLzj5qJbadc26WsZFRESvMKANxFjqaL98+RJjx47F5s2b8f7772PLli2oUr02oheEqV1rLfYyLiIiyo+zuA1AWUf7YHh8Xggq62hPCoxAclo2gFc97JR0KZJTs1Gjdn1IRS7defr0aTRr1gzbtm3DDz/8gLNnz6Jhw4Z6XcZFRESq8TesnmlSR/v0pUfweK8G9uiohy2VSjFjxgwsW7YM9erVw9mzZ9GqVau895XLuM7FPVXZTrGWcRERUeEY0HpWVB1tezsruNevjMk62qnq2rVr8PX1RWxsLEaPHo2lS5eiXLlyBY7T9TIuIiJSjwGtZ0XV0e76QS0En7tf5E5VxV3iJJfLsXz5ckyfPh0VK1bEkSNH4O3trfYzuljGRUREmuEzaD0rqo5222bv4OTFh2rPUdydqu7fv48uXbpg8uTJ6N69O+Li4ooMZyVrKws4lJegYgUbOJSXMJyJiPSEAa1nRU3AsrIwF22nKkEQsHnzZjRr1gyXLl3Cxo0bsXfvXrz99tvFbjcREekXA1rPiqqjLQgQZaeqFy9e4NNPP8VXX30FNzc3XL16FYMHD+aezUREpQQDuhCvL3FKSZeKusRJOQGrV0eXvDC2s7FEb4+6qFzRRuslTiEhIXB1dcXBgwfx008/4eTJk6hTp45o7SciIt3jJDEV9FFERN0ErJIuccrMzMTkyZOxcuVKvPvuuzh69Cjc3d1FaS8REekXA/oNyiIiulji9KbC6miXZInT+fPnMXDgQNy6dQsTJ07E/PnzYWPDpVBERKUVA/o1mhQR0dcuTm/2sHNkOahYoVyB6+bm5mLBggWYM2cOqlWrhuPHj6Nz5846bRsREeken0G/pqgiIkDxlzhp4/UlTo/u3S4Qzrdu3UK7du0wa9Ys9O/fH7GxsQxnIiITwR70a4oqIgIYxy5OgiBg7dq1mDhxIiQSCXbs2IHPP//cYO0xpl25iIhMBQP6NcpwMeZdnJ4+fYphw4bh6NGj+Oijj7Bx40ZUr17dYO0xll25iIhMDYe4X2Psuzjt27cPTZs2xYkTJxAYGIiQkBCDh7Mmu3IREVHxMaBfU1QREUPt4pSamorZs2ejb9++cHZ2xqVLl+Dn5wdzc8N9fZpOqMsReYtMIqKyggH9BnVFRMRcYqWpiIgIuLm54ciRI5gxYwaioqLQuHFjvbZBFWObUEdEZGr4DFoFY9jFSSqVYtasWVi8eDFcXFywbt06DBkyRG/XL0ppmVBHRFRaMaALUVgREX2Ii4uDr68vrl69ihEjRuDnn3/GzZs3DdKWwpSGCXVERKUZh7iNiEKhwPLly9GyZUs8efIEBw8exNq1a1G+fHmdXbOkNceNfUIdEVFpx9+eRuLBgwcYPHgwTp48iZ49e+K3336Dk5OTTq+pzRIpiRY1w4mIqGjsQRuYIAjYtm0bmjVrhgsXLmD9+vU4cOCAXsJZ2yVSxjahjojIlLAHbUBJSUn45ptvsHPnTrRr1w6bN2+Gi4uLzq8rZs1xY5hQR0RkitiDNpBjx47B1dUVe/fuxfz583H69Gm9hDMg/hKp12uGO5SXMJyJiETAgNazzMxMjB07Fp6ennjrrbcQHR0Nf39/WFjoL9S4RIqIyPhxiFuPYmJi4Ovri//9738YN24cFi5cCFtbW51eU9VGFlwiRURk/BjQepCbm4uffvoJP/74I6pUqYJjx46ha9euOr9uYbO0P+1SH56taiEoPL7Qz3KJFBGRYfE3sI79/fffGDhwIKKiotC/f3+sXLkSFStW1Pl1lbO0X58IppylHfv3C8wa3ppLpIiIjFiZfQZd0gIdmhIEAevWrYObmxtu3LiB7du3448//tBLOBc1Szv+8UuEX36EJX5cIkVEZKzKZA9a13sYJyQkYMSIETh06BC6dOmCjRs3ombNmiK0XDOazNL+I/QmOrWoySVSRERGqswFtLqh33NxT7XuPR48eBDDhw9HamoqAgICDLItpKaztBUKwaA1x4mIqHBlaohbl3sYp6WlYfjw4ejVqxeqV6+OmJgYjBs3ziB7NitnaavDWdpERMatTAW0rvYwjoyMhLu7OzZu3Ihp06YhOjoa7777rjZN1Qo3siAiKv3KVECLXaAjJycH06dPR4cOHaBQKHD69GksWLAA1tbWYjS3xJQbWVRxtFP5PmdpExEZvzIV0GIO/V6/fh2tW7fGggULMHjwYFy9ehXt27cXq6la40YWRESlW5ka41QO/WpToEOhUGDFihX4/vvvUb58eezfvx+9e/fWQWu1x40siIhKrzIV0NruYfzo0SMMGTIEYWFh6NGjB9atW4cqVaroutla4SxtIqLSqUwNcQMlH/rduXMnXF1dERkZiTVr1uDgwYNGH85ERFR6laketFJxhn6Tk5Px7bffYvv27WjdujU2b96M+vXrG6DVRERUlpTJgAY0G/o9fvw4Bg8ejKdPn2Lu3LmYOnUqLC3L7B8ZERHpUZkb4tZEdnY2Jk6ciK5du6JcuXKIiorCjBkzGM5ERKQ3TJw3XLlyBV9++SWuX7+Ob7/9Fj/99BPs7FSvJyYiItKVEvegY2Ji0K9fP/Tq1QtfffUVHj9+DABITU3FyJEj4eXlhS+//BKJiYmiNVaX5HI5Fi1ahA8++ADJyckICQnBr7/+ynAmIiKDKHFAT548GfPmzUNQUBB8fHwwb948AEBAQABatmyJ4OBgfPrpp5g/f75ojdWV+Ph4eHh4YNq0aejduzdiY2Px8ccfG7pZRERUhpUooHNycjBu3Dg0atQIANCwYUM8efIEAHDq1Cn4+PgAAHr06IHw8HDIZDKRmisuQRCwYcMGuLm5ITY2Flu2bMHOnTtRqVIlQzeNiIjKuBIFtLW1NXr16gXgv8paXbt2BQA8e/YMlStXBgBYWlqifPnySEpKEqm54klMTESfPn0wbNgwtGzZErGxsfD19YWZGXd4IiIiwzMTBEHtzhDBwcFYuHBhvtdcXFywadMm5OTkYOrUqXj58iVWr14NKysrNG3aFFeuXMmb8dyhQwfs27cvL7QLI5VKERcXp+XtaCYiIgJz585FWloaxowZgy+++KJY20JaWFjgLYdKsLN/C4AZAAGZaS/xMuUF5PLib1VJRERlW9OmTSGRSPK9VuQsbi8vL3h5eRV4PSMjA19//TUcHBywatUqWFlZAQCcnJzw/PlzVK1aFbm5ucjIyICDg4NWjSwJqUyOLGkupNIcSCTWsJVYQibNwnfffYe1a9eiWbNm2Lp1K1xdXYt97pS0bOw+cRvHoq8hS5qbV+O7X+dGcNDRJhQxMTFo0aKFTs6tb7wX42Qq92Iq9wHwXoyR2PehrnNa4mVWkydPhrOzM2bPnp2v9+nh4YEDBw5g9OjROHr0KFq2bJkX3vryX4A+yAvQug7J2LXmR9y9G48pU6Zgzpw5JfqHQEpaNiYFRuSr5Z0lzUVQeDzOxT3lTlFERCSKEgX09evXcfz4cdSrVw+ffPIJgFc9599++w3jxo3D1KlT0b17d9jb22Pp0qWiNrgobwaoQp6LKye2Y/f5PSj/VmUcOhqK7t26lujcUpkce07cVrnRBgAkJGVi38k7GOjVmBtUEBGRVkoU0E2aNMHNmzdVvufg4IDVq1dr1aiSejNA05Me4XLwcrxM+Bs1mnTCu51G4GlOVeTI5CUK0CxpLkKjH6g9JjT6Pvp2rs+AJiIirZhUqc/XA1Quk+LMH1OQ+fIZWvSYAvdu42AlsUNo9H1kSnNLdH5BISCriM9mZudCUKidd0dERFQkkyr1+XqAWlhJ4OY5FhWrNYBNece8Y7QJUDNzM9hKLNWGtJ2NJczMuVSLiIi0Y1I9aGWAKlWr3zpfOAPaBahytrY6nq2cYfdvG6QyOVLSpUhOzUZKuhRSGZdgERGRZkyqB60M0KDw+EKPeT1Ai0tiZYF+nevjXNxTlRPFqjjaoU+nerC2slA5k/zVUqz6OluKRUREpsOketDKAK3iqHqDi9cDtKQc7G2wZGwH9Oroktdbt7OxRG+PunlLrJQzyQ+Gx+cNhyuXYk0KjEByWnaJr09ERGWDSfWggf8CdO+J2wj9t/dqZ2MJz1bO6NOpnihrlCva22CQdxP069IAgkKAmbkZ7CSWsLay4FIsIiIShckFNJA/QJWVxJQBKhZrKwuV5+NSLCIiEoNJDXG/ztrKAg7lJXh07xYcykv0FoZcikVERGIw2YA2lDdnkqvCpVhERFQUBrTIirsUi4iISBUGtMj0MZOciIhMHwNaBzRZikVERKQOx1l1RN1SLCIioqIwoHWosKVYREREReEQNxERkRFiQBMRERkhBjQREZERYkATEREZIQY0ERGREWJAExERGSEGNBERkREymnXQgvBqd6ecnBzRzy2VSkU/pyGYyn0AvBdjZSr3Yir3AfBejJGY96HMPGUGvs5MUPWqAaSlpeHWrVuGbgYREZHeNWjQAPb29vleM5qAVigUyMjIgJWVFczMuBUjERGZPkEQIJPJUK5cOZib53/qbDQBTURERP/hJDEiIiIjxIAmIiIyQgxoIiIiI8SAJiIiMkIMaCIiIiPEgCYiIjJCDGgiIiIjZDSlPrUVEBAACwsL+Pn5AQBSU1MxadIkPHz4EI6OjggICEDlypXzfUYQBCxevBgnT56Eubk55s6dixYtWhii+fm8ePECQ4cOzfs5LS0NycnJuHz5cr7jHj9+jB49eqBWrVoAgLfffhvr16/Xa1s1sX//fixbtgyVKlUCAHz44YeYMGFCvmNycnIwffp0xMXFwcbGBkuXLkXdunUN0Vy1YmJisHDhQshkMjg4OGDBggWoXr16vmOM+Xs5dOgQVq1ahdzcXHz11Vf48ssv871/48YNTJ8+HRkZGWjZsiVmz54NS0vj/DWxYsUKBAcHAwA8PDwwZcqUAu/v3bsXFSpUAAB89tlnBe7XWAwcOBBJSUl5f9Zz5syBm5tb3vul5XvZvXs3tm7dmvfzo0eP0KtXL/zwww95rxn795Keno7+/ftj9erVqFGjBiIjI7Fw4UJIpVJ4eXkV+N0FAP/88w8mT56MFy9eoE6dOli6dCnKlSunfWOEUi41NVWYNm2a0KxZMyEwMDDv9dmzZwtr1qwRBEEQ9u/fL4wbN67AZ4ODg4URI0YIcrlciI+PFz766CNBJpPpq+kakcvlgq+vr3Dw4MEC74WEhAgzZ840QKuKZ86cOcKhQ4fUHrNu3bq8ezl//rzw6aef6qNpxdapUyfhxo0bgiAIwu7du4XRo0cXOMZYv5enT58KnTp1EpKTk4WMjAzBx8dHuH37dr5junfvLly+fFkQBEGYNm2asG3bNgO0tGhnz54VPv/8c0EqlQo5OTnCoEGDhNDQ0HzHjBo1Srh06ZKBWqg5hUIhtG/fXu3vntLyvbzu1q1bwkcffSS8ePEi3+vG/L1cuXJF6NGjh/Duu+8KDx8+FLKysgQPDw/hwYMHgkwmE4YOHSqcOnWqwOdGjhwpHD58WBAEQVixYoWwePFiUdpT6oe4jx8/jtq1a2PIkCH5Xj916hR8fHwAAD169EB4eDhkMlm+Y06fPg1vb2+Ym5ujTp06qFatWoFeqqHt3bsXtra2effyutjYWNy6dQu9evXCoEGDcPPmTQO0sGixsbHYv38/fHx8MGnSJLx8+bLAMadOnULPnj0BAO+//z6SkpLwzz//6LupauXk5GDcuHFo1KgRAKBhw4Z48uRJgeOM9XuJjIxE69at4eDgADs7O3z88ccICQnJe//x48fIzs6Gu7s7AKBPnz753jcmlStXxtSpU2FtbQ0rKyvUrVu3wP8vcXFxWLNmDXx8fDBnzhyj3aghPj4eADB06FD07NkzXw8UKF3fy+t+/PFHTJgwAY6OjvleN+bvZdeuXZg1axacnJwAANeuXYOzszNq1qwJS0tL+Pj4FPizl8lkuHDhAj7++GMA4n4/pT6ge/fujZEjR8LCwiLf68+ePcsb0ra0tET58uWRlJRU4BjlFwG8+kv/9OlT3TdaQ3K5HKtXr8Z3332n8n2JRIKePXti//79GDZsGMaMGaOT3cC0VblyZXzzzTc4ePAgqlWrhjlz5hQ45vXvS/kZY/ouAMDa2hq9evUC8Kp2/IoVK9C1a9cCxxnr9/Lmn7GTkxMSEhIKfb9y5cr53jcm9evXzwuse/fuITg4GB4eHnnvZ2RkoHHjxpg8eTL279+P1NRUrFy50kCtVS81NRVt2rTB//3f/2HTpk3YsWMHzp49m/d+afpelCIjI5GdnQ0vL698rxv79zJ//ny0bNky7+ei/s4AQHJyMsqXL5/3yEHM78f4HmIUIjg4GAsXLsz3mouLCzZt2qTR5wVBKFCIXKFQ5NuYQ9UxuqbuviIiIlC7dm00bNhQ5WeVz9uBV8/gli1bhvj4+Lwenr5p8h0NHz4cH330UYHPCoJg8O/ideruJScnB1OnTkVubi5GjRpV4LPG9r0oqfr//fWfi3rfGN2+fRujRo3ClClTULt27bzXy5Urh99++y3v56FDh8Lf31/l80NDa968OZo3b573c79+/XD69Gm0a9cOQOn8Xnbs2FFgVBMoXd8LoNmfvarXxPp+Sk1Ae3l5FfjXmDpOTk54/vw5qlatitzcXGRkZMDBwSHfMVWrVsWzZ8/yfn7+/Hm+HrU+qLuvsLAweHt7F/rZLVu2oEePHqhYsSKAV/+jGHLiiKp7SUtLw6ZNmzB48GAAr9r45mgHAFSpUgXPnj3Lm1hliO/idYV9LxkZGfj666/h4OCAVatWwcrKqsAxxva9KFWtWhUXL17M+zkxMTHfn3HVqlWRmJiY97Ohv4OixMTEYOzYsfD390f37t3zvffPP/8gMjIS/fr1A2A834EqFy9ehEwmQ5s2bQAUbGtp+15ycnJw4cIFLFq0qMB7pel7AQr+2b/5dwYAHB0dkZaWBrlcDgsLC5XHlFSpH+IujIeHBw4cOAAAOHr0KFq2bFngl2nHjh1x6NAhyOVy3L9/H/fu3YOrq6sBWqvalStX8g23vOnChQvYs2cPAOD8+fNQKBRwcXHRV/M0Ymdnh3Xr1uHq1asAgK1bt6rsQXt4eCAoKAjAq19YEokE77zzjl7bqonJkyfD2dkZAQEBsLa2VnmMsX4vbdu2RVRUFJKSkpCVlYXQ0FB07Ngx7/3q1atDIpEgJiYGABAUFJTvfWPy5MkTjBkzBkuXLi0QzgBgY2ODJUuW4OHDhxAEAdu2bVP5/50xSEtLw+LFiyGVSpGeno79+/fna2tp+l4A4ObNm6hduzbs7OwKvFeavhcAcHNzw927d3H//n3I5XIcPny4wJ+9lZUVWrZsiaNHjwIADhw4IN73I8pUMyMQGBiYbxZ3cnKyMGrUKMHb21v4/PPPhYcPHwqCIAhhYWGCv7+/IAivZk8uWrRI8Pb2Fry9vYWIiAiDtL0wzZo1E7Kzs/O9tn37diEgIEAQhFezcgcPHix0795d6NOnT97sYmNz4cIFoXfv3kK3bt2E0aNHC6mpqYIg5L+X7OxsYcqUKYK3t7fQu3dvIS4uzpBNVumvv/4SGjRoIHh7ews9e/YUevbsKQwfPlwQhNLzvRw8eFDo3r274OnpKaxdu1YQBEEYPny4cO3aNUEQBOHGjRtC3759hY8//liYOHGiIJVKDdncQs2dO1dwd3fP+x569uwpbN++Pd+9hISE5N3r1KlTjfZeBEEQli9fLnTr1k3w9PQUNm3aJAhC6fxeBEEQjhw5IowfPz7fa6Xte+nUqVNeZkRGRgo+Pj6Cp6enMH/+fEGhUAiCIAj+/v5CWFiYIAiC8OjRI8HX11fw8vIShg4dKqSkpIjSDu4HTUREZIRMdoibiIioNGNAExERGSEGNBERkRFiQBMRERkhBjQREZERYkATEREZIQY0ERGREWJAExERGaH/BwxrNndE3q+SAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "original_x = x[:,0]\n",
    "print(original_x)\n",
    "original_y = y\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "sns.set(rc={'figure.figsize':(8,6)}, style=\"whitegrid\")\n",
    "sns.scatterplot(x=original_x, y=original_y,\n",
    "                #hue=labels, # let's use different colors for the two classes\n",
    "                palette=sns.color_palette(['darkred', 'darkblue']),\n",
    "                s=100)\n",
    "sns.lineplot(x=original_x, y=predictions, color='black')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.6 **[2pt]** Find Linear Regression in scikit-learn and train a model on the data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The input to the `fit()` function should be a matrix and a vector, so try forcing `actual_x` into a $n\\times 1$ matrix by using `actual_x.reshape((-1, 1))`. If you want to predict the outputs, you simply need to pass the same data matrix to the method `predict()`.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-20.77122881 -19.94590032 -19.12057182 -18.29524333 -17.46991484\n",
      " -16.64458634 -15.81925785 -14.99392936 -14.16860086 -13.34327237\n",
      " -12.51794387 -11.69261538 -10.86728689 -10.04195839  -9.2166299\n",
      "  -8.39130141  -7.56597291  -6.74064442  -5.91531593  -5.08998743\n",
      "  -4.26465894  -3.43933045  -2.61400195  -1.78867346  -0.96334497\n",
      "  -0.13801647   0.68731202   1.51264051   2.33796901   3.1632975\n",
      "   3.98862599   4.81395449   5.63928298   6.46461147   7.28993997\n",
      "   8.11526846   8.94059695   9.76592545  10.59125394  11.41658243\n",
      "  12.24191093  13.06723942  13.89256791  14.71789641  15.5432249\n",
      "  16.3685534   17.19388189  18.01921038  18.84453888  19.66986737]\n",
      "2.0220548089062516 -0.550680720094807\n"
     ]
    }
   ],
   "source": [
    "from sklearn.linear_model import LinearRegression\n",
    "linear = LinearRegression()\n",
    "reg = linear.fit(x, original_y)\n",
    "sci_w, sci_b = [reg.coef_[0], reg.intercept_]\n",
    "sci_pred = []\n",
    "sci_pred = reg.predict(x)\n",
    "    \n",
    "print(sci_pred)\n",
    "print(sci_w, sci_b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.7 **[1pt]** Plot in a single figure: (i) the data points as a scatterplot; (ii) the model you learned using your implementation of Linear Regression; (iii) the model you trained using the scikit-implementation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Careful, it may be that you plot both but they are exactly the same, so they are superimposed and you only see one line. To verify this you can try plotting them with different colors and different thickness, or changing the linestyle (e.g. one normal line and one dashed line). A list of available linestyles can be found in the [matplotlib documentation](https://matplotlib.org/3.5.1/gallery/lines_bars_and_markers/linestyles.html).\n",
    "\n",
    "To get the parametrization of the sklearn implementation use the following:  \n",
    "`w_skl = [trained.coef_[0], trained.intercept_]`  \n",
    "Do you understand what this does? Can you see how this corresponds to what we did last week? In future assignments you will need to find the model parametrization by yourself!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fcfa057a520>"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.set(rc={'figure.figsize':(8,6)}, style=\"whitegrid\")\n",
    "sns.scatterplot(x=original_x, y=original_y,\n",
    "                #hue=labels, # let's use different colors for the two classes\n",
    "                palette=sns.color_palette(['darkred', 'darkblue']),\n",
    "                s=100)\n",
    "sns.lineplot(x=original_x, y=sci_pred, color='red')\n",
    "sns.lineplot(x=original_x, y=predictions, color='black', style=True, dashes=[(2,2)])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Linear Discriminant Analysis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We switch now into *binary classification*. Let's load the iris dataset once again for this exercise, and carefully selecting the data to have an easy binary classification problem (for now). Notice we are **not** using classes ${-1, +1}$ anymore, because we do not need to compute a Margin here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n",
       "       2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n",
       "       2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "from sklearn.datasets import load_iris\n",
    "iris_x, iris_y = load_iris(return_X_y=True) # print these points to understand them!\n",
    "x1 = np.array([r[0] for r in iris_x]) # first feature\n",
    "x2 = np.array([r[2] for r in iris_x]) # third feature\n",
    "\n",
    "x = np.array([x1, x2]).transpose() # numpy gives us transpose() for free\n",
    "# Reduce the three classes into two for binary classification {1, 2}\n",
    "y = np.array([1 if y in [1,2] else 2 for y in iris_y])\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To solve LDA we need to find the parametrization $\\theta_y=(\\mu_y, \\Sigma, \\pi_y)$. Since $\\mu$ and $\\pi$ are class-dependent, remember to first split the input data based on which class it belongs to."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.1 **[1pt]** Write a (Python) function that takes a dataset (inputs and labels) in input and returns a dictionary hashing each of the $m$ classes to the a list of the points belonging to that class. We will call this `partition` in the next questions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hint: the method `dict.get(<key>, <def>)` can be used to fetch values from a dictionary same as `dict[<key>]`, but when the key is not found it returns the second argument, which is the _default value_... what if you pass an empty list..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'x' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[0;32mIn [2]\u001b[0m, in \u001b[0;36m<cell line: 8>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      6\u001b[0m         partition\u001b[38;5;241m.\u001b[39mget(y[i])\u001b[38;5;241m.\u001b[39mappend([x[i][\u001b[38;5;241m0\u001b[39m], x[i][\u001b[38;5;241m1\u001b[39m]])\n\u001b[1;32m      7\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m partition\n\u001b[0;32m----> 8\u001b[0m partition \u001b[38;5;241m=\u001b[39m get_partition(\u001b[43mx\u001b[49m, y)\n\u001b[1;32m      9\u001b[0m \u001b[38;5;28mprint\u001b[39m(x)\n",
      "\u001b[0;31mNameError\u001b[0m: name 'x' is not defined"
     ]
    }
   ],
   "source": [
    "def get_partition(x, y):\n",
    "    partition  = {}\n",
    "    for i in range(0, len(x)):\n",
    "        if y[i] not in partition:\n",
    "            partition[y[i]] = []\n",
    "        partition.get(y[i]).append([x[i][0], x[i][1]])\n",
    "    return partition\n",
    "partition = get_partition(x, y)\n",
    "print(x)\n",
    "#print(partition)\n",
    "#print(len(partition[1]), len(partition[2]), len(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.2 **[1pt]** Write a function that takes the `partition` in input and returns a dictionary hashing each class to its corresponding prototype $\\mu_y$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hint: function `dict.items()` returns a list of pairs `(key, value)` from the dictionary.\n",
    "Then a _dictionary comprehension_ works same as a list comprehension, with a `for` loop that generates elements. Only this time you need to pass both a key and a value like this:\n",
    "```python\n",
    "d = { the_key: compute_value(a, b) for a, b in another_dict.items() }\n",
    "```\n",
    "If you can use that then the answer is basically one line. If it is complicated instead, write explicit `for` loops, which are exactly equivalent (and perhaps even more readable:\n",
    "```python\n",
    "d = {}\n",
    "for a, b in another_dict.items():\n",
    "    d[the_key] = compute_value(a, b)\n",
    "```\n",
    "Just find a style that is comfortable with you. May take a few weeks but you will get there."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{2: [5.005999999999999, 1.4620000000000002], 1: [6.261999999999998, 4.906000000000001]}\n"
     ]
    }
   ],
   "source": [
    "def get_total(index, values):\n",
    "    total = 0\n",
    "    for val in values:\n",
    "        total+= val[index]\n",
    "    return total\n",
    "\n",
    "def calculate_mean( values):\n",
    "    #print(values)\n",
    "    m1 = get_total(0,values)/(len(values))\n",
    "    m2 = get_total(1,values)/(len(values))\n",
    "    #print(m1,m2)\n",
    "    return [m1, m2]\n",
    "def get_means(partition):\n",
    "    means = {}\n",
    "    for key, val in partition.items():\n",
    "        means[key] = calculate_mean(val)\n",
    "    return means\n",
    "means = get_means(partition)\n",
    "print(means)\n",
    "#partition[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.3 **[1pt]** Write a function that takes the `partition` in input and returns a dictionary hashing each class to its corresponding prior $\\pi_y$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{2: 0.3333333333333333, 1: 0.6666666666666666}\n"
     ]
    }
   ],
   "source": [
    "def get_prior_dict(partition):\n",
    "    total = 0\n",
    "    priors = {}\n",
    "    for key, val in partition.items():\n",
    "        total += len(val)\n",
    "    for key, val in partition.items():\n",
    "        priors[key] = len(val)/total\n",
    "    return priors\n",
    "priors = get_prior_dict(partition)\n",
    "print(priors)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.4 **[4pt]** Write a function that takes the `partition` in input and the class-wise center estimates (the means from above) and returns the corresponding $\\Sigma$ (one for all classes and all inputs).\n",
    "You may need to use `np.concatenate()` to join the $x_i - \\hat{\\mu}_{y_i}$ from each class. Print the `array.shape` (property not method so no `()`) to verify if your linear algebra is on point so far: the covariance matrix between all inputs should have as many rows (and columns) as the number of features (hint: that's 2). Example: `assert sigma.shape == (2,2)` should not raise an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.33055867 0.30456133]\n",
      " [0.30456133 0.45969467]]\n"
     ]
    }
   ],
   "source": [
    "def get_new_sigma(partition, means):\n",
    "    sigma = []\n",
    "    for key, points in partition.items():\n",
    "        curr_mean = means.get(key)\n",
    "        #val1, val2 = 0, 0\n",
    "        for point in points:\n",
    "            difference = np.subtract(point, curr_mean)\n",
    "            #print(difference)\n",
    "            #transposed = np.transpose([difference])\n",
    "            sigma.append(np.array(difference))\n",
    "    sigma_t = np.transpose(sigma)\n",
    "    res = (1/len(sigma))*np.dot(sigma_t, sigma)\n",
    "    #print(res)\n",
    "    return res\n",
    "sigma = get_new_sigma(partition, means)   \n",
    "print(sigma)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.5 **[5pt]** Write the function for the decision boundary of LDA $f(x)$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can find the logarithm in the `math` module: `from math import log` then just `l = log(a)`. You need to implement the equations for $w$ and $q$ from the slides: this cell will be very math heavy, be careful though and you should be able to get it right in few lines. Remember to check for the shape of $w$ and $b$ to verify if your matrix products are computed the right way. You want $w$ to be of length 2, and $b$ is a scalar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "65.6139271748771\n",
      "61.39452614748603\n",
      "[-7.96528842 12.76916894] 4.912548207951017\n"
     ]
    }
   ],
   "source": [
    "from math import log\n",
    "sigma_i =  np.linalg.pinv(sigma)\n",
    "difference = np.subtract(means.get(1) ,means.get(2))\n",
    "w = np.dot(sigma_i, difference)\n",
    "#print(w)\n",
    "u2_t = np.transpose(np.array(means.get(2)))\n",
    "u1_t = np.transpose(np.array(means.get(1)))\n",
    "#print(u2_t, sigma_i)\n",
    "step1 = np.dot(u2_t, sigma_i)\n",
    "step2 = 0.5*np.dot(step1, np.array(means.get(2)))\n",
    "print(step2)\n",
    "step3 = np.dot(u1_t, sigma_i)\n",
    "step4 = 0.5*np.dot(step3, np.array(means.get(1)))\n",
    "print(step4)\n",
    "b = step2 - step4 + log(priors.get(1)) - log(priors.get(2))\n",
    "print(w,b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.6 **[2pt]** Plot the LDA decision boundary on top of the data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Notice that we are using different data from the Linear Regression questions above, and that our model now generated $w$ and $b$ separately, so you **need** to adapt the plotting functions -- actually it's quicker to just rewrite them.\n",
    "- Plotting is one of few applications where generalizing your code just makes for a stunted replica of the original (better) interface, so specialize when needed but for different applications just write a new one rather than reusing your code.\n",
    "- Remember that we already had a good plotting function for a classification problem just last week, why don't you check it out again?\n",
    "- Finally, remember that you already have code that converts a parametrization from $w$ and $b$ to $m$ and $q$ (last assignment), you can simply copy+paste it here to simplify your generation of the model's points."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 363,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "m: 0.6237906674023647, q: -0.38545304584336904\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fcf85f60ac0>"
      ]
     },
     "execution_count": 363,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "def wb2mq(w, b):\n",
    "    assert len(w) == 2, \"This implementation only works in 2D\"\n",
    "    assert w[0] != 0 and w[1] != 0 and b != 0 # avoid edge cases for now\n",
    "    return [w[0]/-w[1], b/-w[1]] # m and q\n",
    "\n",
    "def params2boundary(w, b):\n",
    "    m, q = wb2mq(w, b)\n",
    "    print(f\"m: {m}, q: {q}\")\n",
    "    return lambda x: m*x + q\n",
    "equation = params2boundary(w, b)\n",
    "sns.set(rc={'figure.figsize':(8,6)}, style=\"whitegrid\")\n",
    "sns.scatterplot(x=x1, y=x2,\n",
    "                hue=y, # let's use different colors for the two classes\n",
    "                palette=sns.color_palette(['darkred', 'darkblue']),\n",
    "                s=100)\n",
    "sns.scatterplot(x=means.get(1), y = means.get(2), hue=[1,2], palette= sns.color_palette(['green', 'pink']), s=300)\n",
    "my_y = [equation(inp) for inp in x1]\n",
    "my_y\n",
    "sns.lineplot(x=x1, y=[equation(inp) for inp in x1], color='black')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.7 **[1pt]** Find LDA on scikit-learn; train a model on the data and add it to the print above (data + model from your implementation)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You ned to pass the correct `solver` parameter to the sklearn constructor, check the documentation to understand what I mean. If you do not the result should still look exactly the same as your implementation (because the data is linearly separable), but you should be aware of which technique your library uses and we have not gotten to SVD yet.  \n",
    "Remember to make sure that you can distinguish the two boundaries even if they overlap (e.g. use different colors). If you use our conversions from last exercise you should also see the printed values of $m$ and $q$ and they are likely to differ in the least significant digits even though the graph looks the same.  \n",
    "Also consider that LDA is a **multiclass method**, and so its parametrization is in principle a list for the many boundaries: you need to access the coefficients of the _first_ (and here, only) boundary using `[trained_model.coef_[0], trained_model.intercept_[0]]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'x' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[0;32mIn [1]\u001b[0m, in \u001b[0;36m<cell line: 3>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01msklearn\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mdiscriminant_analysis\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m LinearDiscriminantAnalysis\n\u001b[1;32m      2\u001b[0m lda \u001b[38;5;241m=\u001b[39m LinearDiscriminantAnalysis()\n\u001b[0;32m----> 3\u001b[0m lda\u001b[38;5;241m.\u001b[39mfit(\u001b[43mx\u001b[49m, y)\n\u001b[1;32m      4\u001b[0m w, b \u001b[38;5;241m=\u001b[39m lda\u001b[38;5;241m.\u001b[39mcoef_[\u001b[38;5;241m0\u001b[39m], lda\u001b[38;5;241m.\u001b[39mintercept_[\u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m      5\u001b[0m \u001b[38;5;28mprint\u001b[39m(w,b)\n",
      "\u001b[0;31mNameError\u001b[0m: name 'x' is not defined"
     ]
    }
   ],
   "source": [
    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n",
    "lda = LinearDiscriminantAnalysis()\n",
    "lda.fit(x, y)\n",
    "w, b = lda.coef_[0], lda.intercept_[0]\n",
    "print(w,b)\n",
    "y_sci = lda.predict(x)\n",
    "\n",
    "sns.set(rc={'figure.figsize':(8,6)}, style=\"whitegrid\")\n",
    "sns.scatterplot(x=x1, y=x2,\n",
    "                hue=y, # let's use different colors for the two classes\n",
    "                palette=sns.color_palette(['darkred', 'darkblue']),\n",
    "                s=100)\n",
    "sns.scatterplot(x=means.get(1), y = means.get(2), hue=[1,2], palette= sns.color_palette(['green', 'pink']), s=300)\n",
    "sci_equation = params2boundary(w, b)\n",
    "sns.lineplot(x=x1, y=[sci_equation(inp) for inp in x1], color='orange')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## At the end of the exercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bonus question reward no points! Answering this will have no influence on your scoring, not at the assignment and not towards the exam score. But solving it will reward you with skills that will make the next lectures easier, give you real applications, and will be very good practice towards the exam.\n",
    "\n",
    "The solution for this questions will not be included in the regular lab solutions pdf, but you are welcome to open a discussion on the Moodle: we will support your addressing it, and you may meet other students that choose to solve this, and find a teammate for the next assignment that is willing to do things for fun and not only for score :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see some multiclass classification. Copy the code loading the Iris dataset, you want to extract the same features (so you can plot in 2D), but keep the three classes.  \n",
    "_[think: does it matter what label does each class have? Could you use strings such as `['a', 'b', 'c']`?]_  \n",
    "Then run the scikit-learn LDA on the data to obtain a trained model. At this point you can open up the trained coefficients again, and rather than taking only the first like you did with `[trained.coef_[0], trained.intercept_[0]]`, you should have TWO $w$ vectors and TWO $b$ constants **per each pair** of classes.\n",
    "_[think: the space is actually split in several subspaces. Can you derive how many? Can you design a decision tree on top of the boundaries to do the classification as the number of boundaries grow?]_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### BONUS **[ZERO pt]** Plot the boundaries classifying the three species of Iris in the dataset based on the two features used so far."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Final considerations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Stop for a moment and think how hard it was to derive these equations (in the lecture), and how hard it was instead to implement them (once you get them right). These are two very different skills.  \n",
    "To understand the derivation you need to think hard, express your concept in math (actually requiring broad knowledge of many of its subfields), see it through with absolute precision, and finally correctly solve the equations.  \n",
    "To implement the method, you need to map the math to the correct function calls (hard, but arguably less), and you only ever work with the final solution, but you deal with programming languages and libraries and documentations.  \n",
    "This is the reason why so many people nowadays broadly advertise machine learning skills after taking short tutorials. But if you do not understand what a parameter is for, you will only be guessing which value to use.\n",
    "\n",
    "The reason why you are sweating so much on this course is to gain an edge over all of those who only ever learn to _use_ the tools: by instead _making_ the tools you understand them from the inside out, their applications and limitations, and even become capable of adapting and improving them.  \n",
    "Keep up: this course is not easy, but machine learning has become unavoidable in your field, and these foundations will enable you to bend the whole field to your needs."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}