Homework-5-TenzinChoedon.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Homework 5 - Clustering\n",
    "## CSCI 5622 - Spring 2020\n",
    "***\n",
    "**Name**: $<$Tenzin Choedon$>$ \n",
    "***\n",
    "\n",
    "This assignment is due on Canvas by **11.59 PM on Monday, April 27th**. Submit only this Jupyter notebook to Canvas.  Do not compress it using tar, rar, zip, etc. Your solutions to analysis questions should be done in Markdown directly below the associated question.  Remember that you are encouraged to discuss the problems with your classmates and instructors, but **you must write all code and solutions on your own**, and list any people or sources consulted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.datasets import load_iris\n",
    "import pandas as pd\n",
    "import collections"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DataIris:\n",
    "    def __init__(self):\n",
    "        data = load_iris()\n",
    "        self.data = data.data[:, [1, 3]]\n",
    "        self.target = data.target"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 1 [65 Pts]: K-means clustering\n",
    "\n",
    "\n",
    "> First, we're going to build an implementation of K-means clustering as discussed in lecture. We will cluster a reduced form of the Iris dataset with a dimensionality of $d=2$ found in class `IrisData` above. <br>\n",
    "\n",
    "Tasks :\n",
    "Implement K-means clustering by completing the code in the class below : \n",
    "\n",
    "- [10 points] `initialize_centroids` : select K distinct points from the dataset `X` passed in the constructor and use them as the initial centroids. Store these centroids in the class variable `self.centroids` as an `np.array` of shape $K \\times d$ where the $i$-th row represents a centroid and its would be class label is also $i$\n",
    "- [10 points] `compute_distances` : compute the distance of each point $x_i$ to every centroid $m_k$ and return the result as a matrix `distance_matrix` of size $N \\times K$ where N is the number of points and K is the chosen number of clusters to be found. A cell `(i,k)` shall contain the euclidean distance between point $x_i$ and centroid $m_k$\n",
    "- [10 points] `compute_cluster_assignment` : given the distance matrix of size $N \\times K$ return a array of labels in which each element is an integer in the range $[0, K-1]$ and it represents which centroid in the centroid array `self.centroids` that point belongs to.\n",
    "- [10 points] `compute_centroids` : You shall have the new assignment of clusters contained in the incoming `labels` array to your $N$ points. Compute the new centroids depending on the new set of points that has been alloted to each cluster. \n",
    "- [10 points] `cluster` : This shall contain you main loop which implements the algorithm described above. You shall sequentially call the methods above to find the $K$ centroids(or means). Keep performing this loop until one of the following conditions is met: 1) you perform `epochs` number of iterations; or 2) the average euclidian difference between old and new centroids goes below 0.01. At the end of each epoch call the method `show_progress()` to show where the centroids are after making the necessary updates.\n",
    "- [The Elbow Analysis function is used in the bonus problem below]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class KMeansClustering:\n",
    "    def __init__(self, X, K):\n",
    "        '''\n",
    "        Params : \n",
    "            X : (np.ndarray) of dimension (N, d) N is the number of points\n",
    "            K : (int) number of means/centroids to evaluate\n",
    "            epochs : (int) maximum number of epochs to evaluate for the centroids\n",
    "        '''\n",
    "        self.X = X\n",
    "        self.K = K\n",
    "        self.centroids = self.initialize_centroids()\n",
    "        self.df = pd.DataFrame()\n",
    "        \n",
    "    def initialize_centroids(self):\n",
    "        '''\n",
    "        Randomly select K distinct points from the dataset in self.X\n",
    "        Params : \n",
    "            None\n",
    "        RETURN :\n",
    "            means : (np.ndarray) of the dimension (K, d)\n",
    "        '''\n",
    "        idx = np.random.choice(len(self.X),self.K)\n",
    "        return self.X[idx]\n",
    "    \n",
    "    def compute_distances(self):\n",
    "        '''\n",
    "        Comupute a distance matrix of size (N, K) where each cell (i, j) represents the distance between \n",
    "        i-th point and j-th centroid. We shall use Euclidean distance here.\n",
    "        \n",
    "        PARAMS:\n",
    "            centroids : (np.ndarray) of the dimension (K, d)\n",
    "        RETURN:\n",
    "            distance_matrix : (np.ndarray) of the dimension (N, K)\n",
    "        '''\n",
    "        distance = []\n",
    "        for i in range(self.K):\n",
    "            dist = [np.sqrt((self.centroids[i][0]-x[0])**2 + (self.centroids[i][1]-x[1])** 2) for x in self.X] # calculate distance from i centroid.\n",
    "            dist = np.around(dist,2)\n",
    "            distance.append(list(dist))\n",
    "        return np.array(distance)\n",
    "    def compute_cluster_assignment(self, distance_matrix):\n",
    "        '''\n",
    "        Comupute a distance matrix of size (N, K) where each cell (i, j) represents the distance between \n",
    "        i-th point and j-th centroid. We shall use Euclidean distance here.\n",
    "        \n",
    "        PARAMS:\n",
    "            distance_matrix : (np.ndarray) of the dimension (N, K)\n",
    "        RETURN:\n",
    "            labels : (np.ndarray) of the size (N)\n",
    "        '''\n",
    "        labels = [np.argmin(distance_matrix[:,i]) for i in range(len(distance_matrix[0]))]\n",
    "        return np.array(labels)\n",
    "    \n",
    "    def compute_centroids(self, labels):\n",
    "        '''\n",
    "        Randomly select K distinct points from the dataset in self.X\n",
    "        Params : \n",
    "            labels : (np.ndarray) of the dimension (N) where each i-th item reperesents the closest\n",
    "            centroid among the K centroids. Each value here must be between 0 and K-1.\n",
    "        RETURN :\n",
    "            updated_means : (np.ndarray) of the dimension (K, d)\n",
    "        '''\n",
    "        # get all the data with this label and compute mean of x and y point.\n",
    "        total_labels = np.unique(labels).tolist()\n",
    "        color = ['grey','y','purple']\n",
    "        for l in total_labels:\n",
    "            idx = np.where(labels == l)[0]\n",
    "            plt.plot(self.X[idx, 0], self.X[idx, 1], 'o', color=color[l])\n",
    "            \n",
    "            # get mean of x and y and update centroid\n",
    "            x_mean = np.mean([x[0] for x in self.X[idx]])\n",
    "            y_mean = np.mean([x[1] for x in self.X[idx]])\n",
    "            self.centroids[l] = [x_mean,y_mean]\n",
    "        return self.centroids\n",
    "            \n",
    "    \n",
    "    def cluster(self, epochs):\n",
    "        '''\n",
    "        Implement the K-means algorithm here as described above. However loop for a maximum of self.epochs.\n",
    "        Ensure that you have a condition that checks whether the epochs have changed since the last epoch or not\n",
    "        For this use a threshold of change of 0.01.\n",
    "        \n",
    "        PARAMS:\n",
    "            epochs : (integer) maximum number of epochs\n",
    "        RETURN:\n",
    "            centroids : (np.ndarray) of the size (K, d) also store in a class variable self.centroids\n",
    "        '''\n",
    "        '''\n",
    "        in each loop, perform below steps: \n",
    "        If the old centrioid and new centriod difference is below certain threshold, then stop also.\n",
    "        1. d = compute_distance()\n",
    "        2. computer_cluster_assignment(d)\n",
    "        3. computer_centroid.\n",
    "        '''\n",
    "        \n",
    "        for e in range(epochs):\n",
    "            dist = self.compute_distances()\n",
    "            labels = self.compute_cluster_assignment(dist)\n",
    "            old_centroid = np.around(np.array(self.centroids),2)\n",
    "            new_centroid = np.around(np.array(self.compute_centroids(labels)),2)\n",
    "            print(\"Epochs \",e)\n",
    "            self.show_progress(epochs)\n",
    "            \n",
    "            # grap old x and y value to compare\n",
    "            old_x = [x[0] for x in old_centroid]\n",
    "            old_y = [x[1] for x in old_centroid]\n",
    "            new_x = [x[0] for x in new_centroid]\n",
    "            new_y = [x[1] for x in new_centroid]\n",
    "            if((set(old_x) == set(new_x)) and (set(old_y) == set(new_y))): # the centriod remains same after certain epoch, then stop and exit\n",
    "                break\n",
    "                \n",
    "    def show_progress(self, epoch):\n",
    "        '''\n",
    "        PARAMS:\n",
    "            epoch : (integer) tells which epoch is it\n",
    "        RETURN:\n",
    "            None\n",
    "        '''\n",
    "#         plt.plot(self.X[:, 0], self.X[:, 1], 'o', color='y')\n",
    "        for i in range(self.K):\n",
    "            plt.plot(self.centroids[i, 0], self.centroids[i, 1], 'o', color='red')\n",
    "        plt.title('Centroids at epoch : {}'.format(epoch))\n",
    "        plt.show()\n",
    "        \n",
    "    def elbow_analysis(self, k_range):\n",
    "        '''\n",
    "        PARAMS:\n",
    "            k_range : (list of +ve integers) contains the K number of hyperparameters k to peform \n",
    "            the analysis over\n",
    "        RETURN:\n",
    "            avg_variance : (list of float) list od size K. contains the average variance of clusters corresponding to each \n",
    "            to each hyperparameter k\n",
    "        '''\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "....\n",
      "----------------------------------------------------------------------\n",
      "Ran 4 tests in 0.088s\n",
      "\n",
      "OK\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<unittest.runner.TextTestResult run=4 errors=0 failures=0>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "import unittest\n",
    "\n",
    "class KMeansTester(unittest.TestCase):\n",
    "    def setUp(self):\n",
    "        self.X = np.array([[0.1, 0.3], [0.4, 0.6], [0.2, 0.4], [3.1, 3.1], [3.5, 2.9]])\n",
    "        self.cluster_obj_1 = KMeansClustering(self.X, 2)\n",
    "        self.cluster_obj_2 = KMeansClustering(self.X, 2)\n",
    "        self.cluster_obj_3 = KMeansClustering(self.X, 2)\n",
    "        self.cluster_obj_4 = KMeansClustering(self.X, 2)\n",
    "        \n",
    "    def test_initialize_centroids(self):\n",
    "        \"\"\"\n",
    "        Test initialize_centroids function from KMeansClustering\n",
    "        \"\"\"\n",
    "        means = self.cluster_obj_1.initialize_centroids()\n",
    "        self.assertEqual(means.shape[0], 2)\n",
    "        self.assertEqual(means.shape[1], 2)\n",
    "        \n",
    "    def test_compute_distances(self):\n",
    "        \"\"\"\n",
    "        Test compute_distances function from KMeansClustering\n",
    "        \"\"\"\n",
    "        self.cluster_obj_2.centroids = self.X[:2, :]\n",
    "        distance_matrix = self.cluster_obj_2.compute_distances()\n",
    "        self.assertEqual(round(distance_matrix[0,0], 2), 0.0)\n",
    "        self.assertEqual(round(distance_matrix[0,1], 2), 0.42)\n",
    "        \n",
    "    def tests_compute_cluster_assignment(self):\n",
    "        \"\"\"\n",
    "        Test compute_cluster_assignment function from KMeansClustering\n",
    "        \"\"\"\n",
    "        self.cluster_obj_3.centroids = self.X[:2, :]\n",
    "        distance_matrix = self.cluster_obj_3.compute_distances()\n",
    "        labels = self.cluster_obj_3.compute_cluster_assignment(distance_matrix)\n",
    "        self.assertEqual(labels[0], 0)\n",
    "        self.assertEqual(labels[1], 1)\n",
    "        self.assertEqual(labels[2], 0)\n",
    "        \n",
    "    def test_compute_centroids(self):\n",
    "        \"\"\"\n",
    "        Test compute_centroids function from KMeansClustering\n",
    "        \"\"\"\n",
    "        self.cluster_obj_4.centroids = self.X[:2, :]\n",
    "        distance_matrix = self.cluster_obj_4.compute_distances()\n",
    "        labels = self.cluster_obj_4.compute_cluster_assignment(distance_matrix)\n",
    "        new_means = self.cluster_obj_4.compute_centroids(labels)\n",
    "        self.assertEqual(round(new_means[0, 0], 2), 0.15)\n",
    "        self.assertEqual(round(new_means[0, 1], 2), 0.35)\n",
    "        \n",
    "    \n",
    "tests = KMeansTester()\n",
    "myTests = unittest.TestLoader().loadTestsFromModule(tests)\n",
    "unittest.TextTestRunner().run(myTests)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> [5 pts] In the cell below, perform K-means clustering on the `IrisData` with `K=3` for up to __20 epochs__. Plot the centroid locations at each epoch using the method `show_progress` already written for you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epochs  0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epochs  1\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epochs  2\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epochs  3\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epochs  4\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epochs  5\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epochs  6\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epochs  7\n"
     ]
    },
    {
     "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": [
    "# YOUR CODE HERE\n",
    "Iris = DataIris()\n",
    "\n",
    "cluster = KMeansClustering(Iris.data,3)\n",
    "cluster.cluster(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> [10 pts] The original Iris dataset was a labelled dataset with classes assigned to each point. The `show_progress` method plots all the points as yellow without giving points of different classes different colors along with the centroids as black points. Now that you have performed clustering, try to plot the points in the dataset along with the computed centroids, but this time color the dataset points according to their true label in `IrisData` (see the attribute `target` for true class labels in `IrisData`). Comment on what you observe in the Markdown cell following the code cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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": [
    "labels = Iris.target\n",
    "total_labels = np.unique(labels).tolist()\n",
    "color = ['grey','y','purple']\n",
    "for l in total_labels:\n",
    "    idx = np.where(labels == l)[0]\n",
    "    plt.title(\"True Label\")\n",
    "    plt.plot(Iris.data[idx, 0], Iris.data[idx, 1], 'o', color=color[l])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Write your response here_\n",
    "\n",
    "It misclassified some purple data as yellow due to distance measure from centroid. Those purple points are closer to yellow points centroid and therefore classified as yellow instead of purple. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Elbow Analysis [Bonus 15 Pts]\n",
    "\n",
    "Our Iris dataset should have an expectation of three clusters (as seen in the match to the targets?), but we want to see if that is borne out by an Elbow Test. Add a function tpdate the elbow_analysis function in your KMeansClustering Class above to compute the average within-cluster variance, run this within cluster variance for k = 1 to k = 10 and plot the results below, and discuss your results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Write Your Code Here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_write your response here_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1-D data from Gaussian Distributions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Data1D:\n",
    "    def __init__(self):\n",
    "        self.means = [-4.0, 3.5, 10.6]\n",
    "        self.variances = [1.5, 1.2, 1.0]\n",
    "        X = []\n",
    "        for m, v in zip(self.means, self.variances):\n",
    "            X += list(np.random.normal(m, np.sqrt(v), size=(100)))\n",
    "        self.means, self.variances = np.array(self.means), np.array(self.variances)\n",
    "        X = np.array(X)\n",
    "        self.X = X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 2 [35 Pts]: Gaussian Mixture Model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "GMMs are based on the assumption that all data points come from a fine mixture of Gaussian distributions with unknown parameters. They are parametric generative models that attempt to learn the true data distribution. Hence, once we learn the Gaussian parameters, we can generate data from the same distribution as the source. <br>\n",
    "\n",
    "Like K-Means, GMMs also demand the number of clusters K as an input to the learning algorithm. However, there is a key difference between the two. K-Means can only learn clusters with a circular form. GMMs, on the other hand, can learn clusters with any elliptical shape. <br>\n",
    "\n",
    "K-Means only allows for an observation to belong to one, and only one cluster. Differently, GMMs give probabilities that relate each example with a given cluster. In other words, GMMs allow for an observation to belong to more than one cluster — with a level of uncertainty. <br>\n",
    "\n",
    "Assuming one-dimensional data(as is the data for the problem we will solve) and the number of clusters K equals 3, GMMs attempt to learn 9 parameters.\n",
    "- 3 parameters for the means i.e $\\mu_k$\n",
    "- 3 parameters for the variances i.e $\\sigma^2_k$\n",
    "- 3 scaling parameters $\\phi_k$\n",
    "\n",
    "We estimate these parameters using Expectation Maximization which works as follows:\n",
    "1. First we calculate the likelihood of each point. Below is the Probability Density Function we will use to evaluate the likelihood\n",
    "$$f(x|\\mu_k, \\sigma^2_k) = \\frac{1}{\\sqrt{2\\pi\\sigma^2_k}}exp\\Big(-\\frac{(x-\\mu_k)^2}{2\\sigma^2_k}\\Big)$$\n",
    "\n",
    "2. Next we estimate the posterior probability of each point with repect to certain cluster. This tells us what is the probability that a certain point belongs to a certain cluster\n",
    "$$b_k^{(i)} = \\frac{f(x^{(i)}|\\mu_k, \\sigma^2_k)\\phi_k}{\\sum_{k=1}^{K}f(x^{(i)}|\\mu_k, \\sigma^2_k)\\phi_k}$$\n",
    "\n",
    "3. Now we estimate the parameters as\n",
    "$$\\mu_k = \\frac{\\sum_i b_k^{(i)}x^{(i)}}{\\sum_i b_k^{(i)}}$$\n",
    "$$\\sigma^2_k = \\frac{\\sum_i b_k^{(i)}(x^{(i)} - \\mu_k)^2}{\\sum_i b_k^{(i)}}$$\n",
    "$$\\phi_k = \\frac{1}{N}\\sum_i b_k^{(i)}$$\n",
    "\n",
    "4. We repeat the above steps until the parameters dont change beyond a certain threshold or we reach the maximum number of epochs\n",
    "\n",
    "> Now we shall implement Gaussian Mixture Model for a 1-D dataset composed of points from multiple Gaussian Distributions. You can find the data in `Data1D` above.\n",
    "> Complete the methods below : \n",
    "- [5 points] `compute_pdf` : given a scalar value x(a 1-D point) and integer k find the value of the Probability Density Function(p.d.f) as defined above\n",
    "- [5 points] `compute_pdf_matrix` : Create a matrix of size $N\\times K$ which contains the p.d.f value for every  point w.r.t each cluster\n",
    "- [5 points] `compute_posterior` : Given the p.d.f matrix computed from previous function, now create a matrix of size $N\\times K$ which contains the posterior probability value for every  point w.r.t each cluster as using the formula described above\n",
    "- [5 points] `reestimate_params` : Given the posterior probability matrix, re-estimate the 3 sets of parameters \n",
    "- [5 points] `exp_maximize` : the main training loop that runs for `epochs` number of times. You must also incorporate logic here to break the loop if the parameters do not change beyond a certain threshold just like you did before in K-means. We give you the liberty of deciding how that will work and what the threshold value should be. Note that finally the parameters should be in close range with the parmaters the data distribution was created with in class `Data1D`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "class GaussianMixtureModel1D:\n",
    "    def __init__(self, X, K):\n",
    "        self.X = X\n",
    "        self.K = K\n",
    "        self.mean, self.variance, self.weight = self.initialize_parameters()\n",
    "        \n",
    "    def initialize_parameters(self):\n",
    "        mean = np.random.choice(self.X, self.K)\n",
    "        variance = np.random.random_sample(size=self.K) * 2\n",
    "        weights = np.ones(self.K) / self.K\n",
    "        return mean, variance, weights\n",
    "    \n",
    "    def compute_pdf(self, x, k):\n",
    "        '''\n",
    "        Evaluate the p.d.f value for 1-D point i.e scalar value for the w.r.t to the k-th cluster\n",
    "        Params : \n",
    "            x : (float) the point\n",
    "            k : (integer) the k-th elements from mean, variance and weights correspond to k-th cluster parameters.\n",
    "                Use those to estimate your result.\n",
    "        RETURN :\n",
    "            result : (float) evalutated using the formula described above\n",
    "        '''\n",
    "        # implement pdf formula for one type of cluster and one data point.\n",
    "               \n",
    "        return ((1/np.sqrt(2 * np.pi * self.variance[k])) * np.exp(-(x-self.mean[k])** 2/(2* self.variance[k])))\n",
    "    def compute_pdf_matrix(self):\n",
    "        '''\n",
    "        Evaluate the p.d.f martix by calling compute_pdf() for each combination of x and k\n",
    "        Params : \n",
    "            None\n",
    "        RETURN :\n",
    "            result : (np.array) matrix of size N X K containing p.d.f values\n",
    "        '''\n",
    "        # loop through entire dataset and k cluster and store the result from calling compute_pdf. For each data point, we would have k column with k pdf value.\n",
    "        # return only the p values without x\n",
    "        # (p1,p2,p3) for row of data\n",
    "        pdf = []\n",
    "        for x in self.X:\n",
    "            tmp = []\n",
    "            for k in range(self.K):\n",
    "                val = self.compute_pdf(x,k)\n",
    "                tmp.append(val)\n",
    "            pdf.append(tmp)\n",
    "\n",
    "        return np.array(pdf)\n",
    "    \n",
    "    def compute_posterior(self, pdf_matrix):\n",
    "        '''\n",
    "        Evaluate the posterior probability martix as described by the formula above\n",
    "        Params : \n",
    "            pdf_matrix : (np.array) matrix of size N X K containing p.d.f values\n",
    "        RETURN :\n",
    "            result : (np.array) matrix of size N X K containing posterior probability values\n",
    "        '''\n",
    "        # we have data like this p1,p2,p3). we use that value to calculate posterior by using second formula.\n",
    "        # (b1,b2,b3) for each row of data. for example with b1, we take p1*phi1/(p1*ph1 + p2*ph2 +p3*ph3). and we return (b1,b2,b3)\n",
    "        bk = []\n",
    "        for i in range(len(pdf_matrix)):\n",
    "            tmp = []\n",
    "            denominator = np.sum(np.array(pdf_matrix[i]) * self.weight)\n",
    "            for k in range(self.K):\n",
    "                tmp.append(pdf_matrix[i][k] * self.weight[k]/denominator)\n",
    "            bk.append(tmp)\n",
    "        return np.array(bk)\n",
    "                \n",
    "    \n",
    "    def reestimate_params(self, posterior_matrix):\n",
    "        '''\n",
    "        Re-estimate the cluster parameters as described by the formulae above and \n",
    "        store them in their respective class variables\n",
    "        Params : \n",
    "            posterior_matrix : (np.array) matrix of size N X K containing posterior probability values\n",
    "        RETURN :\n",
    "            None\n",
    "        '''\n",
    "        # meank = (sum of multiplication between each data point with bk) /sum of bk column.\n",
    "        # stdk = \n",
    "        # update self.mean, self.variance, self.weight to new meank,stdk,phik using third formula.\n",
    "        posterior_matrix = np.array(posterior_matrix)\n",
    "        for k in range(self.K):\n",
    "            self.mean[k] = (posterior_matrix[:,k]*self.X).sum()/posterior_matrix[:,k].sum()\n",
    "            self.variance[k] = (posterior_matrix[:,k] * (self.X - self.mean[k]) ** 2).sum()/posterior_matrix[:,k].sum()\n",
    "            self.weight[k] = posterior_matrix[:,k].sum()/len(posterior_matrix[:,k])\n",
    "            \n",
    "            \n",
    "    def exp_maximize(self, epochs):\n",
    "        '''\n",
    "        Peform the expectation-maximization method as dicussed above by calling the functions in their \n",
    "        respective sequence. Also plot the progress of the process by calling the plot_progress function\n",
    "        after every regular interval of epochs.\n",
    "        Params : \n",
    "            epochs : (integer) maximum number of epochs to run the loop for\n",
    "        RETURN :\n",
    "            None\n",
    "        '''\n",
    "        '''\n",
    "        # we can stop if the params are within certain threshold.\n",
    "        1. pdf = compute_pdf_matrix()\n",
    "        2. post = compute_posterior(pdf)\n",
    "        3. reestimate_params(post)\n",
    "        4. plot_progress()\n",
    "        '''\n",
    "        for e in range(epochs):\n",
    "            old_mean = np.round(np.array(self.mean),2)\n",
    "            old_variance = np.round(np.array(self.variance),2)\n",
    "            \n",
    "            pdf = self.compute_pdf_matrix()\n",
    "            posterior = self.compute_posterior(pdf)\n",
    "            self.reestimate_params(posterior)\n",
    "            new_mean = np.round(np.array(self.mean),2)\n",
    "            new_variance = np.round(np.array(self.variance),2)\n",
    "            print(e)\n",
    "            print(old_mean,new_mean)\n",
    "            \n",
    "            self.plot_progress()\n",
    "            if(np.array_equal(old_mean,new_mean) and np.array_equal(old_variance, new_variance)):\n",
    "                break\n",
    "    \n",
    "    def plot_progress(self):\n",
    "        points = np.linspace(np.min(self.X),np.max(self.X),500)\n",
    "        plt.figure(figsize=(10,4))\n",
    "        plt.xlabel(\"$x$\")\n",
    "        plt.ylabel(\"pdf\")\n",
    "        plt.plot(self.X, 0.1*np.ones_like(self.X), 'x', color='navy')\n",
    "        for k in range(self.K):\n",
    "            plt.plot(points, [self.compute_pdf(p, k) for p in points])\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "....\n",
      "----------------------------------------------------------------------\n",
      "Ran 4 tests in 0.016s\n",
      "\n",
      "OK\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<unittest.runner.TextTestResult run=4 errors=0 failures=0>"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import unittest\n",
    "\n",
    "class GMMTester(unittest.TestCase):\n",
    "    def setUp(self):\n",
    "        self.X = np.array([0.1, 1.2, 0.3, 0.4, 0.3, 3.5, 2.9])\n",
    "        self.means = [-2.0, 2.5]\n",
    "        self.variances = [1.0, 1.3]\n",
    "        self.weights = [0.1, 0.2]\n",
    "        \n",
    "        self.cluster_obj_1 = GaussianMixtureModel1D(self.X, 2)\n",
    "        self.cluster_obj_1.mean = self.means\n",
    "        self.cluster_obj_1.variance = self.variances\n",
    "        self.cluster_obj_1.weight = self.weights\n",
    "        \n",
    "        self.cluster_obj_2 = GaussianMixtureModel1D(self.X, 2)\n",
    "        self.cluster_obj_2.mean = self.means\n",
    "        self.cluster_obj_2.variance = self.variances\n",
    "        self.cluster_obj_2.weight = self.weights\n",
    "        \n",
    "        self.cluster_obj_3 = GaussianMixtureModel1D(self.X, 2)\n",
    "        self.cluster_obj_3.mean = self.means\n",
    "        self.cluster_obj_3.variance = self.variances\n",
    "        self.cluster_obj_3.weight = self.weights\n",
    "        \n",
    "        self.cluster_obj_4 = GaussianMixtureModel1D(self.X, 2)\n",
    "        self.cluster_obj_4.mean = self.means\n",
    "        self.cluster_obj_4.variance = self.variances\n",
    "        self.cluster_obj_4.weight = self.weights\n",
    "        \n",
    "    def test_compute_pdf(self):\n",
    "        \"\"\"\n",
    "        Test compute_pdf function from GaussianMixtureModel1D\n",
    "        \"\"\"\n",
    "        pdf = self.cluster_obj_1.compute_pdf(self.X[0], 1)\n",
    "        self.assertEqual(round(pdf, 3), 0.038)\n",
    "        \n",
    "    def test_compute_pdf_matrix(self):\n",
    "        \"\"\"\n",
    "        Test compute_pdf_matrix function from GaussianMixtureModel1D\n",
    "        \"\"\"\n",
    "        pdf_matrix = self.cluster_obj_2.compute_pdf_matrix()\n",
    "        self.assertEqual(round(pdf_matrix[0,0], 3), 0.044)\n",
    "        self.assertEqual(round(pdf_matrix[0,1], 3), 0.038)\n",
    "        \n",
    "    def tests_compute_posterior(self):\n",
    "        \"\"\"\n",
    "        Test compute_posterior function from GaussianMixtureModel1D\n",
    "        \"\"\"\n",
    "        pdf_matrix = self.cluster_obj_3.compute_pdf_matrix()\n",
    "        posterior_matrix = self.cluster_obj_3.compute_posterior(pdf_matrix)\n",
    "        self.assertEqual(round(posterior_matrix[0,0], 2), 0.37)\n",
    "        self.assertEqual(round(posterior_matrix[0,1], 2), 0.63)\n",
    "        \n",
    "    def test_reestimate_params(self):\n",
    "        \"\"\"\n",
    "        Test reestimate_params function from GaussianMixtureModel1D\n",
    "        \"\"\"\n",
    "        pdf_matrix = self.cluster_obj_4.compute_pdf_matrix()\n",
    "        posterior_matrix = self.cluster_obj_4.compute_posterior(pdf_matrix)\n",
    "        self.cluster_obj_4.reestimate_params(posterior_matrix)\n",
    "        self.assertEqual(round(self.cluster_obj_4.mean[0], 2), 0.24)\n",
    "        self.assertEqual(round(self.cluster_obj_4.variance[0], 2), 0.02)\n",
    "        self.assertEqual(round(self.cluster_obj_4.weight[0], 2), 0.13)\n",
    "        \n",
    "    \n",
    "tests = GMMTester()\n",
    "myTests = unittest.TestLoader().loadTestsFromModule(tests)\n",
    "unittest.TextTestRunner().run(myTests)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> [5 pts] Using the Gaussian Mixture Model you have built, fit a model for the 1-D data in `Data1D` with $K=3$. Train the model for 20 epochs and plot the progress of the model using the function `plot_progress` in the code cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# YOUR CODE HERE\n",
    "data = Data1D()\n",
    "gmm = GaussianMixtureModel1D(data.X,3)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "[-4.23  3.36  9.67] [-3.87  3.57 10.7 ]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "[-3.87  3.57 10.7 ] [-3.84  3.6  10.7 ]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "[-3.84  3.6  10.7 ] [-3.83  3.61 10.7 ]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "[-3.83  3.61 10.7 ] [-3.82  3.61 10.7 ]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "[-3.82  3.61 10.7 ] [-3.82  3.61 10.7 ]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmEAAAEGCAYAAAAt7EI0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdeVxc9b3/8deZYYYtQNiSEJZA9kAWMCQkMYvRuGvc4761t9bYxVu3ant/9lZvW6vVa29vtXq12lo1i1UbbbRqjCZmBRJCQjZJIEDYIQTCOsv5/TEMIQQCJDN8Z/k8Hw8eA7Oc84Y5M/Phez7nezRd1xFCCCGEEEPLoDqAEEIIIYQ/kiJMCCGEEEIBKcKEEEIIIRSQIkwIIYQQQgEpwoQQQgghFAhQHWCwYmJi9OTkZNUxhBBCCCH6lZubW6vremxvt3ldEZacnExOTo7qGEIIIYQQ/dI07Uhft8nuSCGEEEIIBaQIE0IIIYRQQIowIYQQQggFpAgTQgghhFBAijAhhBBCCAWkCBNCCCGEUECKMCGEEEIIBbxunjAhhPBIx4rh4L/A2gbJ8yF+pupEQggPJ0WYEEKcC12Hb16A9b8Bu+Xk9anXwDUvQeAwddmEOEs2u42tFVspby4nJTyFjBEZGA1G1bF8jhRhQghxLr74T9j0IqRdBxf9AoIiIPt1+OrX0FQFd/0DTEGqUwoxYPvq9vHohkc50nhyove06DR+s+A3pESkKEzme6QnTAghzlbBB44CLPM7cOMbEJUCIVGw6FG44TUo3QqfPKY6pRADtqd2D3d/ejet1laeX/Q8n93wGU+f/zTlJ8q599N7OXz8sOqIPkWKMCGEOBvNtfDRg5AwCy5/FjTt1Nun3gDnPwg7/gKHvlSTUYhBqGut4wfrfkBUUBQrrlzBJcmXEDcsjmvHX8ubl7+Jjs6DXz5Ii6VFdVSfIUWYEEKcjXVPQUczXPNHMJp6v88FP4Po8bD2UbBZhzafEIP09NanOdFxgj9c+AdiQ2JPuW1sxFieW/gcRxqP8ELuC4oS+h4pwoQQYrBqC2HnWzD7Poid1Pf9TEFw8VNQVwh5fxu6fEIM0qajm1hXso4H0h9gQuSEXu8zO242t025jVUHVrG/fv8QJ/RNUoQJIcRgbXwejIEw/6H+7zvpCscuy40vyGiY8Eh23c7zuc8TPyyeO1PvPON9H0h/gOGBw3khR0bDXEGKMCGEGIzGcti9CmbeDcNi+7+/psH5/w4NR2D/R+7PJ8QgrS9Zz7fHvuVHGT/CbDSf8b7h5nDunXovWyq2kF+TP0QJfZcUYUIIMRi5b4LdBln3D/wxky6HqHGw5SW3xRLibOi6zp/3/JmEYQlcmnzpgB5z86SbiQiM4PXdr7s5ne+TIkwIIQbKZnEUYRMucUxHMVAGo2Mai7LtULXXbfGEGKy9dXvJr83nztQ7CTAMbOrQEFMIyyYu46uyryg/Ue7mhL5NijAhhBiowi/gRBXMvGfwj51xKxjNjikrhPAQHxR+QKAxkKvGXTWoxy2btAyAVQdWuSOW35AiTAghBirvHQiJgQkXD/6xodGO3ZJ7/u7YnSmEYm3WNtYeXsuSMUsIN4cP6rGjQkexMH4hHx36CJtsz2fNrUWYpmmXaZp2QNO0Qk3THj/D/W7UNE3XNC3TnXmEEOKstR2Hg5/CtJv6nhesP2nXQ3MNHNnk2mxCnIV1JetosjRx3fjrzurxV469kurWanKrcl2czH+4rQjTNM0I/BG4HEgFbtU0LbWX+4UBPwa2uSuLEEKcs4Ofga0Dpl5/9suYcAmYQhynOxJCsQ8KPyB+WDyzRs06q8cvSlxESEAIa4vWujiZ/3DnSNhsoFDX9cO6rncAK4Brernf08CzQJsbswghxLnZtwaGjYL4cxiwN4fAxEth7xqZM0woVdVcxbaKbVwz7hoM2tmVAsEBwVyUdBGfHfmMDluHixP6B3cWYfFAabefyzqv66JpWgaQqOv6x27MIYQQ58bS6mjKn3wlGM7xbTPtOmiplV2SQqn1pesBuDRlYNNS9OWKsVfQ1NHExqMbXRHL77izCNN6uU7vulHTDMB/Aw/3uyBNu0/TtBxN03JqampcGFEIIQbg0JdgaYEpgzuCrFfjLwZTqOySFEqtK1lHcngyYyPGntNy5sTNISooirWHZZfk2XBnEVYGJHb7OQHoPqFIGDAV+ErTtGJgDrCmt+Z8Xddf1XU9U9f1zNjYAcxQLYQQrrTvYwiKgOQF574sc4jj6MoDn4Cu939/IVzsePtxcipzuDDpwnNeVoAhgMWJi9lUvgmLzeKCdP7FnUVYNjBB07QUTdPMwC3AGueNuq4f13U9Rtf1ZF3Xk4GtwFJd13PcmEkIIQbHZoUDax3ngDzboyJ7mnAxnKiEqj2uWZ4Qg7Dx6EasutUlRRjAwoSFNFuaya2WoyQHy21FmK7rVuCHwL+AfcAqXdcLNE17StO0pe5arxBCuNTRXGhrgImXuW6Z45c4Lgu/cN0yhRigL0u+JCY4hmkx01yyvDlxczAbzGwo2+CS5fkTt84Tpuv6Wl3XJ+q6Pk7X9V91XvekrutrernvBTIKJoTwOIe+BM0AYxe5bplho2DkNPhWijAxtNpt7Xxz9BsWJy4+66MiewoxhTArbpYUYWdBZswXQogzOfQljD4PgiNdu9wJS6B0K7Q1una5QpzBjqodtFpbuSDxApcud1HCIo40HqH4eLFLl+vrpAgTQoi+tDbA0RwY55remVOMXwJ2KxR97fplC9GHLRVbCDAEkDnStSeoWZiwEEBGwwZJijAhhOhL0QbQ7e4pwhKzwBwmfWFiSG0t30p6bDohphCXLjd+WDzjh49nw1EpwgZDijAhhOjL4fWOQinBDae1NZocfWaHvnT9soXoRV1rHfvq9zF39Fy3LH/u6LnkVefRbmt3y/J9kRRhQgjRl0NfQspC101N0VPKQmgocXwJ4WbbKhynaJ4b554iLGtUFu22dnZV73LL8n2RFGFCCNGbY8WOr7EXuG8dY853XBbLKYyE+22p2EK4OZzU6FS3LH/myJkYNSPbKre5Zfm+SIowIYTozZHNjsvk+e5bx4hUx1GXxd+4bx1CALqus6V8C1lxWRgNRresY5h5GGnRaWyv2O6W5fsiKcKEEKI3RzY5CqTYye5bh8HgGA0rlpMfC/cqbiymqqWKOXFz3Lqe2XGz2VO7h2ZLs1vX4yukCBNCiN4c2ewokAxufptMXgANR6QvTLhVbpXjlEKzR81263pmj5qNVbeyo2qHW9fjK6QIE0KInhoroP4wjJnn/nUlS1+YcL/cqlyig6IZEz7GretJH5GOyWBie6XskhwIKcKEEKKnks5+sKEowkakQdBwOCJ9YcJ9dlTt4LyR56FpmlvXExwQzIzYGV1HYoozkyJMCCF6OrLZMT/YSNec4PiMuvrCpAgT7lF+opzy5nJmjpw5JOubOXImB44dkL6wAZAiTAghejqyGZKywBgwNOtLmuOYDuNE9dCsT/gVZz+Yq09V1JeMERnYdTv5NflDsj5vJkWYEEJ011IP1XshyT0TWvYqMctxWSp9NML1cqtyCTOHMX74+CFZ34zYGRg0Azurdw7J+ryZFGFCCNFdWY7jMsm9h/KfIm4GGM1QKn00wvVyq3I5b8R5bpsfrKdh5mFMjJzIjmo5QrI/UoQJIUR3ZdmgGWB0xtCt0xTkWJ8UYcLFaltrKW4sHrJ+MKeMERnk1+RjtVuHdL3eRoowIYToriwbRqaBOXRo15s4G8p3glVOfixcZ1eN4zyOGSOG8J+KzvW1Wls5cOzAkK7X20gRJoQQTnY7HM2FhFlDv+7ELLB1QIWc/Fi4Tn5NPgGGAKZETxnS9TqLvp1V0hd2JlKECSGEU+1BaG9UU4QldM5kLrskhQvl1+QzJWoKgcbAIV3vqNBRjA4dLX1h/ZAiTAghnMqyHZcqirCwkRCZLEWYcBmr3UpBXQHTY6crWX/6iHR2VcvI7plIESaEEE5l2Y7Z66PGqVl/YpZjmgpdV7N+4VMKGwpptbYyPUZNETY9djrVrdVUNlcqWb83kCJMCCGcyrIhIdP9J+3uS/xMOFEFjeVq1i98inOyVFUjYdNiHGec2FO7R8n6vYEUYUIIAdDWCNX71OyKdIrvnEagXPpoxLnbVbOLqKAo4ofFK1n/5KjJBBgCyK+VmfP7IkWYEEJAZ+GjO0bCVBk5FQwBjiM0hThH+TX5TI+d7vaTdvfFbDQzOXIyu2t2K1m/N5AiTAgh4GRTfvzQTmp5ClOQoxA7KiNh4twcbz9OcWMxM2JnKM0xLXYaBXUF2Ow2pTk8lRRhQggBjtMVxUyE4Ei1OeJnOiZttdvV5hBebXetY/RJeREWM41WayuFDYVKc3gqKcKEEELXO5vyFfaDOcWf55irrE4+tMTZy6/Jx6AZSItOU5rDeVCAsygUp5IiTAghjhVBS53aXZFO0pwvXCC/Jp8JwycQYgpRmiMpLImIwAgpwvogRZgQQpTnOS49oQiLmQimUGnOF2fNrtvJr81XNjVFd5qmMTVmqhRhfZAiTAghKvLAYIIRqaqTgMEIozOkOV+cteLGYpo6mjyiCAOYHjOdQw2HaLG0qI7icaQIE0KI8jwYmQoBZtVJHOIzoDIfrB2qkwgvVFBbAMDU6KmKkzhMi5mGXbdTUFegOorHkSJMCOHfdB0qdkFcuuokJ8XPBFsHVMlM42Lw9tbtJTggmJSIFNVRAJga4ygGnTP4i5OkCBNC+LeGI9DWAKM9rAgDac4XZ6WgroDJUZMxGoyqowAQGRRJYlii9IX1QoowIYR/czble9JIWEQihMRIX5gYNJvdxv76/aRGe0B/YzfTYqZJEdYLKcKEEP6tIs9xqiBPaMp30jTHaJgcISkGqbixmFZrq8cVYWnRaVS3VFPbWqs6ikeRIkwI4d/K82DEFMcpgzzJ6AyoOQAdzaqTCC+yt24vgPJJWntyFoXOfMJBijAhhP/yxKZ8p9HpgA6VsgtHDFxBXQHBAcEkhyerjnKKKdFT0NDkCMkeAty5cE3TLgN+DxiB13Rdf6bH7fcDPwBswAngPl3XpUz2YvsqGlmzq5zsonqONrRi13VGRQRzXtJwrpo+mvOShqNpmuqYQjgcL4XWes9qyneK6zznX8UuSJqjNovwGnvr9npUU75TqCmU5Ihk9tbKR3x3bivCNE0zAn8ELgbKgGxN09b0KLLe0XX9T533Xwq8AFzmrkzCfUrrW/jFmgK+3F9NgEFjRuJw5o2LwWiA0vpW3tlWwhubislKieKpa6YyaVSY6shCeGZTvlNYHISOcBRhQgyAsyn/+gnXq47Sq7ToNLZXbFcdw6O4cyRsNlCo6/phAE3TVgDXAF1FmK7rjd3uHwrobswj3EDXdd7eVsKv1+7DoGk8eukkbpudRGToqZNeNrdbeS+3jP/+4iBX/M9Gfrh4PA9eNAGDQUbFhEIVeaAZYaRn9c8Ajub8uBknC0Uh+uGpTflOqdGpfHz4Y2paaogNiVUdxyO4swiLB0q7/VwGZPW8k6ZpPwAeAszAhb0tSNO0+4D7AJKSklweVJwdu13nqY/38ubmYhZMiOGZG6YTPzy41/uGBgZw97xkls4YzdMf7+X3677l2+omnr8pnWCzZw2bCz9SsauzKb/37Va50elw6EuwtHpuRuExnP1WntaU79S9OX9RyCLFaTyDOxvzexviOG2kS9f1P+q6Pg74KfAfvS1I1/VXdV3P1HU9MzZWqmdPYLXZ+fGKnby5uZjvLUjhL/fO7rMA6y4y1Mzzy2bwsysm88meSu5+YzttFtsQJBaiB113jDJ54q5Ip7gZoNugSpqZRf+cM+V7WlO+05QoR3O+HCF5kjuLsDIgsdvPCUD5Ge6/ArjWjXmEi+i6zv/7xx4+zq/g8csn8/MrUwe1W1HTNO5bOI4Xb04nu7ieH7y9A4vN7sbEQvSi8Si01J5sgPdEzgKxQnZJiv55alO+U4gphJSIFDlCsht3FmHZwARN01I0TTMDtwBrut9B07QJ3X68EvjWjXmEi7z01SHe3V7KDxaP4/5F4856Odekx/PUNVNZt7+an3+wG12XlkAxhJy9Vp54ZKRTRAIER0lfmOiXp86U31NadJqMhHXjtiJM13Ur8EPgX8A+YJWu6wWapj3VeSQkwA81TSvQNC0PR1/Y3e7KI1xj3b4qnvvXAa7LiOeRSyad8/LunDOGH104nlU5ZazMLu3/AUK4SsUu0AwwcqrqJH1zNufLEZKiH0XHi2i1tnpsP5hTanQqNa01VLdUq47iEdw6T5iu62uBtT2ue7Lb9w+6c/3CtSqOt/LI6l2kxoXzm+unuWy+r39fMpG80gaeXFPA1PgIpsZHuGS5QpxRRR7ETgZziOokZzY6HTb/L1jbISBQdRrhofbWO0aXPH0krHtz/oiQEYrTqCcz5osBsdl1HlyRR7vVzv/elkGQyXU9B0aDxu9vySA61MyP390pjfrC/bqa8j24H8wpbgbYLVAtu3BE3zy9Kd9pctRkDJpBdkl2kiJMDMgbm4rYXlTPU9dMZWzsMJcvPyrUzPM3zeBwbTMvfH7Q5csX4hRNFdBc7dlHRjo5M0pfmDgDT2/KdwoxhZASLs35TlKEiX6V1rfw/GcHuXDyCG44L95t65k3Pobbs5J4beNhco8cc9t6hPCKpnynyGQIipC+MNEnb2nKd0qLcTTny8FYUoSJfui6zs8/3INBg6evner28z4+ccUU4iKCeeL9fJm2QrhPxS5Ag1HTVCfpX1dzvoyEid55S1O+U2p0KrWttdKcjxRhoh9rd1ey4WANj146aUCTsZ6rYYEB/OLqVA5WneCtLUfcvj7hpyryIGYimENVJxmYuBmOCVttFtVJhAfylqZ8p+7N+f5OijDRpzaLjV+v3cfkUWHcOTd5yNZ7cepIFk6M5b+/OEjtifYhW6/wI+V53rEr0ikuHWwdUL1PdRLhgbylKd9pUuQkR3N+vRRhUoSJPr3+TRFHG1p58qpUjEN4om1N03jyqlRaO2w89+mBIVuv8BNNlXCi0jua8p26Zs6XvjBxuoLaAq9oyncKMYUwNmIsBbXSnC9FmOhVTVM7L60v5OLUkcwbHzPk6x8/Yhh3zU1mdW4p31Y1Dfn6hQ9zFjLeNBIWNRbMYVKEidPY7DYOHDvgNbsinVKjU6U5HynCRB/+uL6QNqudn10xRVmGH144nhBzAM/9S0bDhAuV5+E1TflOBgPETZfmfHEab2vKd0qNTqWurc7vm/OlCBOnKTvWwjvbSliWmUBKjLrG5ahQM/ctHMtne6vYUSJTVggXqciD6PEQGKY6yeDEzYDKPWCzqk4iPIi3NeU7OYtGf58vTIowcZr/Wec4j/qPLpzQzz3d77vzU4gZZpbeMOE63taU7xSXDtZWqJXJjMVJBbUFXtWU7zQpapLMnI8UYaKHotpm/r7jKLfPSWL0EExJ0Z/QwACWXzCeLYfryC6uVx1HeLsT1dBU7l1N+U7OUyxJX5joxltmyu8pOCCYsRFjpQhTHUB4lpe/KiTAoPHABeNVR+ly6+xEokPN/O+XhaqjCG/njU35TjETwBQifWGii7Mp39v6wZykOV+KMNFNeUMrH+w8ys2zEokNC1Qdp0uIOYDvLkjh64M15Jc1qI4jvJnzdEXe1JTvZDA6cstImOjkbMr3tn4wJ2nOlyJMdPN/Gw+j63DfwrGqo5zmzjljCA8K4I/rZTRMnIOKPIga5zgXozeKS4eKfLDbVCcRHsDZ1O6tRZg050sRJjrVnWhnxfZSrkmPJyEyRHWc04QFmbj3/BT+VVDFgUqZN0ycpYpd3rkr0iluBliaoU7+GRHeN1N+T9KcL0WY6PTm5mLarDaWX+B5o2BO956fTKjZKKNh4uw018HxUu9syndyFpDl0hcmvLcp30ma86UIE0BTm4U3Nxdzaeooxo/w3LmThoeYuWPOGD7OL6fsWIvqOMLbVOx0XDqPMvRGMZMgIFia8wVWu9Wrm/Kd/L05X4owwcrsUprarCy/YJzqKP26e14ymqbxl83FqqMIb+McPfLmIswYAKOmykiY8PqmfCd/b86XIszPWW123thUzOzkKGYkDlcdp1+jhwdzxbQ4Vmwv5US7zBwuBqFiF0SmQLDnb+dnFJcOlflgt6tOIhRy7sLz9iLM35vzpQjzc1/sq+JoQyvfmZ+iOsqAfXd+Ck3tVlZll6qOIrxJhZfOlN/T6HToOCHN+X7O25vynfy9OV+KMD/352+KSYgM5uLUkaqjDFh64nAyx0TyxuYibHb/7CMQg9RSDw0l3r0r0ml0huNS+sL8mrc35Tv5e3O+FGF+bHfZcbYX13PPvGSMBk11nEH57vwUSutb+Xxvpeoowhs4CxZvPjLSydmcL31hfstqt7K/fr/XN+U7+XNzvhRhfuyNTUWEmo0sm5WoOsqgXZI2isSoYF7bWKQ6ivAGzoLFF3ZHOpvzZSTMbxUdL6LN1ub1/WBO/tycL0WYn6pubOOj/HJuykwkPMikOs6gGQ0ad89NJufIMQrKj6uOIzxd+U6ITIbgSNVJXKNr5nxpzvdHvtKU7+Qc0fPHXZJShPmpd7eXYrHp3DMvWXWUs3bTzESCTAb+trVEdRTh6SryTvZS+YLR6dDRBPWHVCcRChTUFfhEU76TsznfH4+QPGMRpmnaTZ2X3nPonOiXza6zMruEBRNiSI4JVR3nrEWEmFg6YzQf7jzK8VaL6jjCUzXXOZryfakIc/a2le9Um0MoUVBbQGp0qtc35Tv5c3N+fyNhT3Re/t3dQcTQ+epANeXH27g9K0l1lHN219xkWi023t9RpjqK8FRdM+X7QD+YU+xkCAiS5nw/ZLFbfKop38lfm/P7K8LqNE1bD6Romram59dQBBSu9+72EmLDArloivdMS9GXqfERpCcO562tR/zuxSsGqNwHTlfUkzEARkpzvj8qPFZIh72DqTFTVUdxKX9tzg/o5/YrgfOAt4Dn3R9HuFt5Qytf7q9m+QXjMBl9oyXwzjljeHj1LrYcqmPe+BjVcYSnKc+DqHHeP1N+T6PTYddKR3O+wTdey6J/zr4pXxsJ696cPzLU+wcIBuqMr1xd1zt0Xd8KzNN1/eueX0OUUbjQyuxSdOCWWd6/K9LpyulxDA8x8dbWI6qjCE9U7mNN+U5x0pzvjwrqCggzh5EY5n1TC52Jvzbnn3EkTNO0jwC98/vTbtd1fal7Ygl3sNrsrMopZcGEWBKjQlTHcZkgk5GbMxN57ZsiKo+3MSoiSHUk4SlO1EBjmW/MD9aT83cqz4OYCWqziCFTUFtAWnRar5/J3sxfm/P7G8P+HY7dkEVAK/B/nV8ngD3ujSZc7asDNVQcb+O22b4zCuZ0e9YY7LrOO9tlugrRjbNnyhdHwmIngzFQ+sL8SLutnW+Pfetz/WBO/tic39/uSOduxwxd12/Wdf2jzq/bgPlDE1G4yjvbSxgRFshFU0aojuJySdEhXDAxlne3l2CxyQSWolP5TkCDUdNVJ3E9o8kxc74cIek3DtYfxKpbfa4fzMkfm/MH2s0Zq2naWOcPnfOGxbonknCHow2tfHWgmmWZiT7TkN/T7VljqGlqZ90+/3kBi36U74To8RAUrjqJe8SlQ8UumTnfT+ypc+yA8tWRMH+cOX+gn8Y/Ab7SNO2rzikr1gP/7r5YwtWcDfk3e+F5IgfqgkmxjAoPYkW27JIUnXy1Kd+pa+b8w6qTiCFQUFtAVFAUI0N88+hBf2zOH2gR9hXwCnAMR6P+K4AcHeklrDY7K7NLWOhjDfk9BRgNLMtM4OuDNZQda1EdR6jWVAlN5T5ehHX+btIX5hcK6gqYGjPV55rynfyxOX+gRdhfgRTgf4CnO79/q78HaZp2maZpBzRNK9Q07fFebn9I07S9mqbla5q2TtO0MYMJLwZm/YEaqhrbuc0HZsjvz7LOkb5VOTKDvt8r9+GmfCdnc76cvsjntVhaOHz8sM/2gzn5W3P+QIuwSbqu/5uu6+s7v+4DJp7pAZqmGYE/ApcDqcCtmqb1POX7TiBT1/XpwHvAs4OLLwbinW1HHA35k32vIb+nhMgQFk6IZVV2KVZp0PdvXU3501QncR9nc37FLtVJhJvtr9+PXbf7fBGWFp1GXVsdVS1VqqMMiYEWYTs1TZvj/EHTtCxgUz+PmQ0U6rp+WNf1DmAFcE33O3QWdM79RluBhAHmEQNUdqyFrw7WcPOsRAJ8tCG/p1tnJ1HZ2MbXB2tURxEqVeRB7CQIHKY6iXtJc75f2FPraMpPi/HtImxajOOfpt21uxUnGRoD/VTOAjZrmlasaVoxsAVYpGnabk3T8vt4TDxQ2u3nss7r+vJd4JPebtA07T5N03I0TcupqZEP1sFYle14Cny5Ib+ni6aMIGZYIO9uL+3/zsI36bpjJMyXd0U6jc6A9kaZOd/HFdQVMDJkJDHBvn1qtklRkzAZTOyu8Y8irL9zRzpddhbL7q1zsNedvJqm3QFkAot6u13X9VeBVwEyMzP9Y0exC1htdlbmlHLBxFgSIn23Ib8nk9HATZkJvPL1IZlB3181VcCJKscoka+Ln+m4PJorM+f7MGdTvq8zG81MjposI2Hd6bp+5ExffTysDOg+/JIAlPe8k6ZpS4CfA0t1XW8f7C8g+rZufzVVje3c6oMz5PfnllmJ2HVYnSOjYX7JH5rynWIngXkYlOWoTiLcpLGjkSONR3y+H8xpWsw0CuoKsNltqqO4nTubhLKBCZqmpWiaZgZuAdZ0v4OmaRk4prtYquu6zLDpYu9uL2FUeBAX+kFDfk9jokM5f3w0K7JLsdtl8NTvHM0BzejbTflOBqOj2DyaqzqJcJN9dfsA3+8Hc5oaM5VWayuFDYWqo7id24owXdetwA+BfwH7gFW6rhdomvaUpmnOE38/BwwDVmualqdp2po+FicGqbS+ha8P1rDMjxrye7p1dhJHG1rZWFirOooYamU5jqMGzX6yGz5+JlTuBkub6iTCDZy75vxlJGx6rOM0Y86DEXyZWz+ddV1fq+v6RF3Xx+m6/qvO657UdX1N5/dLdF0fqet6eufX0jMvUQzUyjJzru8AACAASURBVOxSNPyrIb+ni1NHEhVq5t1tMoO+X7Hb4OgOiM9UnWToxM8Eu8VRiAmfk1+TT3J4MhGBEaqjDImksCTCzeF+0Rfmn0MkPs5is7Mqp5QLJo0gfniw6jjKBAYYuXFmAl/sq6K6SUYI/EbtQcepfBJmqU4ydBI6C86j0hfma3RdJ78mv2t0yB9omsa0mGlShAnvtG5fNdVN7dzmhw35Pd08KxGrXee9XJlB32+UZTsuE/xoJCx8NISNlr4wH3T0xFHq2uqYETtDdZQhNS12GoUNhbRYfPsUdFKE+aB3OhvyL5gUqzqKcuNih5GVEsVKadD3H2U5EBQBUeNUJxlaCTPlCEkflF/jmIrTn0bCwHGEpF23+/zJvKUI8zGl9S1s/Na/Zsjvz62zkzhS18KWw3Wqo4ihcDTX0Q9m8LPtP34mHCuCZtnOfUl+bT7BAcGMHz5edZQh5ZwTzdeb8/3sXcr3rcgu8fuG/J4umzqKiGAT726XBn2f134Cqvf6165IJ+eBCOU71OYQLrWrehdTY6YSYBjo3Oq+ISooivhh8T7fFyZFmA9xNOSXsXjSCEb7cUN+T0EmI9efF8+/CiqpOyHzAfu08p2g2/3ryEin0RmgGWSXpA9ps7axv34/02P8a1ek0/SY6VKECe+xbl8VNU3t3JYlDfk93To7CYtN5/0dR1VHEe7kj035ToHDIHayHCHpQ/bX78eqW/2uH8xpWuw0KpsrqW7x3bncpQjzIW9vKyEuIogLJvnfDPn9mTgyjJljInk3uwRdlwZ9n3U0F6LGQkiU6iRqxM90/A1kG/cJu2p2Af7XlO+UHus49+vO6p2Kk7iPFGE+oqSuhY3f1nLzrESMht7OnS5unZ3E4Zpmth6uVx1FuIOuO0bC/Gl+sJ4SMqH1GNQfVp1EuMCuml3ED4snJjhGdRQlJkdPJsgYRF51nuoobiNFmI9YkV2CQZOG/DO5anoc4UEBvCMN+r7peBmcqPLPfjCnxCzHZclWtTmES/jbJK09mQwmpsZMlZEw4dk6rI4Z8i+cPJK4CGnI70uQycgNMxP4dE8FtdKg73ucvVAJM9XmUClmkmOOtFIpwrxdZXMlVS1VfjdJa08ZIzLYX7/fZydtlSLMB/yroJLaEx3cMUca8vtze5ajQV9m0PdBJdsgIBhGTlOdRB2DARLnyEiYD3BO0ipFWAY23eazR0lKEeYD3t52hITIYBZOkBny+zN+RBhZKVG8s61EZtD3NSWbHT1RAWbVSdRKmuM4f6ZM2urVdlbvJNAYyKTISaqjKDVjxAw0NJ/dJSlFmJcrrG5i6+F6bstKwiAN+QNy+5wxlNS38E1hreoowlXam6ByNyTNVZ1EvaQ5jsvSbWpziHOyo3oH02OnYzKaVEdRKtwczrjh43y2OV+KMC/39rYSTEaNZZnSkD9Ql6aNJCrUzNvbjqiOIlyldLtjktYxUoQx+jwwmqFki+ok4iyd6DjB/vr9zBzpx/2N3WSMyGBXzS5sdpvqKC4nRZgXa+2w8ffcMi6bGkfMsEDVcbxGYICRmzIT+GJfNVWNbarjCFco2eqYLd6fp6dwMgVBXLqMhHmxvJo87LpdirBOGSMyOGE5QWFDoeooLidFmBf7KL+cxjYrd8gM+YN22+wkbHadldmlqqMIVyjZAqOmQ2CY6iSeIWmO4xROFvknwxvtqNpBgBbgt6cr6iljRAbgm5O2ShHmxd7eVsL4EcOYneKns4OfgzHRoSyYEMO720uw2uyq44hzYe1wTNI6Zp7qJJ4jaQ7YOhyFmPA6uVW5pEanEmIKUR3FI8QPiyc2OFaKMOE59hw9zq7SBm7PSkLTpCH/bNyeNYaK4218daBGdRRxLip2gbXtZEO66DZpq/SFeZt2Wzu7a3fLrshuNE0jfUS6TzbnSxHmpd7edoQgk4Hrz0tQHcVrXTRlBCPCAqVB39uVbHZcypGRJ4XGQPQEmS/MC+2u2Y3FbuG8keepjuJRMkZkUN5cTmVzpeooLiVFmBdqbLPwj7xyls4YTUSwfx++fC5MRgO3zErkq4M1lNb75mzMfqFkK0SNg2Fy4vpTJM1xNOfbZXe7N8mtykVD6+qDEg6zRjkOusmuzFacxLWkCPNC/9h5lJYOG7dnjVEdxevdmpWEQdP421YZDfNKdrtjl5tMTXG6pDnQ1gA1+1UnEYOQW5XLhMgJRARGqI7iUSZGTiQiMILtldtVR3EpKcK8jK7r/GXLEabFRzAjcbjqOF4vLiKYy9JG8e72Elo6rKrjiMGqPQitxyBJmvJPM+Z8x2XxN2pziAGz2q3k1eRJP1gvDJqBWSNnsb1CijCh0MZvaymsPsE985JVR/EZ95yfTGOblQ93lquOIgarqx9MmvJPE5kMEYlQvEF1EjFA++v302ptlX6wPsyOm015czllTb5z7l8pwrzMG5uKiBkWyFUz4lRH8RmZYyJJGx3Om5uL0HU5n6RXKdoIYXEQNVZ1Es+jaZCy0DESJn1hXiG3KheAmSNkJKw3WaMcR/360i5JKcK8yOGaE6w/UMMdc5IIDDCqjuMzNE3jnnnJHKw6wZZDctJjr2G3Q9EGSFnkKDjE6ZIXOHbXVheoTiIGYFvFNpLDk4kNiVUdxSOlRKQQExzDtgrfORuEFGFe5C+bizEbDdKQ7wZXzxhNdKiZNzYXq44iBqp6L7TUwthFqpN4rpQFjsuijWpziH5ZbBZyqnKYEye71vuiaRqzRs0iuzLbZ/ZaSBHmJRrbLLyXW8ZVM+KIDZPzRLpakMnIbVlJfLGvipI6ma7CKxR19jqlLFSbw5NFJEBkysm/lfBY+bX5tFpbpQjrR9aoLGpaayhqLFIdxSWkCPMSq7JLae6w8Z3zU1RH8Vm3Z43BqGn8dUux6ihiIIq+dswPFiETFp9RygI4shnsNtVJxBlsq9iGQTOQOSpTdRSPNjtuNoDPHCUpRZgXsNl1/rKlmFnJkUyNl7lj3GVURBCXT4tjZU4pze0yXYVHs1mheJOMgg1EyiJoPw4VvnfKF1+ytWIradFpMj9YPxKGJRAXGuczzflShHmBdfuqKK1v5V4ZBXO7e+Yl09RmZXVOqeoo4kzKd0JHk/SDDURK59/o0Jdqc4g+NVua2V2zW3ZFDoCmacweNZvsymzsuvcf9StFmBd4/Zsi4ocHc0nqSNVRfN7MMZHMHBPJa98UYbV5/wvcZx3+ynGZvEBpDK8wLBZGTYdD61UnEX3IrcrFqlvJistSHcUrZMVl0dDewIH6A6qjnDMpwjzczpJjbCuq597zkwkwytM1FO5bOJayY618sse3ThTrUwq/gLgZjhNVi/6Nv8hxHsm2RtVJRC+2lG8h0BhI+oh01VG8wtzRjtOUbSrfpDjJuZNPdQ/3p68PERFs4tbZSaqj+I2Lp4xkbEwor2w45DOHQfuU1mNQth3GX6w6ifcYdxHYrVAsU1V4oo1HNzJr1CwCjXLk+0DEBMcwJWoKG8u8f3uWIsyDFVaf4LO9Vdw1dwyhgQGq4/gNg0HjewvHsudoo0ze6okOfwW6HSZIETZgiVlgHgaF61QnET0caTzCkcYjLIiXXeuDMT9+PrtqdtHY4d2ju1KEebBXNxzCbDRwt5wncshdlxFPzLBA/rThsOoooqfCLyAoAuLlUP4BCzA7+ucOSRHmab456jjB+oIEKcIGY0HCAmy6ja3lW1VHOSduHV7RNO0y4PeAEXhN1/Vnety+EHgRmA7couv6e+7McybPPruJWbNGs3jxySMQv//9jwB45ZWru65bv76I557bzKOPzjvlvuvXF5GdXc5jj53f5/J6e+wVV7xNcvJwkpOH89hj5/Pss5v44IN9WAI06s8fxQWJkezOLufxx78AYMSIUEaPDmPcuCgCAgwcOFALwLhxURw6VH9K3mef3cTvfreJoCATl18+HoDy8iYOHTpGUdExZswYRXl5I6ARFzeMmTNH8+WXRURGBpGbW4HZbGTx4mQeemguK1bs4a9/3YXFYmfmzDi2bfsezz67iU2bSvj662ImTYqhoqKJyspmzGYj06aNIDo6hHXrDtPWZsNk0sjIiOOGG1L54IN9bN16FJPJwKWXjqO6uhmDQSMvrxKbTWfUqFDi48M5erSR+PhwIiODefTReTz33GaWLBnLF18cJjExnFtumcqKFXvIy6vk5pun8uKLWwgNNQPQ3GwhLm4YBoNGQ0Nb13OwcOEY8vIcvV433zyVV1/NRdNg+PAgYmJCWLBgDBs2HGHdusPELkqkNr2dx369gVFBJtavL8Jm01m79vY+t43u28Bgt7fBPP5cqVz/QF9r3//+R+TlVfLMM0vIzi7n0KF6Jk2M5o6aNWyvSGDtj/6FzWZn3LgoZs0azQsvbOHbb+uJiAjk5punYrXaOXSonvLyJmprWzh2rI0JE6IoLKynrq6F2bMTiI8PY8OGI4wf77i+ubmD0FAzw4cHcexYW9drAcDWeaBGeHgQzc0dWCx2AgI0dB0CAwOwWGxYLHaCgozcddcMbrllKkuWvIXdrpOYGE5IiInx46PYvbuK8vIm4uLCqKlpBmDJkrGMHh1GXl4l+fmVgMYvf7kYgIAAA8888w3R0cHU1rYycWIUERFBJCcPZ/XqvRgM0N5u5YMPbuG55zazZ081FRVNZGaOJjIymOTk4ZSWHmdGh8Z/zS3meze8SH5ZKNu2fc9lz73q7Xkonel3Bbpuc94P6HrfB7r+Js5tXrtxI+HWkRTmWPmvFY5tPj19FJMmxfDqq7lERjrem3btqqStzcbcuQns3FlBXFwYmqaxf38tzc0d6DqEhQUyf34io0eHsWFDCQcP1hEUFMCiRWO6PneSkv6bpqZ2dB2mTInhuuum8Pzzm2luthAQYAB0zGbH9tzWZiUsLJDg4ABKSxvRNI1Jk6I5cKCO4GBH+dDaaiU+fhiaplFW1sTEidGEh5upqDhBW5uVuroWjEbHe72uQ01NM/n51VgsNi67bDwLF47h73/fS1FRA3V1rUyaFI3drhMdHYzVaqepqYOamhZuuimV1av3smrVjSxenMK0mGmEmcNYnfMJeatC+eqrYpYsGctDD83tep6KixsoLm5g7drb+3yeej6HQ729au7qedE0zQgcBC4GyoBs4FZd1/d2u08yEA48AqwZSBGWmZmp5+TkuDzv+vVFLFv2XtcTvH59EddeuxJNgw8+uLnrumXL3uOJJ+bzm998c8p9uz+2r+X19tgHHvgnL7+cw/Llmbz00pVdP8csSWTYzJE0/G0/loZ2AKxWO+3tNkJCTNx99wxefjmHoKAAzGYjv/jFIn75y69PyfvCC1t4+OHPADCZDBiNGm1tts6/Peg6GAyOU/A5L9PSYigoqD3lbxMYaETXoaPD8VijUePzz+/kxRe3smbNQYxGjaCgANrarNhsfW9PJpOByy8fz5o1B0+53mjUTnncyWwadrvO0qUT2by5jJtuSuVPf8rh/vszeeed3VgsdjTt5N/FZDJgsZw8otH5O3UXFGTEaDRgtdrp6LBx9dUTT8mzdOnJnw2BRlIezCA5yMy6pzYD8Pzzl5CRMYrrrluJrsOHH97c5zZwJn1tHwN9/LlSuf7e1t3b3/Paa1dis9kJCDDw5JOLePLJ9YwbVs6u+9/i3z6+lNdz0wgMNPLrX1/E//t/62lttXD//Zn89a+7aG62sHz5ye8B5s1LYPPmslOy9Nxmuv/c22uhL5GRgRw71t71s9lsxGazn7Jd91x/z+0+KCiAjg5r1za7fHkm48dHdb2GAZKTwykubmTkyBCqqlq61qtpEB4eyKJFY07Znrv/DinDGzj84J958NMLeH1PFh99dKvLnnvV2/NQOtPvCpzyvXO7/sUvFvHUU193bePO2zBZSfnd+8wPu4K3vjPslPe0jg5HweXcZrpvm0ajhtFo6HpP7qnne9/y5ZmsXr2XJ56Yz89//iVtbSfnQXRuU049t8uB6Lk+53t47/d1vK93z/baaztOeR32fD05Mzo/C5x/+7tWLyenIpf/nbqCvLwqHnnkM373u0t46KG5p3229vU8DcX2qmlarq7rvQ7du7MImwv8p67rl3b+/ASAruu/6eW+bwIfqyzC4OSLa/nyTF5+OeeUJ6v7dd2ftJ7X97e83h7rLC7mz0/im29KuHd5Jl8E2Wg/3EjDJ8V0dNi4447prFlzAIvFjs12atFx553T+eSTwl7z9vaic3K+cOLihlFRcaLreueLsLcXo/ODxPkiM5kMhISYWLp0En/7Wz6adnrh05vlyzN5/fWdfb6JOJc/c2YcO3ZUcMcdjt/RWcRefvl4/va3fEwmA5qm0d5uIzDQ8cFnteq9vgmYTI7iq/vfEugaweguKCgAXdcJnj2S8LlxVPy5AHOrjYcemtvvtjFQA9mG3Enl+gf6WgO49tqVWK12rFYbP5m1lWeWfEPK/y6nuC4YgIAAx3bqfPNdv76Iq69+l+ZmS9c27NzWAwIc20BAgIbV6thAnLeZTAYMBse25HzcmT5MBqrnhw6c+UPKaNQwmYy0tVm78oaGmpg3L5HPPz9MWJiJpiZL1+s/JsYxQub8PQIDjWgaXf9wOcXFDeOza/9IeFwih+a/6fLnXvX2PJTO9Lt2v+33v9+GpsGPf5x1yvfOx+xpzebVmqc5v/wHvPtMA5pG13up859F5/bTV3HU2/blZDYb+c1vLjrlPfOOO6azevXeXj8TAJdu+458p38m9PX+3PN9GBz/OLe12U4rppYvz+TN7BVE3LKZ1VevZnLUZF54YQuPPPJZ12fp/fc7is/+nid3b69nKsLc2RMWD3Sf8bKs87pB0zTtPk3TcjRNy6mpqXFJuN4sXpzC8uWZPP30BpYvz2Tx4pRer+vrvgNZXm/Xv/TSlcyfn8TGjSXMn5/EhKvGoZmM1G08Snu7jfnzk3jrrXx+/OMsHn54Lu3tjjdXi8XOggWO2/rK+9BDc7uGwXuy2yExMZyKihOEh5u7rrfZdBYsSDrtBb9gQRKbNn2XxMTwrhfQ44/P58c/zuKtt/KZPz+pzwKs+/IXLEjipZeu5Kc/7XvYV9cd2XJzK7p+f+fvs3x5Ztf6OjocBemCBUm0t9uwWvVT8nVnsdhP+1u2tFiwWOwkJoafct9HH53HY4+dT2N2FbrFzvil43noobkD2jYG6lwff65Urn+gr7XFi1N48MEsWlosdHTYuWNWGbnlIyiuC2bBAscRw1arzvz5SV27IRYvTun63mZzbA/O7dJqdbxmnAUYnHwdWCwntyXntq/rp267/XFm6u7nP19wyjLCw81n/HD72c8WdL1mnXkfemgun3/u2A3f1GTBYHBsz2azgdra1lN+x8ceO59HHz31tWU2G6ioOMHOlgyS7LtZPGe4y5971dvzUDrT79r9tgcfzOLHP8467XvnY45F7sdoN/Pqk+Vdtzvf26xWxxPq3J3t3Ca7v1c5nve+N6af/vT8094z33orn0cfnXfae55zG3W+ZgZSgPX32ggPN/f6maDrp79WHn98fq+vn7Y2G4mJ4bz00pXAqX/fW+dciUEzsL7EMQfeQw/NPeWz9KWXrhzQ86Rye3XnSNhNwKW6rv9b5893ArN1Xf9RL/d9ExkJY/78JDbnljPmh+m0FjZw/NMj2Gx2GQlTOBLW3m4janECw2aNpOHtAzz4nfNkJMxN64Yzj4TFBB6n6Ed/4pcb5vPbLSf/GZGRsIGPhI0xHmTLd1dQMOU3XPDDZhkJO0uuGAlbsfJ6njx6L9U7w7l12MNdt8tI2KnONBL28ss5nP+HHAJCbLy39D0ZCeuhDEjs9nMCUO7G9Z2T7vuEn3pqMatW3ci1167kuutWnnLdsmWOJ7rnfZcte4/164vOuLzeHnvTTam8/LKjz2nDhntZeF86VnQat5Tz9NOLCQwMICTExPvv76OtzUpLiwWj0cDy5ZmdTcAB/OMfB3jiifmn5X3iifk8/PBntLVZMZkMBAUZu/I5iyWDASoqTmDo3BLS0mK6XujOy8BAI2az47GbN5dhNGqsW3cXS5dOxGKxc+JEB++/v6/zzaDvv7HJZGDp0okAvPxyzik9Zt117wnLza3g6qsn8sknhdx0UyqPPPIZN92Uypo1BwgONmEynfyd7Ha964PV2e/WncViJzDQ2PW3bG21sGRJyikvfGe+tjYr7e2OF/5PrpiMbrFjSo9l+PAgVq26keuuW8m1156+bXTfBs6kr+1joI8/VyrX39u6e/t7XnvtSq6++l00DZ5+ejFLJxdh0ODjwgldHzqBgUZ++9uLCQ428cgjn/HAA//sKsCWL88kKMjRPGy3O/6BcI4uOLcTk8nQtc1aLPau5dpsOmlpMQP+EIqMPHV+J7PZ2LVdO5c5b97JE43r+unbfVBQAAaDY91tbVaWL8/kt79dAjgONPn888MkJztGwkaODMFisRMZGUhtbSua5mjKXrp0Iu3ttq4CLC3t5GS2FRUnMCZlUnUihL3v/9Wlz73q7Xkonel3PbW3KLnrvWz48KCu7xcvTmbVqhu59aGXaLQf474LT97XYrHz/vv7unoK581L6Np+DIaT24vRqHW9J/dWgDnf+zo6bDz8sOM985NPCvnd7y45rQBLTg4/7fEwuAKs53ut1m3T7vmZYDBopyx7+fLM0wqw7q+ntjYbycnhvPxyDtdc8+5pf/udq0M4cOwAv3zxo66esA0b7uX++08OcpzpeVK9vbpzJCwAR2P+RcBRHI35t+m6XtDLfd9E8UiYJxwd+d0HMsn6ry8IqGolYu8xbrghtevoGjk6UsHRkbGh/PCHswHY2tbGjuZWxh1oYt2Ht8rRkS5e90COjry8/gkSg6u5dO1DVFSc4KqrJsnRkYM4OnLXripCQkz8/qJ/Mm/4DsJ+WeqYusIFz73q7XkoueroyEt/vZyKuC1sun0jL7+Yz6xZo7vez+ToyP6PjnRa/fkWniq/j+E7L+S6pFs88uhIJY35nSu+AscUFEbgz7qu/0rTtKeAHF3X12iaNgv4AIgE2oBKXdfTzrRMd+6OVO2ZT/bzyoZDfP6ThYwfEaY6juimpqmdhc+uZ0nqSP5wa4bqOP6nrRGeGwez74NLf6U6jXfbvxZW3Ap3fgDjLlSdxi/pus4V71/BmIgx/GnJn1TH8Xo3rLmBMHMYb172puoovVK1OxJd19fquj5R1/Vxuq7/qvO6J3VdX9P5fbau6wm6rofquh7dXwHmy6oa23hzcxFXTx8tBZgHig0L5LvzU/hoVzl7jh5XHcf/FH4Btg6YfJXqJN5v3GLH7PkFH6pO4rcOHjtI2YkyliQtUR3FJ1yYdCE7q3dS31avOsqgyYz5HuK/Pz+Iza7zyCWTVEcRfbhv0VgiQ0z89tP9qqP4n73/gJAYSJytOon3MwXDpMth3xqwWVSn8UvrStahobE4cbHqKD5hSdIS7LqdL458oTrKoEkR5gG+rWpiVU4pt2eNISk6RHUc0YfwIBM/WDyejd/WsqlwYJN4Chdob4KDn0LadWAw9n9/0b+06xwnQi/6WnUSv6PrOp8UfcLMkTOJDo5WHccnTIycyNiIsawtWqs6yqBJEeYBfvvpAULNAfzowvGqo4h+3DFnDPHDg/ntp/txZz+l6Gb/WrC2wbQbVSfxHeMugsBw2POB6iR+Z2/9Xoobi7ly7JWqo/gMTdO4POVydlTtoLK5UnWcQZEiTLHtRfV8sa+K+y8YR/SwwP4fIJQKMhn5ycUTyS87zsf5Farj+Ic970FEIiTIrkiXMQXBpCtg/0dg7VCdxq/88/A/MRlMXDzmYtVRfMoVKVego/Ov4n+pjjIoUoQpZLfr/GrtPkaGB/Kd831zUkNfdF1GPKlx4fxm7T5aOnqf8FC4SEs9HPoSpl5/+mRE4txMvR7ajsOhdaqT+A2b3canRZ+yIH4BEYERquP4lKTwJKZGT+Wfh/+pOsqgyLuaQu/llrGrtIFHL51MsFl6XbyF0aDxy2vSKD/exstfHVIdx7ft/RDsVpgquyJdbuxiCImGvLdVJ/Eb2yu3U9NawxVjr1AdxSddnnI5++r3UXTceyYJliJMkYaWDp75dD+ZYyK5PuOsTqkpFJqVHMU16aN5ZcNhSupaVMfxXXnvQuxkGDVNdRLfE2CG6TfDgU+huU51Gr/w8eGPCTWFsihhkeooPunylMsxakY+LPSe6VekCFPk+c8O0tDSwVPXTD3ldBTCezxx+RQCDBpP/3Ov6ii+qXoflG2HjDtPPQ+KcJ3028Fugd2rVCfxeY0djXxW/BmXJV9GUECQ6jg+KTYkloUJC/lH4T+w2L1j+hUpwhTYc/Q4f9t2hLvmJpM6uvfzdgnPNyoiiB9dOIHP91ax/kC16ji+Z8dfwWCCGbeoTuK7Rk2FuBmwU3ZJuts/D/+TNlsbN026SXUUn3bDhBuoa6tjQ+kG1VEGRIqwIWaz6/zHh3uIDjXzk4snqo4jztF35iczLjaU//hgDyfapUnfZaztsOtdmHIVhMb0f39x9tLvgKrdUJ6nOonP0nWd1QdXMyVqCmnRfntimCFxfvz5jAgZwd+//bvqKAMiRdgQ+/M3ReSVNvAfV6YSEWxSHUeco8AAI8/eOJ3y4608KzPpu86+jxyTiZ53l+okvm/ajRAQDDmvq07is3bX7ubbY99y40Q5wMTdAgwBXDv+WjaVb/KKOcOkCBtChdUneO6zA1ycOpJr0kerjiNcZOaYKO6dl8Jftxxh22FpcHaJ7NdheBKkXKA6ie8LiYLpyyB/tWNKEOFyqw6sIjggWCZoHSLXT7gegJUHVipO0j8pwoaIza7z6Hu7CDEb+dV1U9Gk0dinPHLpRJKiQvjp3/Np7bCpjuPdju6Aks0w+/syN9hQyfo+WFsdfXjCpWpba1lbtJal45YSagpVHccvxA+L56Kki1h1YBUtFs8+el3e4YbIaxsPs7OkgV8u2zt9OgAAFbtJREFUTWNEmBwZ42tCzAE8c8M0iuta5ATf52rrS2AOg/PuVJ3Ef4xMg+QFkP0a2KS30ZXe2fcOVruVu1Jl1/pQuiv1Lho7GllzaI3qKGckRdgQ2HP0OM9/dpBLUkeydIbshvRV88bFcO/5yby5uZjP91apjuOdjh+Fgg8cvWBBMqP4kMr6Phwvhf0fq07iM1osLaw8sJILky4kKTxJdRy/MiN2BtNipvHW3rew63bVcfokRZibNbZZeODtHUQPM/PMDdNlN6SPe/zyyUyND+fR93ZR3tCqOo732f4K6HZHQSCG1qQrIGocbPwdyMnpXeLDwg9p7GjknrR7VEfxO5qmcVfqXZQ0lbC+ZL3qOH2SIsyNdF3np+/lc7ShlT/cmkFUqFl1JOFmgQFG/nDreVisdh5csROrzXP/A/M4zbWw/TVIux4ix6hO438MRlj4CFTuhoOfqk7j9TpsHbxR8AYzYmeQPiJddRy/tGTMEpLCknh518seOxomRZgb/WVzMZ/sqeSxSyeRmRylOo4YIikxofzqumlkFx/jd58dVB3He2z6vaM5fNFPVSfxX9Nugshk+PpZGQ07R6sPrqayuZIfpP9AdRS/FWAI4P4Z93Pg2AHWlXjmieqlCHOTLYfq+NXafVw0eQTfWzBWdRwxxK7NiOe2rCT+9PUh3t9RpjqO52uqgu3/B9OWQaxMYqyM0QQLHobyHfDt56rTeK0WSwv/l/9/zBo1izlxc1TH8WtXpFxBSkQKL+W95JGjYVKEucGhmhPc/7dcxkSH8sLN6XJuSD/1y6VpzB0bzeN/301Oscy/dEbfvAC2Dlj0mOokYvotEJkCnz8pR0qepXf3v0tdWx0/yviR9AErZjQYeWDGAxQ2FPLPw/9UHec0UoS5WN2Jdu59I5sAg8Yb98ySWfH9mMlo4OU7zmP08CC+/1YupfWePV+NMjUHHFMjZNwB0eNUpxEBZrj4KajZBzv+ojqN16ltreW13a+xIH4BGSMyVMcRwCXJl5AWncaLuS963LxhUoS5UGuHjfveyqWqsY3/uzuTxKgQ1ZGEYsNDzLx+zywsNjt3/3k71U1tqiN5Fl2HTx4Dcyhc9KTqNMJpytUwZj6s/xW0HVedxqu8kPMC7bZ2fjpbehs9hUEz8Pjsx6lurebV/FdVxzmFFGEu0tph47t/yWZnyTFevDmd85IiVUcSHmJc7DD+fM8sKo63cedr26lv7lAdyXPs/xgOfwWLfy4n6vYkmgaX/spxGqMv/0t1Gq+RW5XLR4c/4p60exgTLkf4epL0EeksHbeUv+z9C8XHi1XH6SJFmAu0WWx87685bDlcx/PLZnD5tDjVkYSHyUyO4vW7Mymqa+bO17dxvNWiOpJ6rcdg7WMwIg0yv6s6jehpdDrMvg+2vwpHNqtO4/Habe3819b/Ii40jn+b9m+q44he/GTmTwg2BvPk5iex2T3j9HJShJ2jlg4r972Vy6ZDtTx34wyuy0hQHUl4qHnjY3jljpkcrGri9te2UtPUrjqSWmsfg+ZquPaPYAxQnUb0ZskvYPgY+McPoMOzemk8ze93/J7ChkKenPskISZpRfFEMcExPJ71ODurd/LW3rdUxwGkCDsnNU3t3PrqVr75tobfXj+dG2dKASbObPHkEbxy50wKq09ww8ubKa5tVh1JjYIPYfcqWPgojJbmZY9lDoWlf4D6w/DZf6hO47G2lG/hrb1vccukW5gfP191HHEGV4+9mouSLuJ/dv4P3x77VnUcKcLOVmF1E9e9tIkDVU28cmcmy2Ylqo4kvMSFk0fy7vfm0NRm4YaXN5NX2qA60tCqLYQ1P3YUXwseVp1G9GfsIpj3I8h5HXatVJ3G41Q1V/Gzb35GSkQKD2U+pDqO6IemaTw590nCzeE8/PXDNFvU/iMsRdhZ+HxvFde/tJk2i52V983l4tSRqiMJL5ORFMnfl88jJNDIsle28Pa2I+j+MEN523FYcatj9+OyvzomBxWe76L/hDHnw0cPQuUe1Wk8Rpu1jQfXP8j/b+/Oo6Mq0zyOf59UFgIJkLBGwiICjqLSsgiN2MoBxMFul2lU7OkZ0LbVg55ptz7a0kdRZ1pahp7RM844jlvr2I7dLi2tKNqtuOAKDJvsKEgMgrKEQExSyzt/3BumjJWQhFTdVNXvc06lbtV9b9Xz1nvvzVP3fevemnANC85cQGFuYdAhSQuUdipl/pnz2X5gOw+veTjQWJSEtUJ9JMadf1rHTx9fRv/Szjw/ezwj+ncPOixJU4N7FfHCNRMYN7gHc55fyw2/X0VNfQafHDNSD89c7nVtXfw4dB8QdETSUqFcmP4oFHaHJy+C/Z8FHVHgorEov1z6S9btWce8M+YxtGRo0CFJK4zpO4b7J93PVSOuCjQOJWEttGlXNdMfeJdHln7KrPGDeG72eJ0HTI5aaZd8Hps1hhumDOOPKz/n3Pve4YNP9gQdVvuLRuDZy2HLn+HcBTBI42bSTnEf+NtnIHwInrgQDn4ZdESBibkYt797O4u3LeaGUTcwccDEoEOSNpjQbwIFoYJAY1ASdgS14Sj3vLKBafe+zWd7a3jgx6OYe95wCnJDQYcmGSInx/iHSUN58oqxRGIxLnnwfeY8v4YDtRlyGotIHTz3U1j/J5h6N4yaFXRE0lZ9T4If/R6qPofHzoWq7LsuaiQW4Y737uCFrS8we8RsZp00K+iQJI1Zuo1DGT16tFu2bFnS3ycWc7y0ZifzF2/ks701TB9Vzq3TTqC0S37S31uyV019hN+8uolHln5KaZcCfjZ5KDPG9CcvlKbfl77eB0//HWx7GybfAROuCzoiaQ/b3oGnLoWCYu/oWJ8Tg44oJQ7WH+Smt25i6edLueqUq7jmO9fo2pByRGa23Dk3OuE8JWHf5Jzj9Q27+edXN7F+5wGG9Sli7nnDGX+czuYtqbNqx37+6aX1fLhtL4N6dOb6KcM49+QyctMpGav8X3jmJ1C1A86/H065OOiIpD19sQb++4dQVw3f/xcYMSPoiJJq496N3PzWzWw/sJ054+Ywfdj0oEOSNKEkrBWeXV7BjX9YxcAenbl+8jB+MOIYQjn6piOp55zjjY27ueeVjWz4opp+3QuZNX4Ql5zWn66dOvCvCiP18N6/wRu/gi69YPrDMHB80FFJMhzYCc9eAdvfgZMvhqm/gqJeQUfVrsKxML9b/zvuXXEvXfO7Mu978xhXNi7osCSNKAlrhdpwlIUrK7lwZL/07QKSjBKLOf6yYTcPvf0JH3y6l8K8EFOH9+HCkeVMGNKz43xJcM4beL/4VvhqE5xwHvzgXuhcGnRkkkzRCLw1H95e4J3cdeKtMHIm5HUKOrKj4pzj3cp3mf/RfLZWbeWs/mdxx/g7KO2k9VlaR0mYSIZYU1HFUx99xourKjlQG6FnUT4Tj+/NpBN6M2FoL4oKArj8TzQMGxfBO/8KlSugdDCcMw+GTU19LBKcLzfCSzd64/+Kj4Hx18J3fgSFJUFH1irhWJglO5bw6NpHWfPVGsqLyvn5mJ8zsf9Ejf+SNlESJpJhasNRXt+wm5fXfsGSjbupro0QyjFOLOvKqIEljB5UwsgBJZR165ScfxyRetjxPmx8xbv80KEvoWQQTLgeRlwKucH+7FsC4hx8+iYsmQefvQe5neCvzvVuQ6ZAp65BR5hQOBpmxe4VLNmxhEWfLmJv7V7Ki8q57KTLuGDIBeSH9IMsabvAkjAzOwe4FwgBDznn5jWaXwA8DowC9gCXOOe2NfeaSsJEvikcjbF8+z7e3vwly7btY1XFfmrDMQCKO+VyfJ9ihvYpZmjvIspLCjmmeyH9uhfSvXNeyxO0mr2wc5U32P7z5fDJm1BfDTl53hGvU3/s/ZPVhbilwc7VsPxRWLcQar7y1pUB46DfKCgfA2UjoGs/yEntsA/nHPvq9rFhzwY+3vMxq79azYc7P6QmUkNeTh5nlp/JBUMu4PR+p5Obo/VZjl4gSZiZhYBNwBSgAvgIuNQ5ty6uzGzgFOfc1WY2A7jQOXdJc6+rJEykeeFojHWVB1i5Yz+bdlWzeddBNu2uZn9NmBxiFFBPAWG658coLzZ6d3L0za+lT+4heubWUGIH6e6q6VZXSdHXFXQ+VEFefdXh1490G0Rk4BlEj5uMO/ZMcgu7kptjhHJM3TXybbEo7PgQNr4E25Z6v6qM+efAyy2EHkOgZCAU94WiPt6tS0/IL4KCIijo6k3nd4ZQvpfM5YTAjGgsSl20jvpo/eH7r6NfU1VXRVVdFfvr9lNVV8W+2n1UHqqkorqCiuoKqsPVh8MbUDyAsWVjOaPfGYwtG0vnPJ2EW9pXUEnYd4G5zrmp/uNfADjn7o4rs9gv856Z5QJfAL1cM0ElOwl7f/l/cveq+1u1TPOfYOK5qeoEbsv7pKo+qVqmtUt15Loc1TLOtfgVHEaUnLhbiLALESGXGE0lWo7/z8Hsm6UaLdLaVM2+sVDrP4VULNE2qdsKOs77OELEyCGG4fx7b62yFr5nFAibEWlh0p8fc/SJOMoijj4R6BtxHBeG4+qgizM/KvwI9EUim+wafgWn/TC55y9sLglL5rHWfsCOuMcVwNimyjjnImZWBfQAvoovZGZXAlcCDBiQ3OvNdelUypD8bs2USLyBtmWzteaWamJWs8u09sWaXSI1sTW7RBM72Obf5dtz2/IezWufuI789u34PpjX7ZMTAgt9+z433xvHFSogmpNPXSyHqINI1BGNxYjEHNGYO3wfizlizuvaidEwDTHn/HtvXsP3qfh/rfFfsZzzQ3bNlPH/xs9v23bQFm1KF9tviSZzktTsB9riaNomx8XIc7XkuTpyXYSQCxNyEXKJkOOi5LjY4aStwBn5DvKd82+Q74w8jC6xEEWxHLo4777gcFwNKZbDchzVhY5qiEsA02uMtBy9vOJgzwGazCQs0ZbYeA1vSRmccw8CD4J3JOzoQ2vaycMvYsHwi5L5FiIiIiJJvXZkBdA/7nE5UNlUGb87shuwN4kxiYiIiHQIyUzCPgKGmtmxZpYPzAAWNiqzEJjpT08HXm9uPJiIiIhIpkhad6Q/xutaYDHeKSoecc59bGZ3AsuccwuBh4EnzGwL3hGwzL74mIiIiIgvqSdBcc4tAhY1eu62uOlaQAOwREREJOvo4ogiIiIiAVASJiIiIhIAJWEiIiIiAVASJiIiIhKApF7AOxnM7EtgexsX70mjs/FnkWyuO2R3/bO57pDd9c/muoPqn83170h1H+ic65VoRtolYUfDzJY1df2mTJfNdYfsrn821x2yu/7ZXHdQ/bO5/ulSd3VHioiIiARASZiIiIhIALItCXsw6AAClM11h+yufzbXHbK7/tlcd1D9s7n+aVH3rBoTJiIiItJRZNuRMBEREZEOQUmYiIiISAAyNgkzs6fNbKV/22ZmK5sot83M1vjllqU6zmQxs7lm9nncZzCtiXLnmNlGM9tiZrekOs5kMbP5ZrbBzFab2fNm1r2JchnT/kdqSzMr8LeLLWb2gZkNSn2UyWFm/c3sDTNbb2Yfm9nPEpQ5y8yq4raJ24KINRmOtB6b5z6/7Veb2cgg4kwGMzs+rk1XmtkBM7uuUZmMansze8TMdpvZ2rjnSs3sNTPb7N+XNLHsTL/MZjObmbqo20cTdU/f/b1zLuNvwALgtibmbQN6Bh1jEuo8F7jpCGVCwFZgMJAPrAJODDr2dqr/2UCuP/1r4NeZ3P4taUtgNvCAPz0DeDrouNux/mXASH+6GNiUoP5nAS8GHWuS6t/segxMA14GDBgHfBB0zEn6HELAF3gnx8zYtge+B4wE1sY9dw9wiz99S6J9HlAKfOLfl/jTJUHXpx3qnrb7+4w9EtbAzAy4GHgq6Fg6oNOALc65T5xz9cD/AOcHHFO7cM696pyL+A/fB8qDjCcFWtKW5wO/9aefASb520fac87tdM6t8KergfVAv2Cj6lDOBx53nveB7mZWFnRQSTAJ2Oqca+tVVdKCc+4tYG+jp+O3798CFyRYdCrwmnNur3NuH/AacE7SAk2CRHVP5/19xidhwBnALufc5ibmO+BVM1tuZlemMK5UuNY/PPtIE4em+wE74h5XkJn/uC7HOwqQSKa0f0va8nAZf4dVBfRISXQp5Hezngp8kGD2d81slZm9bGbDUxpYch1pPc6WbX0GTX/hztS2b9DHObcTvC8lQO8EZbJhPUir/X1u0AEcDTP7M9A3waw5zrkX/OlLaf4o2OnOuUoz6w28ZmYb/Ey7w2uu/sB/AHfhrXR34XXJXt74JRIsmzbnLGlJ+5vZHCACPNnEy6Rt+zfSkrZM6/ZuCTMrAp4FrnPOHWg0ewVeN9VBf4zkH4GhqY4xSY60HmdD2+cD5wG/SDA7k9u+NTJ6PUjH/X1aJ2HOucnNzTezXOBvgFHNvEalf7/bzJ7H69ZJi3/CR6p/AzP7L+DFBLMqgP5xj8uBynYILSVa0P4zge8Dk5w/ICDBa6Rt+zfSkrZsKFPhbxvd+HaXRtoyszy8BOxJ59xzjefHJ2XOuUVm9u9m1tM511Eu8ttmLViP03pbb6G/BlY453Y1npHJbR9nl5mVOed2+l3NuxOUqcAbH9egHFiSgtiSLl3395neHTkZ2OCcq0g008y6mFlxwzTe4L61icqmm0bjPS4kcb0+Aoaa2bH+t8gZwMJUxJdsZnYOcDNwnnOupokymdT+LWnLhUDDr6GmA683tbNKN/7YtoeB9c653zRRpm/DGDgzOw1v/7cndVEmRwvX44XA3/u/khwHVDV0XWWQJns9MrXtG4nfvmcCLyQosxg428xK/CEqZ/vPpbW03t8H/cuAZN6Ax4CrGz13DLDInx6M9yuyVcDHeN1YgcfdTnV/AlgDrMbbOMsa199/PA3vl2RbM6z+W/DGPqz0bw2/CszY9k/UlsCdeDsmgE7AH/zP5kNgcNAxt2PdJ+B1q6yOa/NpwNUN+wDgWr+dV+EN3h0fdNztVPeE63Gjuhtwv79urAFGBx13O38GnfGSqm5xz2Vs2+MlmzuBMN7RrZ/gje/8C7DZvy/1y44GHopb9nJ/H7AFuCzourRT3dN2f6/LFomIiIgEINO7I0VEREQ6JCVhIiIiIgFQEiYiIiISACVhIiIiIgFQEiYiIiISACVhIiIiIgFQEiYiIiISACVhIpLVzOwNM5viT/+jmd0XdEwikh3S+tqRIiLt4HbgTv+ivqfiXQRaRCTpdMZ8Ecl6ZvYmUASc5ZyrDjoeEckO6o4UkaxmZicDZUCdEjARSSUlYSKStcysDHgSOB84ZGZTAw5JRLKIkjARyUpm1hl4DrjRObceuAuYG2hQIpJVNCZMREREJAA6EiYiIiISACVhIiIiIgFQEiYiIiISACVhIiIiIgFQEiYiIiISACVhIiIiIgFQEiYiIiISgP8DDLp1Ucjk4oEAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 720x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "gmm.exp_maximize(20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}