Part_I/practicalMixGaussB.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# practicalMixGaussB\n",
    "\n",
    "The goal of this notebook is to fit a mixture of gaussians model to some one-dimensional data. To do this, we will first generate some data from a known mixture of gaussians model and fit our own mixture of gaussians model to the generated data. The parameters from our estimated mixture of gaussians model should roughly match those of the original known model. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os \n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy.io as spio\n",
    "from scipy.stats import norm \n",
    "import time\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Construct Ground Truth Mixture of Gaussians Model and Plot Some Points\n",
    "\n",
    "Define some true parameters for our ground truth mixture of $k$ Gaussians model. We will represent the mixtures of Gaussians as a python dictionary. Note that we are working in one dimension, but if we were to require $d$ dimenisions, the mean field would be a $d \\times k$ matrix and the cov field would be a $d \\times d \\times k$ matrix. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "mixGaussTrue = dict()\n",
    "mixGaussTrue['k'] = 2 # number of gaussians\n",
    "mixGaussTrue['d'] = 1 # dimension of the data\n",
    "mixGaussTrue['weight'] = np.array([0.3, 0.7]) # weight assigned to each gaussian\n",
    "mixGaussTrue['mean'] = np.array([[-1,1.5]]) # the mean for each gaussian \n",
    "mixGaussTrue['cov'] = np.reshape([0.5, 0.25], newshape=(1,1,2)) # the covariance for each gaussian"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**getGaussProb**, **sampleFromDiscrete**, and **drawEMData1d** are helper functions. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# subroutine to return gaussian probabilities\n",
    "def getGaussProb(x,mean,var):   \n",
    "    \"\"\"\n",
    "    Returns the likelihood that each data point in x belongs to the Gaussian described by mean and \n",
    "    var.\n",
    "    \n",
    "    Keyword arguments:\n",
    "    x -- 1 by n vector of data points. n is the number of data points.\n",
    "    mean -- scalar containing the mean parameter of the Gaussian distribution.\n",
    "    var -- scalar containing the variance parameter of the Gaussian distribution.\n",
    "    \n",
    "    Returns: \n",
    "    prob -- scalar contianing the likelihood that each data point in data belongs to the Gaussian \n",
    "    distribution defined by mean and var.\n",
    "    \"\"\"\n",
    "    mean = np.squeeze(mean)                                        \n",
    "    var = np.squeeze(var)                                          \n",
    "    prob = np.exp(-0.5*((x-mean)**2)/(var))                        \n",
    "    prob = prob/ np.sqrt(2*np.pi*var)                              \n",
    "    return prob                                                    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def sampleFromDiscrete(probDist): \n",
    "    \"\"\"\n",
    "    Draws a random sample from a discrete probability distribution using a rejection sampling method.  \n",
    "    \n",
    "    Keyword arguments:\n",
    "    probDist -- discrete probability ditrubtion to sample from.\n",
    "    \n",
    "    Returns: \n",
    "    r -- sampled point.\n",
    "    \"\"\"\n",
    "\n",
    "    nIndex = len(probDist)                                                                 \n",
    "    while True:                                                                            \n",
    "        #choose random index                                                               \n",
    "        r=int(np.floor(np.random.uniform()*nIndex))                                        \n",
    "        #choose random height                                                              \n",
    "        randHeight = np.random.uniform()                                                   \n",
    "        #if height is less than probability value at this point in the                     \n",
    "        # histogram then select                                                            \n",
    "        if randHeight<probDist[r]:                                                         \n",
    "            break                                                                          \n",
    "    return r                                                                               "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def drawEMData1d(data, mixGauss):\n",
    "    \"\"\"\n",
    "    Draw the data, data, in histogram form and plot the mixtures of Gaussian model, mixGauss, on top of it.\n",
    "    \n",
    "    Keyword arguments:\n",
    "    data -- 1 by n vector of data points.\n",
    "    mixGauss -- dict with mixture of gaussian information.\n",
    "\n",
    "    \"\"\"\n",
    "    # delete previous plot if it exists                                                                   \n",
    "    # hold off;                                                                                           \n",
    "    # bin the data to make a histogram                                                                    \n",
    "                                                                                                          \n",
    "    binWidth = 0.1;                                                                                       \n",
    "    binMin = -4.0;                                                                                        \n",
    "    binMax = 4.0;                                                                                         \n",
    "    nSteps = int(np.ceil((binMax - binMin) / binWidth))                                                   \n",
    "                                                                                                          \n",
    "    nDims, nData = data.shape                                                                             \n",
    "                                                                                                          \n",
    "    xHist = np.linspace(binMin, binMax, nSteps, endpoint=True)                                            \n",
    "    xHistExt = np.append(xHist, np.inf)                                                                   \n",
    "    yHist, _ = np.histogram(data, xHistExt)                                     \n",
    "                                                                                                          \n",
    "    yHist = yHist / (nData * binWidth)                                                                    \n",
    "    plt.cla()                                                                                     \n",
    "    plt.bar(xHist, yHist, binWidth, edgecolor='b')                                                        \n",
    "                                                                                                          \n",
    "    # calculate Gaussian data                                                                             \n",
    "    nGauss = mixGauss['k']                                                                                \n",
    "    gaussEnvEst = np.zeros(xHist.shape)                                                                   \n",
    "    for cGauss in range(nGauss):                                                                          \n",
    "        # calculate weighted Gaussian values                                                              \n",
    "        gaussProb = mixGauss['weight'][cGauss] * getGaussProb(xHist, mixGauss['mean'][:,cGauss],          \n",
    "                                                              mixGauss['cov'][:, :, cGauss])              \n",
    "        plt.plot(xHist, gaussProb, 'm-')  # weighted components of MoG                                    \n",
    "        # add to form envelope                                                                            \n",
    "        gaussEnvEst = gaussEnvEst + gaussProb                                                             \n",
    "                                                                                                          \n",
    "    plt.plot(xHist, gaussEnvEst, 'g-')  # final mixture of Gaussians                                      \n",
    "                                                                                                          \n",
    "    # tidy up plot                                                                                        \n",
    "    plt.xlabel('Data Value')                                                                              \n",
    "    plt.ylabel('Probability Density')                                                                     \n",
    "    # set(gca,'Box','Off');                                                                               \n",
    "    # set(gcf,'Color',[1 1 1]);                                                                           \n",
    "    plt.xlim((binMin, binMax))                                                                            \n",
    "    plt.ylim((0, max(yHist) * 1.5))                                                                       \n",
    "                                                                                                          \n",
    "    return                                                                                                \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mixGaussGen1d(mixGauss, nData):  \n",
    "    \"\"\"\n",
    "    Generates data from a one-dimensional mixture of Gaussians model. \n",
    "    \n",
    "    Keyword arguments:\n",
    "    mixGauss -- dict containing the mixture of gaussians arguments.\n",
    "    nData -- number of data points to generate.\n",
    "    \n",
    "    Returns: \n",
    "    data -- 1 by nData, generated data points. \n",
    "    \"\"\"\n",
    "    \n",
    "    # create space for output data                                                                               \n",
    "    data = np.zeros(shape=(1, nData))                                                                            \n",
    "    # for each data point                                                                                        \n",
    "    for cData in range(nData):                                                                                   \n",
    "        # randomly choose Gaussian according to probability distributions                                        \n",
    "        h = sampleFromDiscrete(mixGauss['weight'])                                                               \n",
    "        # draw a sample from the appropriate Gaussian distribution                                               \n",
    "        \n",
    "        data[:, cData] = np.random.normal(mixGauss['mean'][:,h], np.sqrt(mixGauss['cov'][:,:,h]))\n",
    "        \n",
    "                                                                                                         \n",
    "    return data                                                                                                  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With all the helper functions complete, we can now generate and plot some points from our model. The blue bars are the histogram of the generated points. The green curve is what the complete mixture of gaussians model looks like. The pink curves are the component gaussians. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAGwCAYAAABPSaTdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABkB0lEQVR4nO3dd3gU5d7G8e9mk2wS0jslkIhI76gUAUFBQRA5FtRDU/SIFURR0ffYjopdbGAHCyCiFEWKqAgIIlICSO+hJKSR3nfn/SMSjUkwIWWSzf3hmgt26j2bJfll5nmesRiGYSAiIiLipFzMDiAiIiJSnVTsiIiIiFNTsSMiIiJOTcWOiIiIODUVOyIiIuLUVOyIiIiIU1OxIyIiIk7N1ewANc3hcHDy5El8fHywWCxmxxEREZFyMAyD9PR0GjVqhItLxa7V1Lti5+TJk0RERJgdQ0RERM7BsWPHaNKkSYW2qXfFjo+PD1D4Zvn6+pqcRkRERMojLS2NiIiIop/jFVHvip0zt658fX1V7IiIiNQx59IERQ2URURExKmp2BERERGnpmJHREREnJqKHREREXFqKnZERETEqZla7KxZs4ahQ4fSqFEjLBYLixYtOuv6CxYsYMCAAYSEhODr60uPHj1YsWJFzYQVERGROsnUYiczM5OOHTvy1ltvlWv9NWvWMGDAAJYuXcrmzZvp168fQ4cOZevWrdWcVEREROoqi2EYhtkhoLDf/MKFC7nmmmsqtF3btm0ZMWIEjz/+eKnLc3Nzyc3NLXp9ZlCi1NRUjbMjIiJSR6SlpeHn53dOP7/rdJsdh8NBeno6gYGBZa4zdepU/Pz8iiY9KkJERKR+qdPFziuvvEJmZiY33HBDmetMmTKF1NTUounYsWM1mFBERETMVmcfFzF37lyefPJJFi9eTGhoaJnr2Ww2bDZbDSYTERGR2qROFjvz5s1j3LhxzJ8/n8svv9zsOCIiIlKL1bnbWHPnzmXs2LHMmTOHq666yuw4IiIiUsuZemUnIyODAwcOFL0+fPgw0dHRBAYG0rRpU6ZMmcKJEyf45JNPgMJCZ/To0bz++ut0796duLg4ADw9PfHz8zPlHERERKR2M/XKzqZNm+jcuTOdO3cGYNKkSXTu3LmoG3lsbCwxMTFF67/77rsUFBRw991307Bhw6JpwoQJpuQXERGR2q/WjLNTUyrTT19ERETMUW/H2RERERH5Jyp2RERExKmp2BERERGnpmJHREREnJqKHREREXFqKnZERETEqanYEREREaemYkdEREScmoodERERcWoqdkRERMSpqdgRERERp6ZiR0RERJyaih0RERFxaip2RERExKmp2BERERGnpmJHREREnJqKHREREXFqKnZERETEqanYEREREaemYkdEREScmoodERERcWoqdkRERMSpqdgRERERp6ZiR0RERJyaih0RERFxaip2RERExKmp2BERERGnpmJHREREnJqKHREREXFqKnZERETEqanYEREREaemYkdEREScmoodERERcWoqdkRERMSpqdgRERERp6ZiR0RERJyaih0RERFxaip2RERExKmp2BERERGnpmJHREREnJqKHREREXFqKnZERETEqanYEREREaemYkdEREScmoodERERcWoqdkRERMSpqdgRERERp6ZiR0RERJyaqcXOmjVrGDp0KI0aNcJisbBo0aJ/3Gb16tV07doVDw8PzjvvPN55553qDyoiIiJ1lqnFTmZmJh07duStt94q1/qHDx9m8ODB9O7dm61bt/Loo49y33338dVXX1VzUhEREamrXM08+KBBgxg0aFC513/nnXdo2rQp06ZNA6B169Zs2rSJl19+mWuvvbaaUoqIiEhdVqfa7Pzyyy8MHDiw2LwrrriCTZs2kZ+fX+o2ubm5pKWlFZtERESk/qhTxU5cXBxhYWHF5oWFhVFQUEBiYmKp20ydOhU/P7+iKSIioiaiioiISC1Rp4odAIvFUuy1YRilzj9jypQppKamFk3Hjh2r9owiIiJSe5jaZqeiwsPDiYuLKzYvPj4eV1dXgoKCSt3GZrNhs9lqIp6IiIjUQnXqyk6PHj1YuXJlsXnfffcd3bp1w83NzaRUIiIiUpuZWuxkZGQQHR1NdHQ0UNi1PDo6mpiYGKDwFtTo0aOL1h8/fjxHjx5l0qRJ7N69m48++ogPP/yQBx980Iz4IiIiUgeYehtr06ZN9OvXr+j1pEmTABgzZgyzZs0iNja2qPABiIqKYunSpdx///28/fbbNGrUiDfeeEPdzkVERKRMFuNMC996Ii0tDT8/P1JTU/H19TU7joiIiJRDZX5+16k2OyIiIiIVpWJHREREnJqKHREREXFqKnZERETEqanYEREREaemYkdEREScmoodERERcWoqdkRERMSpqdgRERERp6ZiR0RERJyaih0RERFxaip2RERExKmp2BERERGnpmJHREREnJqKHREREXFqKnZERETEqanYEREREaemYkdEREScmoodERERcWoqdkRERMSpqdgRERERp6ZiR0RERJyaih0RERFxaip2RERExKmp2BERERGnpmJHREREnJqKHREREXFqKnZERETEqanYEREREaemYkdEREScmoodERERcWoqdkRERMSpqdgRERERp6ZiR0RERJyaih0RERFxaip2RERExKmp2BERERGnpmJHREREnJqKHREREXFqKnZERETEqanYEREREaemYkdEREScmoodERERcWoVLnaefPJJjh49Wh1ZRERERKpchYudb775hubNm3PZZZcxZ84ccnJyqiOXiIjUQjExsGVL6VNMjNnpREpnMQzDqOhG27dvZ+bMmcyZM4e8vDxuvPFGbr31Vi688MLqyFil0tLS8PPzIzU1FV9fX7PjiIjUGTEx0LKVQU62pdTlHp4Ge/dYaNq0hoNJvVCZn9/nVOycUVBQwDfffMPMmTNZvnw5LVu25LbbbmPs2LH4+fmd626rlYodEZFzs2ULdO0KQUO24haUUWxZfpI3SUs6s3kzdOliUkBxapX5+V2pBsoOh4O8vDxyc3MxDIPAwEBmzJhBREQE8+bNq8yuRUSklnILysAWnlZs+nvxI1KbnFOxs3nzZu655x4aNmzI/fffT+fOndm9ezerV69mz549PPHEE9x3331VnVVERESkwipc7HTo0IHu3btz+PBhPvzwQ44dO8bzzz/P+eefX7TO6NGjSUhIKNf+pk+fTlRUFB4eHnTt2pW1a9eedf3Zs2fTsWNHvLy8aNiwIbfccgtJSUkVPQ0RERGpJypc7Fx//fUcOXKEb7/9lmuuuQar1VpinZCQEBwOxz/ua968eUycOJHHHnuMrVu30rt3bwYNGkRMGU36f/75Z0aPHs24cePYuXMn8+fP57fffuO2226r6GmIiIhIPVHhYscwDAICAkrMz87O5umnn67Qvl599VXGjRvHbbfdRuvWrZk2bRoRERHMmDGj1PU3bNhAZGQk9913H1FRUVxyySXccccdbNq0qaKnISIiIvVEhYudp556ioyMkg3RsrKyeOqpp8q9n7y8PDZv3szAgQOLzR84cCDr168vdZuePXty/Phxli5dimEYnDp1ii+//JKrrrqqzOPk5uaSlpZWbBIREZH645yu7FgsJcdY2LZtG4GBgeXeT2JiIna7nbCwsGLzw8LCiIuLK3Wbnj17Mnv2bEaMGIG7uzvh4eH4+/vz5ptvlnmcqVOn4ufnVzRFRESUO6OIiIjUfeUudgICAggMDMRisXDBBRcQGBhYNPn5+TFgwABuuOGGCgf4e+FUVjEFsGvXLu677z4ef/xxNm/ezPLlyzl8+DDjx48vc/9TpkwhNTW1aDp27FiFM4qIiEjd5VreFadNm4ZhGNx666089dRTxQYNdHd3JzIykh49epT7wMHBwVit1hJXceLj40tc7Tlj6tSp9OrVi8mTJwOFPcMaNGhA7969eeaZZ2jYsGGJbWw2Gzabrdy5RERExLmUu9gZM2YMAFFRUfTs2RM3N7dKHdjd3Z2uXbuycuVKhg8fXjR/5cqVDBs2rNRtsrKycHUtHvlMb7BKDAQtIiIiTqxcxU5aWlrR0MydO3cmOzub7OzsUtetyBDOkyZNYtSoUXTr1o0ePXrw3nvvERMTU3RbasqUKZw4cYJPPvkEgKFDh3L77bczY8YMrrjiCmJjY5k4cSIXXXQRjRo1KvdxRUREpP4oV7ETEBBAbGwsoaGh+Pv7l9qm5kxbG7vdXu6DjxgxgqSkJJ5++mliY2Np164dS5cupVmzZgDExsYWG3Nn7NixpKen89Zbb/HAAw/g7+9P//79eeGFF8p9TBEREalfyvUg0NWrV9OrVy9cXV1ZvXr1Wdft27dvlYWrDnoQqIjIuTnzINDwMWuxhRcfxiM3zpe4j3vrQaBSbSrz87tcV3b+WsDU9mJGRERE5K8qPM7O8uXL+fnnn4tev/3223Tq1Imbb76Z06dPV2k4ERERkcqqcLEzefLkolGId+zYwaRJkxg8eDCHDh1i0qRJVR5QREREpDLK3fX8jMOHD9OmTRsAvvrqK4YOHcpzzz3Hli1bGDx4cJUHFBEREamMCl/ZcXd3JysrC4Dvv/++6NlWgYGBeu6UiIiI1DoVvrJzySWXMGnSJHr16sXGjRuZN28eAPv27aNJkyZVHlBERESkMip8Zeett97C1dWVL7/8khkzZtC4cWMAli1bxpVXXlnlAUVEREQqo8JXdpo2bcqSJUtKzH/ttdeqJJCIiIhIVapwsQPgcDg4cOAA8fHxOByOYsv69OlTJcFEREREqkKFi50NGzZw8803c/To0RIP36zo4yJEREREqluFi53x48fTrVs3vv32Wxo2bFjqc7JEREREaosKFzv79+/nyy+/5Pzzz6+OPCIiIiJVqsK9sS6++GIOHDhQHVlEREREqlyFr+zce++9PPDAA8TFxdG+fXvc3NyKLe/QoUOVhRMRERGprAoXO9deey0At956a9E8i8WCYRhqoCwiIiK1zjk9G0tERESkrqhwsdOsWbPqyCEiIiJSLSrcQBng008/pVevXjRq1IijR48CMG3aNBYvXlyl4UREREQqq8LFzowZM5g0aRKDBw8mJSWlqI2Ov78/06ZNq+p8IiIiIpVS4WLnzTff5P333+exxx7DarUWze/WrRs7duyo0nAiIiIilVXhYufw4cN07ty5xHybzUZmZmaVhBIRERGpKhUudqKiooiOji4xf9myZbRp06YqMomIiIhUmQr3xpo8eTJ33303OTk5GIbBxo0bmTt3LlOnTuWDDz6ojowiIiIi56zCxc4tt9xCQUEBDz30EFlZWdx88800btyY119/nRtvvLE6MoqIiIicswoXOwC33347t99+O4mJiTgcDkJDQ6s6l4iIiEiVOKdiJzExkSNHjmCxWIiMjKziSCIiIiJVp0INlHfu3EmfPn0ICwvj4osv5qKLLiI0NJT+/fuzd+/e6sooIiIics7KfWUnLi6Ovn37EhISwquvvkqrVq0wDINdu3bx/vvv07t3b37//Xfd0hIREZFapdzFzmuvvUazZs1Yt24dHh4eRfOvvPJK7rzzTi655BJee+01pk6dWi1BRURERM5FuW9jrVy5kocffrhYoXOGp6cnkydPZsWKFVUaTkRE6pbdu2HLluJTTIzZqaS+K/eVnUOHDtGlS5cyl3fr1o1Dhw5VSSgREalb7Bk2sBiMHGkpsczD02DvHgtNm5oQTIQKFDvp6en4+vqWudzHx4eMjIwqCSUiInWLI9cVDAtBQ7biFvTnz4L8JG+SlnQmMREVO2KaCnU9T09PL/U2FkBaWhqGYVRJKBERqZvcgjKwhaeZHUOkmHIXO4ZhcMEFF5x1ucVS8vKliIiIiJnKXeysWrWqOnOIiIiIVItyFzt9+/atzhwiIiIi1aJCIyiLiIiI1DUqdkRERMSpqdgRERERp6ZiR0RERJxahYudWbNmkZWVVR1ZRERERKpchYudKVOmEB4ezrhx41i/fn11ZBIRERGpMhUudo4fP85nn33G6dOn6devH61ateKFF14gLi6uOvKJiIiIVEqFix2r1crVV1/NggULOHbsGP/5z3+YPXs2TZs25eqrr2bx4sU4HI7qyCoiIiJSYZVqoBwaGkqvXr3o0aMHLi4u7Nixg7Fjx9K8eXN++umnKoooIiIicu7Oqdg5deoUL7/8Mm3btuXSSy8lLS2NJUuWcPjwYU6ePMm//vUvxowZU9VZRURERCqsQk89Bxg6dCgrVqzgggsu4Pbbb2f06NEEBgYWLff09OSBBx7gtddeq9KgIiIiIueiwsVOaGgoq1evpkePHmWu07BhQw4fPlypYCIiIiJVocK3sfr27UuXLl1KzM/Ly+OTTz4BwGKx0KxZs8qnExEREamkChc7t9xyC6mpqSXmp6enc8stt1Q4wPTp04mKisLDw4OuXbuydu3as66fm5vLY489RrNmzbDZbDRv3pyPPvqowscVERGR+qHCt7EMw8BisZSYf/z4cfz8/Cq0r3nz5jFx4kSmT59Or169ePfddxk0aBC7du2iadOmpW5zww03cOrUKT788EPOP/984uPjKSgoqOhpiIiISD1R7mKnc+fOWCwWLBYLl112Ga6uf25qt9s5fPgwV155ZYUO/uqrrzJu3Dhuu+02AKZNm8aKFSuYMWMGU6dOLbH+8uXLWb16NYcOHSpqFB0ZGVmhY4qIiEj9Uu5i55prrgEgOjqaK664Am9v76Jl7u7uREZGcu2115b7wHl5eWzevJlHHnmk2PyBAweW+RiKr7/+mm7duvHiiy/y6aef0qBBA66++mr+97//4enpWeo2ubm55ObmFr1OS0srd0YRERGp+8pd7DzxxBNA4ZWUESNG4OHhUakDJyYmYrfbCQsLKzY/LCyszEdPHDp0iJ9//hkPDw8WLlxIYmIid911F8nJyWW225k6dSpPPfVUpbKKiIhI3VXhBspjxoypdKHzV39v/1NWmyAAh8OBxWJh9uzZXHTRRQwePJhXX32VWbNmkZ2dXeo2U6ZMITU1tWg6duxYlWUXERGR2q9cV3YCAwPZt28fwcHBBAQElFmMACQnJ5frwMHBwVit1hJXceLj40tc7TmjYcOGNG7cuFhD6NatW2MYBsePH6dFixYltrHZbNhstnJlEhEREedTrmLntddew8fHp+jfZyt2ysvd3Z2uXbuycuVKhg8fXjR/5cqVDBs2rNRtevXqxfz588nIyChqM7Rv3z5cXFxo0qRJpTOJiIiI8ylXsfPX51yNHTu2yg4+adIkRo0aRbdu3ejRowfvvfceMTExjB8/Hii8BXXixImiwQpvvvlm/ve//3HLLbfw1FNPkZiYyOTJk7n11lvLbKAsIiIi9Vu5ip2K9GDy9fUt97ojRowgKSmJp59+mtjYWNq1a8fSpUuLRl+OjY0lJiamaH1vb29WrlzJvffeS7du3QgKCuKGG27gmWeeKfcxRUREpH4pV7Hj7+//j7euzjQsttvtFQpw1113cdddd5W6bNasWSXmtWrVipUrV1boGCIiUrqYGEhMLDk/OBjKGNtVpM4pV7GzatWq6s4hIiI1LCYGWrYyyMku+cush6fB3j0WFTziFMpV7PTt27e6c4iISA1LTIScbAtBQ7biFpRRND8/yZukJZ1JTNTVHXEO5Sp2tm/fTrt27XBxcWH79u1nXbdDhw5VEkxERGqGW1AGtnCNLi/Oq1zFTqdOnYiLiyM0NJROnTphsVgwDKPEeufSZkdERESkOpWr2Dl8+DAhISFF/xYRkfrLwMAv6VsSGiyjQW4IDfIvwN3ajRSvxmZHEylVuYqdM13B//5vERGpZ1zyCeQ1tjdZ9MeMI8BvEDEbOt9PQWo4gUktcXEbRrrvBeblFPmLcj8I9K/27t3Lm2++ye7du7FYLLRq1Yp7772Xli1bVnU+ERGpJTJyUom86Wp2R63BYli4dNcoLBZfMtz3Euu3j2MhR0n0iyPRLw6v3E1Epr1GLuUfe6081FVezkWFi50vv/ySm266qWjUY4ANGzbQrl075syZw/XXX1/lIUVExFxHYo9w64IrONJiH7Z8G733PcT+qIvBAnAlWb+HE/pBY86/8nPiG77PgfBdpFifwWp/t8oyqKu8nKsKFzsPPfQQU6ZM4emnny42/4knnuDhhx9WsSMi4mQ27NjA0DlDSfRJJCAjkHZ7n2N/m789j9BiIT43HBf/rgRbgwlMn8jJwBhapz/HCcsAwFrpHOoqL+fKpaIbxMXFMXr06BLzR44cWeIJ5iIiUrct+H4B/eb1I9EjkcjEKILe/4n9gW3Ouk26dwAtkh7DrcCN3c3W0vaSR6s005mu8memvxY+IqWpcLFz6aWXsnbt2hLzf/75Z3r37l0loURExHyn004xetVoctxyuDj2Ymb2W8+B1Pbl2jYu7AK6Hyp8FNCu/i+x5ucvqjOqyFmV6zbW119/XfTvq6++mocffpjNmzfTvXt3oLDNzvz583nqqaeqJ6WIiNS4d1Y8QqZHJhckXsCPT//InuNeFdo+pskAuu09xKaW3/Df2HEM2NGWtu3bVlNakbKVq9i55pprSsybPn0606dPLzbv7rvvZvz48VUSTEREzOMduJuFbp8C8Ey7Z/AK9YLjFdyJBeKs93HesSMcitjBsFnD2Pz4Zvz8/Ko+sMhZlOs2lsPhKNek0ZNFRJxD6GWTsFvt9IzryXW3XXfO+ymw2kj7YhGBmUEc9D3ITc/cVIUpRcqnwm12RETEuXk5dnCo7XJcHC68MOAFLNaSXb0rIjH9PJ6P+BSr3coy72V8v/L7KkoqUj7nNKhgZmYmq1evJiYmhry8vGLL7rvvvioJJiIiNc/AoMBnBgCDjl9Nryd7Vcl+u/YaxLDZw1jgu4Cpy6dy+YDLq2S/IuVR4WJn69atDB48mKysLDIzMwkMDCQxMREvLy9CQ0NV7IiI1GEN0n9ld+jv2PJt3NnneSyWyl3V+atHr32Uhd8t5EffH9ny2xa6XNilyvYtcjYVvo11//33M3ToUJKTk/H09GTDhg0cPXqUrl278vLLL1dHRhERqQEGBSTZZgFw4fqxNGxftY8A6tqzK5emXArAs/OfrdJ9i5xNhYud6OhoHnjgAaxWK1arldzcXCIiInjxxRd59NGqHThKRERqjk/KSuL9juOf6c++dU//8wbnYMqAKQB87fE1B/cfrJZjiPxdhYsdNze3osuaYWFhxMTEAODn51f0bxERqVsMI4sYv9kAdNszlvi80Go5zoCrBtAluQsF1gKe//j5ajmGyN9VuNjp3LkzmzZtAqBfv348/vjjzJ49m4kTJ9K+fflG1hQRkdrFO2Uh6V4pNE5qwhGvodV6rAe7PQjAHMccEk+V8ghzkSpW4WLnueeeo2HDhgD873//IygoiDvvvJP4+Hjee++9Kg8oIiLVy0IyB0IWAND+xDgyPNyq/Bi7d8OWLYVTi1YjiDrdnCxbFi998FKVH0vk7yrcG6tbt25F/w4JCWHp0qVVGkhERGpWYMFyYt1yaR7XkgOR3SCp6vZtz7CBxWDkyL/26nKhfYcJ8K/7+CDtA57IfAKvBhV7FIVIRZzTODsA8fHx7N27F4vFQsuWLQkJCanKXCIiUiMMEkK+BSAqcRD7m1ddV3MAR64rGBaChmwt9nTyU4kXEZwSRqL/Kd784E0envBwlR5X5K8qfBsrLS2NUaNG0bhxY/r27UufPn1o1KgRI0eOJDU1tToyiohINQlo+iPx/sfwyPMgKbhqBhAsjVtQBrbwtKLJJTiPJr8UPkvxrWNvUZBfUG3HFqlwsXPbbbfx66+/smTJElJSUkhNTWXJkiVs2rSJ22+/vToyiohINQns/A4AnY9cSrKfZ40ee8+W+/HN9uW4z3E+/uzjGj221C8VLna+/fZbPvroI6644gp8fX3x8fHhiiuu4P333+fbb7+tjowiIlIN0nNTON52CQAN7ANr/Pg5+X5cmzcGgFd2vILD4ajxDFI/VLjYCQoKws/Pr8R8Pz8/AgICqiSUiIhUv2W/fESuew4RCc043LiFKRluHvAItnwbu/12s2zJMlMyiPOrcLHzf//3f0yaNInY2NiieXFxcUyePJn//ve/VRpORESqz9exMwG44NhVFLhVbcPk8goMa8TQ3MJxfWb+PNOUDOL8ytUbq3PnzsUeBrd//36aNWtG06ZNAYiJicFms5GQkMAdd9xRPUlFRKTKbNq3id3ev+NqdyXV5QpTs4zpOYYvt3/JctflZGVmqRu6VLlyFTvXXHNNNccQEZGaNH3hdAA67unDcV9/bKSblmXQ1YMIWx/GKe9TfD7/c24de6tpWcQ5lavYeeKJJ6o7h4iI1JCcghy+SvsK3MFjyy1wiTm3sM6wWq0Mcx/Ge7zHnO1zuBUVO1K1Ktxm54zNmzfz2WefMXv2bLZu3VqVmUREpBrNWTaHNPc0wlLD2H7oOrPjADB24FgA1jRYQ8KpBHPDiNOpcLETHx9P//79ufDCC7nvvvu455576Nq1K5dddhkJCfqAiojUdu9veB+Aq1KvJd3wMDlNoe59utM8pTn5rvl8PE9j7kjVqnCxc++995KWlsbOnTtJTk7m9OnT/P7776SlpXHfffdVR0YREaki+2L3scF9AxbDwrCOtadDicVi4dqgawGYd3ieyWnE2VS42Fm+fDkzZsygdevWRfPatGnD22+/zbJlGiNBRKQ2m/5lYcPki05cROOe7U1OU9ytwwvb6mz228yBvQdMTiPOpMIPAnU4HLi5uZWY7+bmptEvRURqQEwMJCaWnB8cDH+MCFKqAkcBc2LngA1GNR6FxcXchskAu3f/9VVLOiR2ZnvwVj766iOee/Q5s2KJk6lwsdO/f38mTJjA3LlzadSoEQAnTpzg/vvv57LLLqvygCIi8qeYGGjZyiAnu2Sh4uFpsHePpcyC5+v1X5NgS8Av04+Rd4zkoInPbrZn2MBiMHJk8fPo0HUEDN3K/IQveQ4VO1I1KlzsvPXWWwwbNozIyEgiIiKwWCzExMTQvn17Pvvss+rIKCIif0hMhJxsC0FDtuIWlFE0Pz/Jm6QlnUlMLPvqzqc/fgrAVSlX4dfcD7bUROLSOXJdwSh5HskJF+Jqd+WA/342/rKRi3pcZF5IcRoVLnYiIiLYsmULK1euZM+ePRiGQZs2bbj88surI5+IiJTCLSgDW3haudfPLchlZd5KcIMRnUdUY7KK+ft55OJLi/292d1qFTOXzVSxI1WiQsVOQUEBHh4eREdHM2DAAAYMGFBduUREpAp9s+4bMt0yCU4L5oq7zX08xD9x2X4ztFrFwuyFvGV/C6vVanYkqeMq1BvL1dWVZs2aYbfbqyuPiIhUg8/Xfg7AgIwB2IJtJqc5u/37bsQr14tT3qdYsXSF2XHECZzTU8+nTJlCcnJydeQREZEqlmfPY0VOYdFwXdvaMWLy2eQVeHNp+kAAPvn5E5PTiDOocJudN954gwMHDtCoUSOaNWtGgwYNii3fssXEFm8iIlLC0g1LyXDLICg9iMF3DDY7TrkMaj6KpamLWGZZRk52Dh6etWOkZ6mbKlzsDBs2DIvF/LEZRESkpOLj1hT6eOVcsMBlqZfhEV43iga/wKsJOhFEkncSb771JZddNrLUcxMpjwoXO08++WQ1xBARkcooa9waXPLxmrwcPOG6VrX/FtaZ8xg9xpWOV1xNUo+ZfPzrXB56aKTZ0aQOK3exk5WVxeTJk1m0aBH5+flcfvnlvPHGGwQHB1dnPhERKYeyxq2xZG4j1jONgIwABt9S+29h/fU88OwGzORwi9U0GvkDmUcbk7q2ldkRpQ4qdwPlJ554glmzZnHVVVdx4403snLlSu68887qzCYiIhV0ZtyaM1MDv8JnFvaJ70+Dpg3+Yevawy0og5SoCAIyAsnyyKSx2wZc/bLMjiV1VLmv7CxYsIAPP/yQG2+8EYCRI0fSq1cv7Ha7xkAQEamFDAo4GfIzAJeFXGtymnNgceG8hB5s9v4Wu+MXYJDZiaSOKveVnWPHjtG7d++i1xdddBGurq6cPHmyUgGmT59OVFQUHh4edO3albVr15Zru3Xr1uHq6kqnTp0qdXwREWflkr+DLI80/DL9uLDPELPjnBOrS3cADoX8AobGeJNzU+5ix2634+7uXmyeq6srBQUF53zwefPmMXHiRB577DG2bt1K7969GTRoEDExMWfdLjU1ldGjR+vBoyIiZ+GWvR6ADrv7497Ex+Q05yYxsB1eOQ1I8U4m3Nhudhypo8p9G8swDMaOHYvN9ufImzk5OYwfP77YWDsLFiwo98FfffVVxo0bx2233QbAtGnTWLFiBTNmzGDq1KllbnfHHXdw8803Y7VaWbRo0VmPkZubS25ubtHrtLTyP0tGRKSuMrAT6/sLAG67/mVymnNnd3WjxamL2NZsFR4NfgTGmR1J6qByX9kZM2YMoaGh+Pn5FU0jR46kUaNGxeaVV15eHps3b2bgwIHF5g8cOJD169eXud3MmTM5ePAgTzzxRLmOM3Xq1GL5IiIiyp1RRKTOKvidDM8UfLN82XdkqNlpKsXT3gOA441WAw5zw0idVO4rOzNnzqzSAycmJmK32wkLCys2PywsjLi4uFK32b9/P4888ghr167F1bV80adMmcKkSZOKXqelpangERGnZ8v6BXyg06FLWOMo/y+itVFSYCfcCtw4FXCChiGbMcwOJHVOhZ+NVdX+PhqzYRiljtBst9u5+eabeeqpp7jgggvKvX+bzYavr2+xSUTEmRnYifNdB4Bval+T01Rens2LFnFdAAhpPc/kNFIXVXgE5aoSHByM1WotcRUnPj6+xNUegPT0dDZt2sTWrVu55557AHA4HBiGgaurK9999x39+/evkewiIrWZUbCLdJ/T+GT7EOvZzew4VcI3twfwKymtvoXcYWbHkTrGtCs77u7udO3alZUrVxabv3LlSnr27FlifV9fX3bs2EF0dHTRNH78eFq2bEl0dDQXX3xxTUUXEanVbH/0wup8uCcn/E37nbZKpfh3w8XhQkyjPfjklt7UQaQspv4vmDRpEqNGjaJbt2706NGD9957j5iYGMaPHw8Utrc5ceIEn3zyCS4uLrRr167Y9qGhoXh4eJSYLyJSXxk4SPAu7IUVmN0LPJ3jwc3ZXv6cF9uOA423E2BfyymuMDuS1CGmFjsjRowgKSmJp59+mtjYWNq1a8fSpUtp1qwZALGxsf845o6IiPzJcN1DqlcinrmeJAV2MDtOlfJPuBQab+e0/1pQsSMVYHoD5bvuuosjR46Qm5vL5s2b6dOnT9GyWbNm8dNPP5W57ZNPPkl0dHT1hxQRqSO8jcLHQ3Q+chHHwpzjFtYZp3ML22UebLgdW47GTJPyM73YERGRqpPmW1jshKb3wHCOO1hFUqwRRMS1wOHiIPD0JrPjSB2iYkdExFkE7SXR/whWu5XsBl3NTlMtAncPBiDd7ReTk0hdomJHRMRJhLQqHIOmw9FOHGjiaXKa6pG0ZwQA+8M345qXY3IaqStU7IiIOAlLq0UARCb1osC5musUOX7qYkJTGpLnlkfQ6Wiz40gdoWJHRMQJONwSSGgSDYDd/UJzw1QrFyJO9QYg16JbWVI+KnZERJyAzXM1hsWg1fFWHIgIMDtOtbIXFBY7B8J+xcVeYHIaqQuc9EKniEj9YvVZBUCLE5ewvZThdWJjYcuW4vN2766BYNUgzqMtfpn+pDZIIShmF8e5xOxIUsup2BERqeMcZBEXWtgV25rdu9R1/nWtQV6uk/RFd3HlvPiL2Rq1Agp+A4uKHTk7FTsiInWcw74Ju7WAiMQIDgZGAukl1snLtRA0ZCtuQRlF87IPhZC6tlXNBa1C7lwErOBo0C+4JE0wO47UcmqzIyJSx1lzfwWg7Z5+JPiUffXGLSgDW3ha0eTql1VTEatcYmBH3PPdSfCLIyTnkNlxpJZTsSMiUocZ5HPK9zcArHuGmZym5hS4e9DiVBcAPC0/m5xGajsVOyIidVi+sZ1ctyyC0oPYd6K/2XFqlE9udwDiA1XsyNmp2BERqcPccgpvYXXd34sDhp/JaWpWin9XLIaFo2H7CPA9aHYcqcVU7IiI1FEGDpK9NgDgn9AXAyfpbVVO2V4BnHeqDQBNWs4zOY3UZuqNJSJSR+VZ9pHhkUyDnAYkOC6u8v3/fRye2jguT0jmxRxkJzktlwCPmh1HaikVOyIidZRbzq/gAd0OXsSuQI8q2689wwYWg5Eja/+VouwGFwEfcTjqN9JTkoFAsyNJLaRiR0SkDjIwyHArfDZUk9O9+N2j6goTR64rGHVjXJ4UvyY0TI4gNvAYP//yFX373252JKmF1GZHRKQOKnA7wukGx3ErcCPHq1O1HKOujMvTOL4XAKvjFpucRGorFTsiInWQq+tPAHQ92JXdkVV3C6suKigofFzEL96ryc3JNTmN1EYqdkRE6qB8zzUAnB/fm0xPk8OYLM6zDb6Z/mR4ZLDs22Vmx5FaSMWOiEhdE7ifZL+DWO1WDPeLzE5jPhdXmu0tHFBxwaYFJoeR2kgNlEVETBQTA4mJpS8LDoamTUvO92wzj2yg85HO/B7lBRjVGbFOyN97DXRZwHf537FpkwMXl8Lf5ct6D6V+UbEjImKSmBho2cogJ7v0nlQengZ791hK/LB2b/0l2UDrE5ew5kIVOvYMG4cODcOWb+OUzymGD93A8bieQNnvodQvKnZEREySmAg52SW7eAPkJ3mTtKQziYnFr0zEZh0ltfE2XBwuWF2613Di2smR60pevi9tjl/Irqifadj3Awo87GW+h1L/qNgRETHZmS7e5fHDkfkAtI9pz+5IH3QL60/emT2Bn4kP/hmb97Vmx5FaRA2URUTqkB8OFhY7HQ73IS5Ihc5fJbn1LHwwaMh+vDMSzI4jtYiKHRGROuJk+kl2GL8B4JbVx+Q0tU+meyDN49oB4JO2weQ0Upuo2BERqSO+2v4VhsWgzbE27AkNNTtOrRScVTiacmKDdSYnkdpExY6ISB3xxYYvAOi8uz+HgkwOU0ul+xY22j4YthPvvDL69Eu9o2JHRKQW270btmyBH35JYH36egCsu4aDpfY/kdwMGd7BnHeqFYbFILBgjdlxpJZQbywRkVrInmEDi8HIkYVFjaXLQoyrHbQ42YLtKZ2B380NWIuFZlzCobA9pPitNjuK1BK6siMiUgs5cl3BKByDJ3zMWgJ6fwjAxXv7sh0/k9PVbpk+hbeyDjTaho/XCZPTSG2gYkdEpBZzC8rALfwkKX5bAPBJ6o9D37rPKs0nnKYJ5+NwcRDZaq7ZcaQW0P8YEZFaLstlIw6XAiLjIznoeZ7ZceqEhmmXAJDbZqHJSaQ2ULEjIlLbFRQ2TO65tw/bg9XUsjyyG/QA4GDUr6QmxZucRsymYkdEpBZzWLJI8dgMQFj6JeRb1QurPFL9GtMkMQq71c6P6z83O46YTMWOiEgtluv1M3ZrPk2SmnAirInZceqUhgmFo0yvSlhgchIxm4odEZFazOHxHQD9fu/P9uYOk9PULVnGpQBsDFhPckKyuWHEVCp2RERqK+9YMnw2AdAsqT/ZNpPz1DGJHlGEJzYl3zWfLxZ8YXYcMZGKHRGR2qr9HAyLg7bH2nIwItzsNHWOxeJC2K6rAFiwV7ey6jMVOyIitZR7h08A6Lfjcra0KDA5Td2UvPsmANZ4rSHtdJrJacQsKnZERGqhAo8D5DXcjqvdlcDsPuToFtY5ORbbi4Zpjch1y+XLhV+aHUdMomJHRKQWygv6FoDu+7qz43wvk9PUZS5c6hgMwJc7VezUVyp2RERqGQM79oBlAPTdOZAd59lNTlS3XdZqBAA/efxEZkamyWnEDBqKU6QOiImBxMSS84ODoWnTms8j1SvHZQd5tgR8sn0grzv5rnlmR6rTOnTpR+gXocR7x7NgwQJGjR5ldiSpYbqyI1LLxcRAy1YGXbtSYmrZyiAmxuyEUtWyXH4EoN/v/djYTI11KstqtTLYtfBW1uzo2SanETOo2BGp5RITISfbQtCQrYSPWVs0BQ3ZSk62pdQrPlJ3Ocgh26XwWVgXbx/ETvU4rxLjrhgHwI8NfiQ+Vs/Kqm9U7IjUEW5BGdjC04omt6AMsyNJNciy/oLdmkOj5EbEHuuPw0XPwqoKPfv0pHlqc/Jd85k1b5bZcaSGmV7sTJ8+naioKDw8POjatStr164tc90FCxYwYMAAQkJC8PX1pUePHqxYsaIG04qIVK9sl1UADNg+gB8IMzmN83BxcWFESGFD5TlH5picRmqaqcXOvHnzmDhxIo899hhbt26ld+/eDBo0iJgyGiGsWbOGAQMGsHTpUjZv3ky/fv0YOnQoW7dureHkIiJVr4BksqzRAHTeN4Dd+JobyMncfsPtuDhc2BawjR1bd5gdR2qQqcXOq6++yrhx47jtttto3bo106ZNIyIighkzZpS6/rRp03jooYe48MILadGiBc899xwtWrTgm2++qeHkIiJVL8v1J7A4aBvTlgNeUYBuYVWlyOaR9EjrAcD7i983OY3UJNOKnby8PDZv3szAgQOLzR84cCDr168v1z4cDgfp6ekEBgaWuU5ubi5paWnFJhGR2ijLUngLa+D2gfzcyM3kNM5pZKuRAHyZ8SV2u8Yvqi9MK3YSExOx2+2EhRW/Jx0WFkZcXFy59vHKK6+QmZnJDTfcUOY6U6dOxc/Pr2iKiIioVG4RkeqQZzlCruth3ArcaBHXh2O+VrMjOaWRN42kQW4DYn1iWf7tcrPjSA0xvYGyxVL8Mq1hGCXmlWbu3Lk8+eSTzJs3j9DQ0DLXmzJlCqmpqUXTsWPHKp1ZRKSqZbiuBKD7/u78fp4eD1FdvH29uTL/SgA+WvuRyWmkpphW7AQHB2O1WktcxYmPjy9xtefv5s2bx7hx4/jiiy+4/PLLz7quzWbD19e32CQiUps4LFlkuhQWO4O3DObX1nrCeXW6pfctACx3W056arrJaaQmmFbsuLu707VrV1auXFls/sqVK+nZs2eZ282dO5exY8cyZ84crrrqquqOKSJS7bJ9luFwySIiMYKAzK4k+htmR3JqV151JY3SG5Fly+Kzzz8zO47UAFNvY02aNIkPPviAjz76iN27d3P//fcTExPD+PHjgcJbUKNHjy5af+7cuYwePZpXXnmF7t27ExcXR1xcHKmpqWadgohI5VgcZPkWPo372g3X8mtbh8mBnJ/VauVa72sB+GyPip36wNRiZ8SIEUybNo2nn36aTp06sWbNGpYuXUqzZs0AiI2NLTbmzrvvvktBQQF33303DRs2LJomTJhg1imIiFTOBUuwu53AO9ubvrsGsL6tbmHVhDuuuQOADb4bOLz/sMlppLqZ/tTzu+66i7vuuqvUZbNmzSr2+qeffqr+QFIv6CniJZX1nuTmgq2MZ1HW5/erynSfBsCQzUPYeoEbOTY94bwmtO3Ulo6zOrItYBvvz3+f5x59zuxIUo1ML3ZEatqZp4jnZJfs9efhabB3j6Xe/QA/23uCxQCj9B6S9fX9qir7UrdB1CpcHC4M3zicN6/VVZ2a9O/If7MtdRvzEufxjOMZXFxM76As1UTFjtQ7f32K+F8fppmf5E3Sks4kJtaRqxWGnbDA7axY8RszF0ezP30/uUYu+eSTb+RTcOaPpYAggjjP4zzODzyfVk1b0aZVG85vfT7u7u5A2e9J9qEQUte2KjEf6uD7VQvNPfw6AH139SXVO4hjoTkmJ6pfxt40lsfeeoxDfodYt3odvfv1NjuSVBMVO1JvnXmKeF3hVpBJw9i15Fl2kOJ1iNNNjpB7Xw6P5lHY+s7v7NuvZS1kAXsKJ9evXDkv/TwG+A6ga+N/gaVvifckP6lB4bHr2HtVF8RnxrPsxGwArttwHT92yTc5Uf0TEhZC/8z+rPBbwfvfva9ix4mp2BGpxVKSU1i6dB6tb/iSg5FrOOZWvD2He747Uenn0869NW2C2uDj4YPNzYab1Q03NzdsbjasLlaOJx5nf8J+DmYd5KjlKMcaHCPfNZ99/vvYxz6IfRu/BwIIP3UxtriuJAV0JN+mge2q0zub3iHfkUfr462JSGjDppaZZkeql2696FZW7F3BAssCXk96nYCgALMjSTVQsSNSyxTkF/DpZ58yZ8cc1nitIc8tD9oULgs/3ZiI5J5YXZqTmt2aPV/eyJzf3OnSpWLHsNvtHNhzgO9Wf8e3B77lZ4+fSfU+TbT3cmA5bgVutD3eHw/HKJKo4M7lH+UW5DL9t+lA4VWdn863kK/vxqa49vpriZwcyRG/I7zx4Rs88dATZkeSaqD/XiK1RGZGJm++9yZvnXiLE74nim5LNU5tQvC2odiDu5IWGUZ8o8LGwrlxvhgO93M6ltVqpWXblrRs25J7uZdff8ll5L+X49d9NifC1hPnf4LoyBUQuYLmoa/hn3ENiY4O4KLnNVWFz3//nFOZpwhOC6bPrj48MExPNzeL1WplfMR4Hkl7hHfj3+Wx/MdwddOPRmejpuciJks4lcBDzzxExP8imJI+hRO+J/DN9uU/+f9hbd+1LLr5KNt+nE6i5wXlem7cuXCz2ThweBgn3O/F3f0duh17hQ5HL8XF4cLByM1sbvdfsgruICx2Ma55WdWSob4wDINpv04DYPjG4WxxhBDvq2LHTHfdehd+2X7E+sTyyWefmB1HqoHKV5FyquqxeU4eO8mT7zzJbGM2WbYs8IKwjDDuCrmLifdNxDeg8DluW7ZUMngFWSwWEoJbAi2J/O1BfPOWcLDrHBL84kjwex+/zPm0jLuZY45/1WywOuKfPidrjq4hOi4aW76NqzZfxYs0BtT4uzrt3l1yXnBw4d+FXysfrsn7Nx97Tmfa1je4/LJb1cPQyajYESmHqhybJzcnl+ffeJ6XT79Mhkdhd+7mqc2Z2GIitz98OzaPMkbwM0GqtSGHfphBRPi/aO+ylMMBXxIbeJyNUdMJTVlEyzZP43Dcgi4SFyrP5+SVX14BYOC2gfj7hrIhO4jQmg5aT9gzbGAxGDmy5NfDZjPAArk5hcv8vSfjev977AjaxmV9f+SH1f1V8DgRFTsi5VAVY/M4HA7mzZ3HlC1TOOp7FDygRUoLnur2FCNuGlGrBzTLd/XgRPjleNgvpeeBH9gV/hnx/ieJv+E2Rn82jZcTXmDwoMFmxzTdP31OVuxZzTf7vsHFcOG6Ddfhfn1DHDN0C6u6OHJdwSj76wEUW9bsyGVsa74C964vk5ioYseZ1N7vriK10JnxZs5Mfx9oryy/rf+NSyZdws0Hbuao71ECsgJ4yf8ldr24i5v+fVOtLnT+ymF15UTjKwgteI+Ld43FI8+T3QG/c9XGq7j8wcvZv3+/2RFrhVI/JxY7r+y8H4Ahm4bQLKUZbtc0NDlp/XC2/7d/XebiOQSAPW1XcPLoPrPiSjWoG99hReqotNNp3ProrXRf0Z1fAn7BrcCN/+T/hwMPHuDBCQ/W2V4fuTZPjnreitcbu7gm4UZcHC784PMDHWd15PFXHye/QAPkldDpY/ambcXH4cMtq24heHgwLsG155alQHJAFBcc74zDxcHcNS+bHUeqkIodkWry1fyvaPVsK2baZuJwcXB56uVsvXYr7z7zLoEhgWbHqxLJGZH899a5bOi/gU5Jnch2z+Z/6f+j/SPtWf3zarPj1RoOSxb0fwyAkatG4p/lT6O7GpmcSkrjk3IDAIs95pKSnGJuGKkyKnZEqtipk6cY/uBwrtt1HbE+sYRlhPH5BZ+z8tWVtO3U1ux41eLCvhfy2yu/8aLni/hk+7DXZy/9vu/HqCdGkZyabHY802X6zwafOJrkNmP4+uH4XeKHf19/s2NJKU54dSc8sSmZHhm8+eGbZseRKlI3r6GL1DK7dxc2QP7uu494OfUhTvucxmJYGJkzktcfqd4h6EvrVguQmwu2Uu6SnGtX+X/i6ubK5IcmM2LvCMa/fjfLwpbwmeUzlj23nEeavUH/7jdV27H/qqyu31B95342BZZTZPrOA+CORbfjZncjf1QkW7dayvzaiYksVkI2jCduyKO8e+pdpuRPqbO3m+VP+gqKVMKZrq133XGCxkPGsrv1D+AFjRIiabD0HZ756QoCgqr32KV1qwXAYoBR+a7yFebZlFUzF9O+4UISr7qf2OBjTE64mebPzuPUj++zc1tItR37bF2/oQbOvRSnXWeBSx5ND3Wn1+6ebMGfB+7Q85dqs33b7sb3suc54XOC2XNmM2bMGLMjSSWp2BGpBEeuK61afkLs0InsbpCC1W6ly75/czT9TvYf7l6uLumVOXZp3WoBsg+FkLq2VaW6yp+rxETIyXHhZNvz8En+kF5xM/mlzTwOdliM73lr+WL52zz4nxur79ildP2Gmjn3v8tx2UmW61owXPi/FbdhwcKiQWmEh64F/vw6Se2Sm+/LDXn/5lPPGUzbOo1Ro0bVmR6TUjp99UTOkXtuJk18/489N44ltUEKEYlRtD/1OvGRN+ASUnO9kf7erdYWnoarX1apy8rbVb6qchkReRxv/m96H3yFJolNSfNOZnLsTVzz1DUkpCZU67H//p7U5LkDGDg47fY+AF32XkWLU82JbgwxHdJLfJ2k9rmp32TcCtyIDohm/rz5ZseRSlKxI3IOQhO2c9rlXrZdsAyLYaHbnptws73K6YBIs6PVSkeatMCW+AG9fr4VF4cLi1lMq+db8fn3n5sdrdpkWleR53IAq8OTKd+MBWB+J33LrSvCGkcxxlF4++qR3x4hNyfX5ERSGfqfJ1IBVnsOIbEf8lvTR0n0jSf0dCMiZ37Lcdud2F3dzI5Xq2XaPFj3/Qe877aEZknNSPZI5qZ1NzF86nASM8poUVxHOVxSSXH7GIABO/5NcGYg6wjiULBGS65LnrvvOfyy/Tjid4RX3n7F7DhSCSp2RMopouFajIDb2XTeQgC6Hh6Cdf/nHI4ZZHKyusRCp8GD2PbgNm49UXiVZ1HeIlpNbcWX6780O1zVcMknJfRx7JZkPPIbMeHr6wCYSZTJwaSiQsJCmBw8GYCXEl4i4VT13XqV6qViR+QfFOQX8P7chzh5Wz9OBh0lICOQi448TWL4ePJcGpgdr07ya+rHB+9+wKKARTRNbEqSexLXr7ye66ddT3J2HR+XZ+CD5HluxWJ4cPd3T+Jht/FLQ1cO4m12MjkHk++bTGRqJCmeKTz2xmNmx5FzpN5YImexa9subp55M9sCtgHQ9khvCnzHcyrMr1L7LWssmNLGxqmOsVj+vs/KHKOi+/pzuYXGfYYyu3FPpn81iXktP+PL1C/56bmfeHf4u/yry7/OPZRJvo6ZCd3fAKBVwoMM+a0FDgzmXWCDWJPDyTlxd3dnarep3LT/Jma5zGLitom06djG7FhSQSp2RErhcDiY9tY0/u/U/5EdkI1XrhfnLZ1KQseOeHhWrlfPWceCKWNsnKryj2PzVOO+yl4/CCszGdLsarYOvZ9jwce49ptrGbJ+CO+MfofGvo0rnbUmbDi+ged2jAfA+/Qt/GdFXwB+bWPnuI/VzGhSSTfceAOvT3qdDQEbuP/j+1nx6gqzI0kFqdgR+ZuE2GNc/ukYVvmvAnfodLoTT/Wey7CprQjvtLbS+y9rLJiyxsapyrFYyhqb51yOUdF9nW1coPwkb75eci2rO/fig2UPMbvNbJYkLaHlqy15fuDz3NXjLlwstfeu+8n0k/xr3r/Id+TB7uFckjiaTgfBYTFY1CtPV3XqOBcXF6ZdN42eK3vynd93LFuyjEFD1FavLqm93z1ETNC6zYfcsLY9q/xX4Wp35SHrQ/z20m80iar6gd/+PhZMWWPjVMdYLFV5jIru62xj4Hh3CuejmR+xMHkhrY+3JtOSyb0r76X7G93ZcWrHOWesTjkFOQyfN5zYjFia+7SjwcIP+M/6wmXfdSvgVKBhbkCpEhdfcjHXZRc2Nn/whwex2+0mJ5KKULEjAnjkpBNqPM3uG24jzTOVFiktWDtgLS/83wt6Lk4Nc/V25eo3r+an4T9x/8/345XrxW8pv9FlRhce/u5hUnNSzY5YxDAMxi8Zz8YTGwnwCOCVCxdxX94pArIhNtDBV73zzI4oVejlO1/GM8+TXf67ePf9d82OIxWgYkfqvbBTm4l3u4ft532Pi8OFMal3sf257XTv3d3saPVa6OBQXpj3Al/HfE3v3b0psBTw4i8v0vy15ry18S3y7OYWEln5Wdz69a18vO1jXCwufHH9F4T/5sdATuGwwAeDc8nX0EtOJSIqgns87wHgqYNPkXY6zeREUl4qdqTe8shPIzDuTTZGPsFp7yQaJkfQ9MOV3DfybTw8PcyOJ4BboBuXfXYZ86+Zz/NfP09EYgRJeUncu+xe2r7dlq92fYVh1Pxtot0Ju7no/YuYFT0LF4sLbw9+m75+fcl5bi8A37S1cLCxo8ZzSfV7/L7HCU8PJ947nlueu8XsOFJOuj4vVaKsrtTBwTX30MXycjgctG4zk9hGkznifRqAboeGE+u4kyMn+pfadfpcu2aXtl2sGquWqbT3KzgYmt4YxsS+Exl490A+2fAJH1/6MQc4wHXzr6NHkx68NOAlejXtVbljlPNzOnv7bO5YcgeZ+ZmEe4cz99q5XBp5Kbtu2oWRlM8RvPiqU45+k6zjyv6cePPeJe9xzdZrWOC9gGlvTWPiPRNrPJ9UjIodqbSzdaX28DTYu8dSawqeQ/sOcf+s29h9wyoAGiU3pVHmvSQ0bE3eAb8a6ZbtbjMAPTbgr872fv35GbLR6atONP6yMYPvH8ynF3zK/B7z+eX4L1wy8xIubnwxV4XcDdYbKnGMsjPmFOQwYdkE3tvyHgD9o/oz519zCPMOI/7LeOI/jwcrPG9vRb51G7aydyW1WHk+J0OvGcrE7RN51XiVR+Ieoee6nlzU6yIT0kp5qdiRSiurK3V+kjdJSzqTmGj+1R273c5Lr7/EM4nPkBmSiavdlc77biapyTUkBLsDZ+8aXdGu2WXt68x7IsX90/t15jNksVgIvT6US/tfSpOJTbj6zauZdeksVnRawa8nfuXXE7/CpEmk51+B1XIZrkZohY9RIpvh4OeYn5mwfALRcdFYsPB438f5b5//YnWxkhefx/479wPgPrYpez/0Jbz63iqpZuX9nLz42Iv88sAv/BLwCyO+GsHW1lvxD/Q3L7iclYodqTJnuhTXNutWr+OehfcQHRANNmiT1I6UeR9ybFAuNteSeUs7j/ykc3ssRG19T2qr8r5fbkFutP60NaHfhtJ4fGNu/fFWlnZZyje9lhDf4BSZzCbTmIun40I87Rfh4WiD8UcJUp5jGIbB9lPbmbNjDnN/n8uxtGMAhHiFMPtfsxnQfEDRevvu2kd+Yj4NOjTA5fZI+LBy74HUDv/0ObFarcyfNJ/Ob3bmiN8RRj07isUvLcbFRTcwayMVO+K0Th47yaQ3JzHfcz6OAAeeeZ484vcIV458lIvfdCWcyg8QKOYKuiqIC3deyJGnjhD4eiA3rbuJn1r+wsz+CzkRsoVs669kW38FwNLJD3x6k+HXCMPlPKyGPwYF5LvboIkbW5LySDqYy68nfmXu73PZlbCr6Di+Nl+ua30dT/d7utiIziennyTxq0QsrhZazWrFfkM/6OqTxk0b83Hfjxny2xCW+C7hlTdeYfLEyWbHklKo2BGnk5eXxwuvv8CLyS+S0aDwMvSgtEG8ftvrtGjdgi1bTA4oVcrV15XzXzmf8FvC2Tp2P5dtvoTLdl/C5vMO886V33Es6HfyXPZjuKZCyyVkAMVuUjYGboPb1wPr/5xts9oYcsEQbm5/M4NbDMbDtXgPvVNzTrH/3sLbV5FPR+LT2Qf02ap3Bg0ZxEPbHuL5gud5LOkxeq7uSa++5WssLzVHxY44lcULFvPAzw9w0O8geECLlBa81u81rrr6KrOjSTXzbueN17udeLhbPHd77qbroSjen34H26MK+KJvFjuyU0g7moSt92IKvH7HIAdwA7sbjjQfIpu649vAncY+jbmh7Q0MbzUcP4/SH/ia9G0Se8bsAQMa39OYpo/Ukhb4YopnHnmGdQ+uY63/Wm78+ka2tdlGYEig2bHkL1TsiFNYtXIV/7f0/1jvvx78wC/bjylhU3jg0Qc0AnI9YrFY+IEwDl2zlxsO5HL5Zlc6HHalw2Ff1jYKZMbJ6zFadivWFiM3zpe4j3vz1Wbo0uWfj5GyNoWd1+3EKDAI/Xco579+PhaLetfVZ1arlS8e+IJOr3fiuO9xLnv2Mr5/9HuCQoPMjiZ/0E8BqXZljVFTFWPwbFi7gUcXPFr40E5/sNqtDE+9mTuvegn/4DBOxprfE0wqr6Jj42S7W/i8fx4/ds7nX2vd6b7bld4nC+jBRn7YAN8OgLRzaHOeviWdHUN24Mhx4HVZENn3tmJr9J+FzrmOxyR1W+E4Y+G80PJz7j44lOiAaHo824u3B/2At19jbKWMQ1AbxyBzZip2pNqcbbwKqNwYPFs2buGxzx9jud9y8AcXhwtttl/NqdXP8uXpNnz5RuWPIear7Ng48QEG71ydy7KL8rlmqTedE+xcsRf6HvLi+675rOxaQHw5s2TtzWL7lduxp9nxuNiPAetak9ZdDZLru+LjjF1KRPgyrKOGsj9wL2OWXELOpys5nXZ+ie30valmqdiRanO2cWvOdQyeH1f8yEsrXuI7n+9w+BUOx98/8Up2ff4ssd0tuF2dVNTLqjaN8yPn5lzHxvm7o+EOnr24ARFLorg7eBvnJ1oYssGdK35zY815DmaRBXiVuX1OTA7bBmwjPyEf7y7eWF5oT9qlriVyVXQ8Jqn7/j7OWD7QOOZN3BpPIjbkCMG39ub8vdPJCA0u2kbfm2qeih2pdpUdayYvL49PP/2UN3e8ybaAbfBHm9FLUy7lueHPYfPuQde3IDxorca0cVJVNV5RNAH8d7ALF2dkcdUGN1qctHLZfoN+bCTrwWDSpjbF92LfYtskLU9iz6g95Cfm49nSkw7LO/D7MddSc53reExS9/31s5BFAOHpL+JW8F/iAo9T0HYckenPcNq/mckp6y8VO1JrJSck8/pHr/N+wvvE+sRCALjaXRmSNYSHrn6IHn16AKgruVSMxUJ0CzvRLeycf9yFQas96XocClYlsqV7Ir69fGn0n0YEDQsi5tkYjr1UOKBgg44NaP9Ne9xD3OGYyecgtV6GTwjuOz6gSdN7OB5+gAPWR2iZ+DiJwa3NjlYvqdiRWqUgv4DFCxcz89eZfO/5PbluueBT2LtqlG0UD4x5gMjmkWbHFCdxoImDly+zYvu4C7OvPkbBslOkrUsjbV0aWAF74XqN7mpE81eaY/WwmppX6pZMlxByZq3jvDH9OdRwJ1sbP0yXI9dwyn672dHqHRU7Uits/nUz733zHgtzF5LgnQB/3EmISo1ifNPx3HX/XXj7epsbUpzWURrg+UQr2s6I4uCDB4mfF19U6ACkrU8j9oNYQq4LwRauR3xK+WXmhJKf8TIdj77EtmY/sum8BYSkruOC818HRpgdr95QsVOPFXaXLH1Zbi7V2l3SMBxEhP/Myx8sYLPbMvYF7gE3wA18s325PHsoV7cbR9ur+uLi4sK+A2VnUnff+uvvX/vKfBb2rckme9VR8r8u7J/lEuWF0dgTY2MyGdEZHLj3AAfuO4C1gy9ZXUNoSDBGJbJL3XQun7l81wakhE7ioiOXcjjgbRL8TpEw8kYenvkJMwPfpUlkk+oJK0VU7NRTxbtLlsJigHFu3X3LYi3IIzjpd+zGRo4Eb+TU+Hjmnllmt9Jif28s20azf98IFti9WFDOTFL//NOwBhURGuvGaHYTcv8p8v+YN5cIPjwchf2IBR+jgMs5xQBO0dpIx74tDdu2NOZwkCNfw9Y2buw4z86RcEels0jtVRWfuVNhXfDLe4ume+eztcWXfB+8lDbvtuGx0Me4e9zdunpdjVTs1FN/7y75V2e6z1a2u6+bkU3zyK8JzFlEWvI2joTs4lBkTtFyW54HzU90wzuzJwnuvUixBZAdHELBbq8yu/SeLa/UH2V1Sa/IZ6FJgoUhv7hz0e4cXCj8XG5rBAs6urAv9CTeh/JJXdsK9yG/80tQBr8AAZkudNnjTpffPehICpGnIXKdO8PXQba7wS7/LH7lGMeSDOJCQc8FdR5V8ZkDyHf35IT7PTT54E7cr7+DAwH7eCTtEZ6d+izXWa5jwr8m0LFbx+o4hXpNxU49V1qX3jPdZyvU3ddiJyDnGL5xO3EY+0ny2klil33EXVjAwb+sFpgeTFRid+wJ/dn53e0k/3srmc0Lj2Ejrcxjny2TuvvWXxXt+u1LHn0OOOjxs41OB//89reOIJYNPs3x9ukA2Cj9M5cF/NDAl9m/d8eXfK7stZ4LE/JpFWPFO8dC1/gCunIQlkDmSi8ONC684rMnL59N5IChG191XVUNNxBz8lI23LiDpauf5b2E94jziWMmM5n57Uwu+uwi7uhwB/+++d/YPNRGrCqo2JEKcpAQe4IV3+5i2/5tRMdGsyN7F56P7GO3LbvE2oFpITRJbI+X0ZocrzYk+zUlMdxCRlJD8gt0yVaqmQENky10OuBKh+2ZXMB6rOsAXHFg8FsrO1+E+rFlTXvCQ9ZSkR8rabix5nwXfr0kF4sDmsa7cN5Gfy7Y3YCObsk0yLXQ8ZArHQ/BMLKBDaR+AUcb2jga5iAu0OBwagG/F908k/rGzd2dpx5+iv/m/5f5X8znnU3vsNZvLRsDNrLx2EYefOJBehX0om/TvgzqO4jWHVrj4qLLhefC9GJn+vTpvPTSS8TGxtK2bVumTZtG7969y1x/9erVTJo0iZ07d9KoUSMeeughxo8fX4OJnZzhoIE9Cc/wdYRl/oLbyZM4LHFku54k1TsWzyknuHLTX4oaL4oGnnUrcKNxchSBmc1xN9qQkNibg0uH4j5mHbaGhb8JqcWNVBsDArMdNCeJTjscRG60cV6sC2EpZ344FHavOhII0a3y+LVNAbFBBhk7K9+d3HApHKV5Z3MbSbs70OjGNVxAJufFudAszoWmR2xEpDvwy+GPB5Oe2TILWEf65xAX7EFcgIMkX4NkX4MTyQUcIhNLnoFaAzk3VzdXbvr3Tdz075vYu3Mvr897nc9zP+e012mWsIQlKUuYvHgyobND6W50p0/TPnRt05X2HdrrYaPlZGqxM2/ePCZOnMj06dPp1asX7777LoMGDWLXrl00LaVRyOHDhxk8eDC33347n332GevWreOuu+4iJCSEa6+91oQzqL3sdjupyamknE7h9OnTpKWmkZqeSnJqMolpiRw+kUjHgclY7CfIT0oh2zWNdM8kTnsnUXBxAVwMx8vYt8WwEJYRRlRBFO2929PY1ol33rwQrkzDaJRNkk/hehnJDQH9FiJVw+IA3ywL/hkWPE7lY+MkzbY6CMadkBQXmsa74J2TAeyALXDm21u+1WBPUzsbGnjz/e+dcBn6G7bw6r2a4nCxcDjcweFGhWVKxs4g0pZ05KLB62hRkE2TBBfCk10IO+VKcI6BTy74nLDS4sRfC68s4DeYC1nuXqQ1MEj3MkgpyCKePRRsdpAd4kqGZ2F7oeTEAk6Shleagd0Hst0h3/RfZ6WiWrZtyfSnp/Nq9qssX7qcH7b/wM+pP/O77+/Ee8fzNV/z9emvYR2wDgKzAmma25Tz3M7jAv8LaBrUlLDgMBqGNiS8YTgNmzTEw9PD7NMynan/FV599VXGjRvHbbfdBsC0adNYsWIFM2bMYOrUqSXWf+edd2jatCnTpk0DoHXr1mzatImXX365wsXOO0+8g6fNs9g84y/3042/dCp1nPm9yvhz2ZnlhmEUTmf+/O3fjj/+nJnvMBzYDTsOCv82MLA7/niNnQKjoHCioOh1PvkUGAXkkUe+Jb/o73xLPrmWXHJccsix5pBrzS2cXHPJcf+zIXCpvIGeZS/2ywggIDMY3+xA/LLDaZDXCLeMCLK3due/k86ndYc///McOgTfJ4D/sd24pf/5zTonNp90EvA/auCWWvy357KWVXT+2ZblpxikkED+j5Bw5M/18w9Bb6iSY1R0/plMVOD4Vfme/H3+mStt2bH5ZPx1/T8+67kn80knnoAjDlxPF65v+WNZzol8MjmF/yEHbklWLH/0lMs7nkcWsfjvc+AW54qLAS4OKDiZSzbH8N/hwHbIDasDXO3gWmCBhGwM9uCzxoGHmw2PPAueuWBLz8DGenxm2/Eo+GvbiGxgH2yHwjELCtktcMzw4mRkNiea5nIs1MG+JnZybJCxM5Ck3z0Ixxz5WDkYYuF4eEHRvIydDclc0pGOQ9fR1JJF2GkXAtMsBKZb8E9wJzDdBR8K8Mqz4JVnIfw0QAEQB78DxW68ZQFbYCFA4XvlwCDP1U4268jBin2RnTxPDwqsUOAKOVlZZPI7rqsdOBq4U2AFuwvkpGSTyQE8NjnA1w27BRwukJOQSwZH8f7dgUuMKw4LOCyFnSRz4vJI5wQ++xxYTxX+aDEskHMyj3Ri8TvgwJroivHHByjneD4ZnML3kAPX5L98Rk8Ufub8Dhd+5oCiS8I5f3we/Y8YuKVYi75L/33+mW1KfK4p/Gib/f+wrO9Nf9fL0oteHXsVflayM/h538+sTVzLZjZzpMERkhskk+xVOEUTXfjROPXHtPPP/XjneOOb64uX3QtPuydeDi88DU+8/vjjhhtuFjfcLe644oq7xR03FzesWLFa/pxccCn82+KCBcuff7sU/m3BgsVi+ePt/9vfltKv67uc5Rfiv2+TnVuyqUR5WQzDnBZzeXl5eHl5MX/+fIYPH140f8KECURHR7N69eoS2/Tp04fOnTvz+uuvF81buHAhN9xwA1lZWbi5uZXYJjc3l9zc3KLXqamphVeN7ocK3aCvoyyGBa9cL7xyvfDM98QrxwvfHF98s3zxyfHBJ8un6O+gjCCCMoIIyAjAzVHyvRQxmwNI84Bkqyvxmb5kRmSQ5p9Pshcc87dwKCWY5F9bEnDFNtwCM4ttm3MkmLRfLiixrKLz85MbcHpFYW+Zyu6rrPl/Xdbw8mhCbZn45IBPLthONsD9UAChzeLwIx/vPAOPPPDIcsUj24q3NRdPO1IPZLpncjLwJCcDTnIi8AQnAk+Q7J1MaoNU0jzTSPVKLSounUIu8BqkpKTg5+dXoU1Nu7KTmJiI3W4nLCys2PywsDDi4uJK3SYuLq7U9QsKCkhMTKRhw4Yltpk6dSpPPfVUyZ29du7Z6xIDg8w//og4hb9etDxGqc+pOr2i7M3LWlbR+VW5r7MdI/Z7iC1twdEyNlChU3/kAXF/TPVIUlJS3Sl2zvj7ZSrDMMq83FXW+qXNP2PKlClMmjSp6HVKSgrNmjUjJiamwm9WXZaWlkZERATHjh3D19f3nzdwEjpvnXd9oPPWedcHZ+7MBAYGVnhb04qd4OBgrFZrias48fHxJa7enBEeHl7q+q6urgQFld4i3WazYSvlGQN+fn716kNyhq+vr867HtF51y867/qlvp73uXS/N62rjLu7O127dmXlypXF5q9cuZKePUtvOdujR48S63/33Xd069at1PY6IiIiIqb2C540aRIffPABH330Ebt37+b+++8nJiamaNycKVOmMHr06KL1x48fz9GjR5k0aRK7d+/mo48+4sMPP+TBBx806xRERESkljO1zc6IESNISkri6aefJjY2lnbt2rF06VKaNWsGQGxsLDExMUXrR0VFsXTpUu6//37efvttGjVqxBtvvFGhbuc2m40nnnii1FtbzkznrfOuD3TeOu/6QOdd8fM2reu5iIiISE3Q8LYiIiLi1FTsiIiIiFNTsSMiIiJOTcWOiIiIODUVO3/Izc2lU6dOWCwWoqOjzY5T7a6++mqaNm2Kh4cHDRs2ZNSoUZw8edLsWNXqyJEjjBs3jqioKDw9PWnevDlPPPEEeXl5Zkerds8++yw9e/bEy8sLf39/s+NUm+nTpxMVFYWHhwddu3Zl7dq1ZkeqdmvWrGHo0KE0atQIi8XCokWLzI5U7aZOncqFF16Ij48PoaGhXHPNNezdu9fsWNVuxowZdOjQoWgwwR49erBs2TKzY9W4qVOnYrFYmDhxYrm3UbHzh4ceeohGjRqZHaPG9OvXjy+++IK9e/fy1VdfcfDgQa677jqzY1WrPXv24HA4ePfdd9m5cyevvfYa77zzDo8++qjZ0apdXl4e119/PXfeeafZUarNvHnzmDhxIo899hhbt26ld+/eDBo0qNjwFc4oMzOTjh078tZbb5kdpcasXr2au+++mw0bNrBy5UoKCgoYOHAgmZnO/QzAJk2a8Pzzz7Np0yY2bdpE//79GTZsGDt37vznjZ3Eb7/9xnvvvUeHDh0qtqEhxtKlS41WrVoZO3fuNABj69atZkeqcYsXLzYsFouRl5dndpQa9eKLLxpRUVFmx6gxM2fONPz8/MyOUS0uuugiY/z48cXmtWrVynjkkUdMSlTzAGPhwoVmx6hx8fHxBmCsXr3a7Cg1LiAgwPjggw/MjlEj0tPTjRYtWhgrV640+vbta0yYMKHc29b7KzunTp3i9ttv59NPP8XLy8vsOKZITk5m9uzZ9OzZs949diM1NfWcHiontUteXh6bN29m4MCBxeYPHDiQ9evXm5RKakpqaipAvfq/bLfb+fzzz8nMzKRHjx5mx6kRd999N1dddRWXX355hbet18WOYRiMHTuW8ePH061bN7Pj1LiHH36YBg0aEBQURExMDIsXLzY7Uo06ePAgb775ZtHjSaTuSkxMxG63l3iIcFhYWImHB4tzMQyDSZMmcckll9CuXTuz41S7HTt24O3tjc1mY/z48SxcuJA2bdqYHavaff7552zZsoWpU6ee0/ZOWew8+eSTWCyWs06bNm3izTffJC0tjSlTppgduUqU97zPmDx5Mlu3buW7777DarUyevRojDo4oHZFzxvg5MmTXHnllVx//fXcdtttJiWvnHM5b2dnsViKvTYMo8Q8cS733HMP27dvZ+7cuWZHqREtW7YkOjqaDRs2cOeddzJmzBh27dpldqxqdezYMSZMmMBnn32Gh4fHOe3DKR8XkZiYSGJi4lnXiYyM5MYbb+Sbb74p9s3QbrdjtVr597//zccff1zdUatUec+7tA/L8ePHiYiIYP369XXukmhFz/vkyZP069ePiy++mFmzZuHiUjdr/nP5es+aNYuJEyeSkpJSzelqVl5eHl5eXsyfP5/hw4cXzZ8wYQLR0dGsXr3axHQ1x2KxsHDhQq655hqzo9SIe++9l0WLFrFmzRqioqLMjmOKyy+/nObNm/Puu++aHaXaLFq0iOHDh2O1Wovm2e12LBYLLi4u5ObmFltWGlMfBFpdgoODCQ4O/sf13njjDZ555pmi1ydPnuSKK65g3rx5XHzxxdUZsVqU97xLc6bmzc3NrcpINaIi533ixAn69etH165dmTlzZp0tdKByX29n4+7uTteuXVm5cmWxYmflypUMGzbMxGRSHQzD4N5772XhwoX89NNP9bbQgcL3oi5+366Iyy67jB07dhSbd8stt9CqVSsefvjhfyx0wEmLnfJq2rRpsdfe3t4ANG/enCZNmpgRqUZs3LiRjRs3cskllxAQEMChQ4d4/PHHad68eZ27qlMRJ0+e5NJLL6Vp06a8/PLLJCQkFC0LDw83MVn1i4mJITk5mZiYGOx2e9FYUueff37R576umzRpEqNGjaJbt2706NGD9957j5iYGKdvk5WRkcGBAweKXh8+fJjo6GgCAwNLfI9zFnfffTdz5sxh8eLF+Pj4FLXL8vPzw9PT0+R01efRRx9l0KBBREREkJ6ezueff85PP/3E8uXLzY5WrXx8fEq0xzrT3rTc7bSqvG9YHXb48OF60fV8+/btRr9+/YzAwEDDZrMZkZGRxvjx443jx4+bHa1azZw50wBKnZzdmDFjSj3vVatWmR2tSr399ttGs2bNDHd3d6NLly71oivyqlWrSv3ajhkzxuxo1aas/8czZ840O1q1uvXWW4s+3yEhIcZll11mfPfdd2bHMkVFu547ZZsdERERkTPqboMFERERkXJQsSMiIiJOTcWOiIiIODUVOyIiIuLUVOyIiIiIU1OxIyIiIk5NxY6IiIg4NRU7IiIi4tRU7IiIlCIyMpJp06aZHUNEqoCKHRE5Z2PHjsVisWCxWHBzcyMsLIwBAwbw0Ucf4XA4KrSvWbNm4e/vX+lM7du357bbbit12dy5c3Fzc+PUqVOVPo6I1B0qdkSkUq688kpiY2M5cuQIy5Yto1+/fkyYMIEhQ4ZQUFBQ43nGjRvHF198QVZWVollH330EUOGDCEsLKzGc4mIeVTsiEil2Gw2wsPDady4MV26dOHRRx9l8eLFLFu2jFmzZhWt9+qrr9K+fXsaNGhAREQEd911FxkZGQD89NNP3HLLLaSmphZdKXryyScB+Oyzz+jWrRs+Pj6Eh4dz8803Ex8fX2aeUaNGkZuby/z584vNj4mJ4ccff2TcuHEcPHiQYcOGERYWhre3NxdeeCHff/99mfs8cuQIFoul6GnxACkpKVgsFn766aeiebt27WLw4MF4e3sTFhbGqFGjSExMLP+bKSLVQsWOiFS5/v3707FjRxYsWFA0z8XFhTfeeIPff/+djz/+mB9//JGHHnoIgJ49ezJt2jR8fX2JjY0lNjaWBx98EIC8vDz+97//sW3bNhYtWsThw4cZO3ZsmccOCgpi2LBhzJw5s9j8mTNnEhYWxqBBg8jIyGDw4MF8//33bN26lSuuuIKhQ4cSExNzzuccGxtL37596dSpE5s2bWL58uWcOnWKG2644Zz3KSJVpLoevy4izm/MmDHGsGHDSl02YsQIo3Xr1mVu+8UXXxhBQUFFr2fOnGn4+fn94zE3btxoAEZ6enqZ6yxbtsywWCzGwYMHDcMwDIfDYURGRhpTpkwpc5s2bdoYb775ZtHrZs2aGa+99pphGIZx+PBhAzC2bt1atPz06dMGYKxatcowDMP473//awwcOLDYPo8dO2YAxt69e//xvESk+ujKjohUC8MwsFgsRa9XrVrFgAEDaNy4MT4+PowePZqkpCQyMzPPup+tW7cybNgwmjVrho+PD5deeinAWa/CDBw4kCZNmhRd3fnxxx85cuQIt9xyCwCZmZk89NBDtGnTBn9/f7y9vdmzZ0+lruxs3ryZVatW4e3tXTS1atUKgIMHD57zfkWk8lTsiEi12L17N1FRUQAcPXqUwYMH065dO7766is2b97M22+/DUB+fn6Z+8jMzGTgwIF4e3vz2Wef8dtvv7Fw4UKg8PZWWVxcXBg7diwff/wxDoeDmTNn0qdPH1q0aAHA5MmT+eqrr3j22WdZu3Yt0dHRtG/fvsx9urgUfqs0DKNo3t9zOxwOhg4dSnR0dLFp//799OnT55/eLhGpRq5mBxAR5/Pjjz+yY8cO7r//fgA2bdpEQUEBr7zySlHh8MUXXxTbxt3dHbvdXmzenj17SExM5PnnnyciIqJoX+Vxyy238Mwzz7BgwQIWLFjAO++8U7Rs7dq1jB07luHDhwOQkZHBkSNHytxXSEgIUNgup3PnzgDFGisDdOnSha+++orIyEhcXfWtVaQ20ZUdEamU3Nxc4uLiOHHiBFu2bOG5555j2LBhDBkyhNGjRwPQvHlzCgoKePPNNzl06BCffvppseIDCgfxy8jI4IcffiAxMZGsrCyaNm2Ku7t70XZff/01//vf/8qVKyoqiv79+/Of//wHNzc3rrvuuqJl559/PgsWLCA6Oppt27Zx8803n3VcIE9PT7p3787zzz/Prl27WLNmDf/3f/9XbJ27776b5ORkbrrpJjZu3MihQ4f47rvvuPXWW0sUcSJSs1TsiEilLF++nIYNGxIZGcmVV17JqlWreOONN1i8eDFWqxWATp068eqrr/LCCy/Qrl07Zs+ezdSpU4vtp2fPnowfP54RI0YQEhLCiy++SEhICLNmzWL+/Pm0adOG559/npdffrnc2caNG8fp06e58cYb8fLyKpr/2muvERAQQM+ePRk6dChXXHEFXbp0Oeu+PvroI/Lz8+nWrRsTJkzgmWeeKba8UaNGrFu3DrvdzhVXXEG7du2YMGECfn5+RVezRMQcFuOvN6FFREREnIx+3RARERGnpmJHREREnJqKHREREXFqKnZERETEqanYEREREaemYkdEREScmoodERERcWoqdkRERMSpqdgRERERp6ZiR0RERJyaih0RERFxav8Pd2cER8K4Wn0AAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# define number of samples to generate\n",
    "nData = 400;\n",
    "\n",
    "# generate data from the mixture of Gaussians \n",
    "data = mixGaussGen1d(mixGaussTrue,nData)\n",
    "\n",
    "#plot! \n",
    "fig,ax = plt.subplots(1,1)\n",
    "drawEMData1d(data,mixGaussTrue)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Estimate MoG using the E-M Algorithm\n",
    "Here we want to use the E-M algorithm to fit a MoG model to our data points. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getMixGaussBound(data, mixGaussEst, responsibilities):                                                  \n",
    "    \"\"\"\n",
    "    Calculate the bound on the log likelihood for the whole data set under a mixture of Gaussians model.  \n",
    "    \n",
    "    Keyword arguments:\n",
    "    data -- d by n matrix containing data points.\n",
    "    mixGaussEst -- dict containing the mixture of gaussians parameters.\n",
    "    responsibilities -- k by n vector containing the responsibility of this data point for each Gaussian. \n",
    "    \n",
    "    Returns: \n",
    "    bound -- scalar containing the bound on the log likelihood.\n",
    "    \n",
    "    \"\"\"\n",
    "    # find total number of data items                                                                       \n",
    "    nDims, nData = data.shape                                                                               \n",
    "                                                                                                            \n",
    "    # initialize bound                                                                                      \n",
    "    bound = 0                                                                                               \n",
    "    \n",
    "    #<delete>\n",
    "    curCov = mixGaussEst['cov']                                                                             \n",
    "    curWeight = mixGaussEst['weight']                                                                       \n",
    "    curMean = mixGaussEst['mean']                                                                           \n",
    "    #</delete>\n",
    "        \n",
    "    # run through each data item                                                                            \n",
    "    for cData in range(nData):                                                                              \n",
    "        # extract this data                                                                                 \n",
    "        thisData = data[:, cData]                                                                           \n",
    "        # extract this q(h)                                                                                 \n",
    "        thisQ = responsibilities[:, cData]                                                                  \n",
    "                                                                                    \n",
    "        boundValue = 0\n",
    "\n",
    "        for i in range(mixGaussEst['k']):\n",
    "             # boundValue = sum_k(rik*log(lamda_k * Norm_xi(mu_k,cov_k)/rik))\n",
    "            boundValue = boundValue + thisQ[i]* np.log(curWeight[i]*getGaussProb(thisData, curMean[:, i], curCov[:,:,i])/thisQ[i])    \n",
    "        \n",
    "        # add to total log like\n",
    "        # bound = sum_i(boundValue)                                                                             \n",
    "        bound = bound + boundValue                                                                          \n",
    "                                                                                                            \n",
    "    return np.array(bound).item()                                                              "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "\n",
    "The log likelihood is taken since the raw likelihood value could be too small for our machine's percision. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getMixGaussLogLike(data, mixGaussEst):\n",
    "    \"\"\"\n",
    "    Calculate the log likelihood for the whole dataset under a mixture of Gaussians model.\n",
    "    \n",
    "    Keyword arguments:\n",
    "    data -- d by n matrix containing data points.\n",
    "    mixGaussEst -- dict containing the mixture of gaussians parameters.\n",
    "\n",
    "    Returns: \n",
    "    logLike -- scalar containing the log likelihood.\n",
    "    \n",
    "    \"\"\"\n",
    "    data = np.atleast_2d(data)                                                                         \n",
    "    # find total number of data items                                                                  \n",
    "    nDims, nData = data.shape                                                                          \n",
    "    \n",
    "    # initialize log likelihoods                                                                       \n",
    "    logLike = 0;                                                                                       \n",
    "                                                                                                       \n",
    "    # run through each data item                                                                       \n",
    "    for cData in range(nData):                                                                         \n",
    "        thisData = data[:, cData]    \n",
    "        \n",
    "        # calculate likelihood of this data point under mixture of Gaussians model. \n",
    "        like = 0\n",
    "        for i in range(mixGaussEst['k']):     \n",
    "            # like = sum_k(Pr(x,h_i|theta)) = sum_k(lamda_k * Norm_xi(mu_k,cov_k))                                                           \n",
    "            like = like + mixGaussEst['weight'][i]*getGaussProb(thisData, mixGaussEst['mean'][:, i], mixGaussEst['cov'][:,:,i])\n",
    "                                                                                                       \n",
    "        # add to total log like                                                                        \n",
    "        logLike = logLike + np.log(like)                                                               \n",
    "                                                                                                       \n",
    "    return  np.array(logLike).item()                                                                    \n",
    "                                                                                                       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fitMixGauss1d(data, k):   \n",
    "    \"\"\"\n",
    "    Estimate a k MoG model that would fit the data. Incremently plots the outcome.\n",
    "               \n",
    "    \n",
    "    Keyword arguments:\n",
    "    data -- d by n matrix containing data points.\n",
    "    k -- scalar representing the number of gaussians to use in the MoG model.\n",
    "    \n",
    "    Returns: \n",
    "    mixGaussEst -- dict containing the estimated MoG parameters.\n",
    "    \n",
    "    \"\"\"\n",
    "    #     MAIN E-M ROUTINE  \n",
    "    #     In the E-M algorithm, we calculate a complete posterior distribution over                                  \n",
    "    #     the (nData) hidden variables in the E-Step.  \n",
    "    #     In the M-Step, we update the parameters of the Gaussians (mean, cov, w).   \n",
    "    \n",
    "    nDims, nData = data.shape                                                                                        \n",
    "                                                                                                                     \n",
    "                                                                                                      \n",
    "    responsibilities = np.zeros(shape=(k, nData))                                                                    \n",
    "                                                                                                                     \n",
    "    # we will initialize the values to random values                                                                 \n",
    "    mixGaussEst = dict()                                                                                             \n",
    "    mixGaussEst['d'] = 1                                                                                             \n",
    "    mixGaussEst['k'] = k                                                                                             \n",
    "    mixGaussEst['weight'] = (1 / k) * np.ones(shape=(k))                                                             \n",
    "    mixGaussEst['mean'] = 2 * np.random.randn(1, k)                                                                  \n",
    "    mixGaussEst['cov'] = 0.1 + 1.5*np.random.uniform(size=(1,1,2))                                                   \n",
    "                                                                                                                     \n",
    "    # calculate current likelihood                                                                                                                                                                    \n",
    "    logLike = getMixGaussLogLike(data, mixGaussEst)                                                                  \n",
    "    print('Log Likelihood Iter 0 : {:4.3f}\\n'.format(logLike))                                                       \n",
    "                                                                                                                     \n",
    "    nIter = 20;                                                                                                      \n",
    "                                                                                                                     \n",
    "    logLikeVec = np.zeros(shape=(2 * nIter))                                                                         \n",
    "    boundVec = np.zeros(shape=(2 * nIter)) \n",
    "    \n",
    "    fig,ax = plt.subplots(1,1)\n",
    "                                                                                                                     \n",
    "    for cIter in range(nIter):                                                                                       \n",
    "                                                                                                                     \n",
    "        # ===================== =====================                                                                \n",
    "        # Expectation step                                                                                           \n",
    "        # ===================== =====================                                                                \n",
    "        curCov = mixGaussEst['cov']                                                                                  \n",
    "        curWeight = mixGaussEst['weight']                                                                            \n",
    "        curMean = mixGaussEst['mean']                                                                                \n",
    "        for cData in range(nData):           \n",
    "            \n",
    "            # Caculate posterior probability that                                \n",
    "            # this data point came from each of the Gaussians                                                        \n",
    "            lk = np.zeros(mixGaussEst['k'])\n",
    "\n",
    "            for i in range(mixGaussEst['k']):    \n",
    "               # lik = lamda_k * Norm_xi(mu_k,cov_k)                                                                                      \n",
    "               lk[i] = curWeight[i] * getGaussProb(data[:, cData],curMean[:,i],curCov[:,:,i])\n",
    "\n",
    "            # r_ik = like/ sum_k(like)\n",
    "            responsibilities[:, cData] = (lk/np.sum(lk)).reshape(mixGaussEst['k'],) \n",
    "\n",
    "\n",
    "        # calculate the log likelihood                                                                               \n",
    "        logLike = getMixGaussLogLike(data, mixGaussEst)                                                              \n",
    "        print('Log Likelihood After E-Step Iter {} : {:4.3f}\\n'.format(cIter, logLike))                              \n",
    "                                                                                                                     \n",
    "        # calculate the bound                                                                                                                                                                      \n",
    "        bound = getMixGaussBound(data, mixGaussEst, responsibilities)                                                \n",
    "        print('Bound After E-Step Iter {} : {:4.3f}\\n'.format(cIter, bound))     \n",
    "        \n",
    "        logLikeVec[2 * cIter] = logLike                                                                              \n",
    "        boundVec[2 * cIter] = bound                                                                                  \n",
    "        # ===================== =====================                                                                \n",
    "        # Maximization Step                                                                                          \n",
    "        # ===================== =====================                                                                \n",
    "        # for each constituent Gaussian                                                                              \n",
    "        for cGauss in range(k):                                                                                      \n",
    "            # Update weighting parameters mixGauss.weight based on the total                                 \n",
    "            # posterior probability associated with each Gaussian.\n",
    "            # lamda_k = sum_i(rik)/sum_k(sum_i(rik))                                         \n",
    "            mixGaussEst['weight'][cGauss] = np.sum(responsibilities[cGauss, :])/np.sum(responsibilities)\n",
    "            \n",
    "                                                                                                                 \n",
    "            # Update mean parameters mixGauss.mean by weighted average                                       \n",
    "            # where weights are given by posterior probability associated with Gaussian.\n",
    "            # mu_k = sum_i(rik*xi)/sum_i(rik)                                    \n",
    "            mixGaussEst['mean'][:,cGauss] = np.sum(responsibilities[cGauss, :] * data)/np.sum(responsibilities[cGauss, :])\n",
    "            \n",
    "            \n",
    "            # Update covarance parameter based on weighted average of                                        \n",
    "            # square distance from update mean, where weights are given by                                           \n",
    "            # posterior probability associated with Gaussian \n",
    "            # diff = x_i - mu_k                                            \n",
    "            diff = data - mixGaussEst['mean'][:, cGauss]\n",
    "            # cov_k = sum_i(rik*diff@diff.T)/sum_i(rik)\n",
    "            mixGaussEst['cov'][:,:,cGauss] = np.sum(responsibilities[cGauss, :] * diff @ diff.T) / np.sum(responsibilities[cGauss, :])\n",
    "                                                                                                                     \n",
    "        # draw the new solution \n",
    "        drawEMData1d(data, mixGaussEst)\n",
    "        time.sleep(0.7)\n",
    "        fig.canvas.draw()\n",
    "                                                                                                                     \n",
    "        # calculate the log likelihood                                                                               \n",
    "        logLike = getMixGaussLogLike(data, mixGaussEst)                                                              \n",
    "        print('Log Likelihood After M-Step Iter {} : {:4.3f}\\n'.format(cIter, logLike))                              \n",
    "                                                                                                                     \n",
    "        # calculate the bound                                                                                        \n",
    "        bound = getMixGaussBound(data, mixGaussEst, responsibilities)                                                \n",
    "        print('Bound After M-Step Iter {} : {:4.3f}\\n'.format(cIter, bound)) \n",
    "                                                                                                                  \n",
    "        logLikeVec[2 * cIter + 1] = logLike                                                                          \n",
    "        boundVec[2 * cIter + 1] = bound                                                                              \n",
    "                                                                                                                     \n",
    "    plt.figure()                                                                                                     \n",
    "    plt.plot(logLikeVec, 'g',label='log likelihood')                                                                                        \n",
    "    plt.plot(boundVec, 'r',label='lower bound')  \n",
    "    plt.legend()\n",
    "                                                                                                                     \n",
    "    return mixGaussEst                                                                                               "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Time to put it all together!\n",
    "\n",
    "Make sure you've filled all the TO DOs above! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Log Likelihood Iter 0 : -863.130\n",
      "\n",
      "Log Likelihood After E-Step Iter 0 : -863.130\n",
      "\n",
      "Bound After E-Step Iter 0 : -863.130\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\dudu2\\AppData\\Local\\Temp\\ipykernel_3832\\1327614761.py:61: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n",
      "  lk[i] = curWeight[i] * getGaussProb(data[:, cData],curMean[:,i],curCov[:,:,i])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Log Likelihood After M-Step Iter 0 : -642.008\n",
      "\n",
      "Bound After M-Step Iter 0 : -647.494\n",
      "\n",
      "Log Likelihood After E-Step Iter 1 : -642.008\n",
      "\n",
      "Bound After E-Step Iter 1 : -642.008\n",
      "\n",
      "Log Likelihood After M-Step Iter 1 : -633.892\n",
      "\n",
      "Bound After M-Step Iter 1 : -637.663\n",
      "\n",
      "Log Likelihood After E-Step Iter 2 : -633.892\n",
      "\n",
      "Bound After E-Step Iter 2 : -633.892\n",
      "\n",
      "Log Likelihood After M-Step Iter 2 : -626.622\n",
      "\n",
      "Bound After M-Step Iter 2 : -630.153\n",
      "\n",
      "Log Likelihood After E-Step Iter 3 : -626.622\n",
      "\n",
      "Bound After E-Step Iter 3 : -626.622\n",
      "\n",
      "Log Likelihood After M-Step Iter 3 : -619.307\n",
      "\n",
      "Bound After M-Step Iter 3 : -622.991\n",
      "\n",
      "Log Likelihood After E-Step Iter 4 : -619.307\n",
      "\n",
      "Bound After E-Step Iter 4 : -619.307\n",
      "\n",
      "Log Likelihood After M-Step Iter 4 : -611.305\n",
      "\n",
      "Bound After M-Step Iter 4 : -615.412\n",
      "\n",
      "Log Likelihood After E-Step Iter 5 : -611.305\n",
      "\n",
      "Bound After E-Step Iter 5 : -611.305\n",
      "\n",
      "Log Likelihood After M-Step Iter 5 : -602.239\n",
      "\n",
      "Bound After M-Step Iter 5 : -606.880\n",
      "\n",
      "Log Likelihood After E-Step Iter 6 : -602.239\n",
      "\n",
      "Bound After E-Step Iter 6 : -602.239\n",
      "\n",
      "Log Likelihood After M-Step Iter 6 : -592.221\n",
      "\n",
      "Bound After M-Step Iter 6 : -597.215\n",
      "\n",
      "Log Likelihood After E-Step Iter 7 : -592.221\n",
      "\n",
      "Bound After E-Step Iter 7 : -592.221\n",
      "\n",
      "Log Likelihood After M-Step Iter 7 : -582.501\n",
      "\n",
      "Bound After M-Step Iter 7 : -587.017\n",
      "\n",
      "Log Likelihood After E-Step Iter 8 : -582.501\n",
      "\n",
      "Bound After E-Step Iter 8 : -582.501\n",
      "\n",
      "Log Likelihood After M-Step Iter 8 : -575.727\n",
      "\n",
      "Bound After M-Step Iter 8 : -578.459\n",
      "\n",
      "Log Likelihood After E-Step Iter 9 : -575.727\n",
      "\n",
      "Bound After E-Step Iter 9 : -575.727\n",
      "\n",
      "Log Likelihood After M-Step Iter 9 : -572.951\n",
      "\n",
      "Bound After M-Step Iter 9 : -573.903\n",
      "\n",
      "Log Likelihood After E-Step Iter 10 : -572.951\n",
      "\n",
      "Bound After E-Step Iter 10 : -572.951\n",
      "\n",
      "Log Likelihood After M-Step Iter 10 : -572.207\n",
      "\n",
      "Bound After M-Step Iter 10 : -572.453\n",
      "\n",
      "Log Likelihood After E-Step Iter 11 : -572.207\n",
      "\n",
      "Bound After E-Step Iter 11 : -572.207\n",
      "\n",
      "Log Likelihood After M-Step Iter 11 : -572.014\n",
      "\n",
      "Bound After M-Step Iter 11 : -572.081\n",
      "\n",
      "Log Likelihood After E-Step Iter 12 : -572.014\n",
      "\n",
      "Bound After E-Step Iter 12 : -572.014\n",
      "\n",
      "Log Likelihood After M-Step Iter 12 : -571.957\n",
      "\n",
      "Bound After M-Step Iter 12 : -571.977\n",
      "\n",
      "Log Likelihood After E-Step Iter 13 : -571.957\n",
      "\n",
      "Bound After E-Step Iter 13 : -571.957\n",
      "\n",
      "Log Likelihood After M-Step Iter 13 : -571.938\n",
      "\n",
      "Bound After M-Step Iter 13 : -571.945\n",
      "\n",
      "Log Likelihood After E-Step Iter 14 : -571.938\n",
      "\n",
      "Bound After E-Step Iter 14 : -571.938\n",
      "\n",
      "Log Likelihood After M-Step Iter 14 : -571.932\n",
      "\n",
      "Bound After M-Step Iter 14 : -571.935\n",
      "\n",
      "Log Likelihood After E-Step Iter 15 : -571.932\n",
      "\n",
      "Bound After E-Step Iter 15 : -571.932\n",
      "\n",
      "Log Likelihood After M-Step Iter 15 : -571.930\n",
      "\n",
      "Bound After M-Step Iter 15 : -571.931\n",
      "\n",
      "Log Likelihood After E-Step Iter 16 : -571.930\n",
      "\n",
      "Bound After E-Step Iter 16 : -571.930\n",
      "\n",
      "Log Likelihood After M-Step Iter 16 : -571.929\n",
      "\n",
      "Bound After M-Step Iter 16 : -571.930\n",
      "\n",
      "Log Likelihood After E-Step Iter 17 : -571.929\n",
      "\n",
      "Bound After E-Step Iter 17 : -571.929\n",
      "\n",
      "Log Likelihood After M-Step Iter 17 : -571.929\n",
      "\n",
      "Bound After M-Step Iter 17 : -571.929\n",
      "\n",
      "Log Likelihood After E-Step Iter 18 : -571.929\n",
      "\n",
      "Bound After E-Step Iter 18 : -571.929\n",
      "\n",
      "Log Likelihood After M-Step Iter 18 : -571.929\n",
      "\n",
      "Bound After M-Step Iter 18 : -571.929\n",
      "\n",
      "Log Likelihood After E-Step Iter 19 : -571.929\n",
      "\n",
      "Bound After E-Step Iter 19 : -571.929\n",
      "\n",
      "Log Likelihood After M-Step Iter 19 : -571.929\n",
      "\n",
      "Bound After M-Step Iter 19 : -571.929\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#generate data from the ground truth mixture of Gaussians we've defined way above. \n",
    "data = mixGaussGen1d(mixGaussTrue,nData);\n",
    "\n",
    "#draw data, ground truth mixture of Gaussians.\n",
    "drawEMData1d(data,mixGaussTrue)\n",
    "\n",
    "#define number of components to estimate\n",
    "nGaussEst = 2;\n",
    "\n",
    "#fit mixture of Gaussians (Pretend someone handed you some data. Now what?)\n",
    "mixGaussEst = fitMixGauss1d(data,nGaussEst);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first and the second image above show the ground truth distribution and estimated distribution respectively, in which the green curve is the mixed distribution and the red curve is the separated distribution. It can be seen that the estimated distribution in the second figure matches the data well, and is intuitively close to the ground truth.\n",
    "The third figure plots the log likelihood and the EM lower bound in green and red with each iteration. As indicated in the figure, the lower bound is being maximized in each E and M step, with respect to the responsibility and the parameters respectively, and the likelihood is maximized in the M-step within each iteration. The lower bound is close to the likelihood, but slightly lower, which matches the expectation."
   ]
  }
 ],
 "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.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}