Assignment 6/.ipynb_checkpoints/HW6_16110142_Q1-checkpoint.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Q1 (a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from sklearn.model_selection import train_test_split\n",
    "import numpy as np\n",
    "from sklearn.datasets import load_iris\n",
    "import pandas as pd\n",
    "from sklearn.utils import shuffle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = load_iris()['data']\n",
    "y = load_iris()['target']\n",
    "df = pd.DataFrame(X)\n",
    "\n",
    "df = df[[0,3]]\n",
    "\n",
    "dataset = np.array(df)\n",
    "df['y'] = pd.Series(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_gaussian(x, mean, variance):\n",
    "    val = (1/np.sqrt(2*np.pi*variance))*np.exp(-((x-mean)**2)/(2*variance))\n",
    "    return val"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\"\"\"\n",
    "    Defining the helper functions here\n",
    "\"\"\"\n",
    "def gaussian_naive_bayes(X,y):\n",
    "    number_classes = {}\n",
    "    for i in y:\n",
    "        if i not in number_classes:\n",
    "            number_classes[i]=1\n",
    "        else:\n",
    "            number_classes[i]+=1\n",
    "    normalise = 0\n",
    "    for i in number_classes:\n",
    "        normalise+=number_classes[i]\n",
    "    for i in number_classes:\n",
    "        number_classes[i]/=normalise\n",
    "    mean = {i:0  for i in number_classes}\n",
    "    variance = {i:0 for i in number_classes}\n",
    "    for label in number_classes:\n",
    "        new_arr = [0 for i in range(len(X[0]))]\n",
    "        var_arr = [0 for i in range(len(X[0]))]\n",
    "        count = 0\n",
    "        for j in range(len(y)):\n",
    "            if y[j] == label:\n",
    "                count+=1\n",
    "                for k in range(len(new_arr)):\n",
    "                    new_arr[k]+=X[j][k]\n",
    "                    var_arr[k]+=X[j][k]**2\n",
    "        for i in range(len(new_arr)):\n",
    "            new_arr[i]/=count\n",
    "            var_arr[i]/=count\n",
    "        mean[label] = np.array(new_arr)\n",
    "        var_compute = []\n",
    "        for i in range(len(new_arr)):\n",
    "            var_compute.append(var_arr[i] - new_arr[i]**2)\n",
    "        variance[label] = np.array(var_compute)\n",
    "    return mean, variance\n",
    "\n",
    "def predict(mean, variance, X_test, y_test,active=False,result=True):\n",
    "    predicted = [-1 for i in range(len(X_test))]\n",
    "    prob_values = []\n",
    "    for i in range(len(X_test)):\n",
    "        current_sample = X_test[i]\n",
    "        new_arr = []\n",
    "        for label in mean:\n",
    "            val = 0\n",
    "            for j in range(len(X_test[i])):\n",
    "                val+=np.log((compute_gaussian(X_test[i][j],mean[label][j],variance[label][j])))\n",
    "            new_arr.append((val,label))\n",
    "        new_arr = sorted(new_arr,key=lambda x: x[0])\n",
    "        predicted[i] = new_arr[len(new_arr)-1][1]\n",
    "        prob_values.append((new_arr[len(new_arr)-1][0],new_arr[len(new_arr)-1][1],i))\n",
    "    #print(predicted)\n",
    "    if result==True:\n",
    "        counter = 0\n",
    "        for i in range(len(y_test)):\n",
    "            if y_test[i]==predicted[i]:\n",
    "                counter+=1\n",
    "        print(\"Accuracy of Naive Bayes is,\",counter/len(y_test)*100,\"%\")\n",
    "    if active==False:\n",
    "        return np.array(predicted)\n",
    "    else:\n",
    "        return np.array(predicted),prob_values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of Naive Bayes is, 98.0 %\n"
     ]
    }
   ],
   "source": [
    "df_new = shuffle(df)\n",
    "train = df_new[:100]\n",
    "test = df_new[100:]\n",
    "X_train = np.array(train[[0,3]])\n",
    "y_train =  np.array(train['y'])\n",
    "X_test =  np.array(test[[0,3]])\n",
    "y_test =  np.array(test['y'])\n",
    "mean_train, variance_train = gaussian_naive_bayes(X_train,y_train)\n",
    "predicted_labels = predict(mean_train,variance_train,X_test,y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Q1 (b) (i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_min, x_max = df[0].values.min() - .5, df[0].max() + .5\n",
    "y_min, y_max = df[3].min() - .5, df[3].max() + .5\n",
    "h = 0.1  # step size in the mesh\n",
    "xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))\n",
    "Z = predict(mean_train,variance_train,np.c_[xx.ravel(), yy.ravel()],y_test,result=False)\n",
    "\n",
    "# Put the result into a color plot\n",
    "Z = Z.reshape(xx.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of Naive Bayes is, 86.0 %\n",
      "Accuracy of Naive Bayes is, 90.0 %\n",
      "Accuracy of Naive Bayes is, 92.0 %\n",
      "Accuracy of Naive Bayes is, 92.0 %\n",
      "Accuracy of Naive Bayes is, 92.0 %\n",
      "Accuracy of Naive Bayes is, 92.0 %\n",
      "Accuracy of Naive Bayes is, 92.0 %\n",
      "Accuracy of Naive Bayes is, 92.0 %\n",
      "Accuracy of Naive Bayes is, 92.0 %\n",
      "Accuracy of Naive Bayes is, 92.0 %\n",
      "Accuracy of Naive Bayes is, 92.0 %\n",
      "Accuracy of Naive Bayes is, 92.0 %\n",
      "Accuracy of Naive Bayes is, 92.0 %\n",
      "Accuracy of Naive Bayes is, 92.0 %\n",
      "Accuracy of Naive Bayes is, 92.0 %\n",
      "Accuracy of Naive Bayes is, 92.0 %\n",
      "Accuracy of Naive Bayes is, 92.0 %\n",
      "Accuracy of Naive Bayes is, 92.0 %\n",
      "Accuracy of Naive Bayes is, 92.0 %\n",
      "Accuracy of Naive Bayes is, 92.0 %\n",
      "Accuracy of Naive Bayes is, 92.0 %\n",
      "Accuracy of Naive Bayes is, 92.0 %\n",
      "Accuracy of Naive Bayes is, 92.0 %\n",
      "Accuracy of Naive Bayes is, 92.0 %\n",
      "Accuracy of Naive Bayes is, 92.0 %\n"
     ]
    }
   ],
   "source": [
    "df_new = shuffle(df)\n",
    "train_set = df_new[:15]\n",
    "pool_set = df_new[15:100]\n",
    "test_set = df_new[100:]\n",
    "X_train = np.array(train_set[[0,3]])\n",
    "y_train =  np.array(train_set['y'])\n",
    "X_test =  np.array(test_set[[0,3]])\n",
    "y_test =  np.array(test_set['y'])\n",
    "X_pool = np.array(pool_set[[0,3]])\n",
    "y_pool = np.array(pool_set['y'])\n",
    "\n",
    "mean_train, variance_train = gaussian_naive_bayes(X_train, y_train)\n",
    "accuracy_active = []\n",
    "for itr in range(25):\n",
    "    _, prob = predict(mean_train,variance_train,X_pool,y_pool,active=True,result = False)\n",
    "    new_arr = (sorted(prob,key = lambda x:x[0]))\n",
    "    #print(index)\n",
    "    index = new_arr[0][2]\n",
    "    X_train = np.vstack([X_train, X_pool[index]])\n",
    "    y_train = list(y_train)\n",
    "    y_train.append(y_pool[index])\n",
    "    y_train = np.array(y_train)\n",
    "    X_pool = np.delete(X_pool,index,0)\n",
    "    y_pool = np.delete(y_pool,index)\n",
    "    mean_train, variance_train = gaussian_naive_bayes(X_train, y_train)\n",
    "    predicted_labels = predict(mean_train,variance_train,X_test,y_test)\n",
    "    counter = 0\n",
    "    for i in range(len(y_test)):\n",
    "        if y_test[i]==predicted_labels[i]:\n",
    "            counter+=1\n",
    "    accuracy_active.append(counter/len(y_test)*100)\n",
    "    Z = predict(mean_train, variance_train, np.c_[xx.ravel(), yy.ravel()],y_test,result = False)\n",
    "    Z = Z.reshape(xx.shape)\n",
    "    plt.figure(figsize = (9,6))\n",
    "    plt.scatter(X_train[:,0], X_train[:,1], c= y_train, \n",
    "            edgecolors='k', s=250, cmap=plt.cm.Paired )\n",
    "    plt.pcolormesh(xx, yy, Z, cmap=plt.cm.Paired, alpha=0.2)\n",
    "    plt.xlabel('Petal Width')\n",
    "    plt.ylabel('Sepal Length')\n",
    "    plt.title('Boundary Change as Active Learning goes on.. Note the added datapoints - '+str(itr))\n",
    "    plt.savefig('GIF/'+'00'+str(itr)+'.png')\n",
    "    plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Q1 (b) (ii)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"image.gif\"/>"
      ],
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import Image\n",
    "Image(url='image.gif')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A much faster GIF is uploaded [here](https://drive.google.com/file/d/1J3UFvih944jwCcIzy6vgJF6oiVgTz5J4/view?usp=sharing)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Q1 (b) (iii)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "seed_ = [i for i in range(5)]\n",
    "overall = {i:[0 for j in range(10)] for i in range(5)}\n",
    "for sd in seed_:\n",
    "    train_set = df_new[:15]\n",
    "    pool_set = df_new[15:100]\n",
    "    test_set = df_new[100:]\n",
    "    X_train = np.array(train_set[[0,3]])\n",
    "    y_train =  np.array(train_set['y'])\n",
    "    X_test =  np.array(test_set[[0,3]])\n",
    "    y_test =  np.array(test_set['y'])\n",
    "    X_pool = np.array(pool_set[[0,3]])\n",
    "    y_pool = np.array(pool_set['y'])\n",
    "    np.random.seed(sd)\n",
    "    random_accuracy  = []\n",
    "    for itr in range(10):\n",
    "        index = np.random.randint(0,len(X_pool))\n",
    "        X_train = np.vstack([X_train, X_pool[index]])\n",
    "        y_train = list(y_train)\n",
    "        y_train.append(y_pool[index])\n",
    "        y_train = np.array(y_train)\n",
    "        X_pool = np.delete(X_pool,index,0)\n",
    "        y_pool = np.delete(y_pool,index)\n",
    "        mean_train, variance_train = gaussian_naive_bayes(X_train, y_train)\n",
    "        predicted_labels = predict(mean_train,variance_train,X_test,y_test,result=False)\n",
    "        counter = 0\n",
    "        for i in range(len(y_test)):\n",
    "            if y_test[i]==predicted_labels[i]:\n",
    "                counter+=1\n",
    "        random_accuracy.append(counter/len(y_test)*100)\n",
    "        overall[sd][itr]=(np.array(random_accuracy).mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "mean_random = [0 for i in range(10)]\n",
    "for i in range(10):\n",
    "    for j in overall:\n",
    "        mean_random[i]+=overall[j][i]\n",
    "for i in range(10):\n",
    "    mean_random[i]/=5\n",
    "mean_variance = [0 for i in range(10)]\n",
    "random_variance = [0 for i in range(10)]\n",
    "for i in range(len(random_variance)):\n",
    "    sum_1 = 0\n",
    "    for j in overall:\n",
    "        sum_1+=overall[j][i]**2\n",
    "    sum_1/=5\n",
    "    sum_1 = sum_1 - mean_random[i]**2\n",
    "    sum_1 = np.sqrt(sum_1)\n",
    "    random_variance[i] = sum_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Five Seeds are the columns\n",
      "The columns represent the accuracy, with respect to number of samples\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>86.000000</td>\n",
       "      <td>88.000000</td>\n",
       "      <td>86.000000</td>\n",
       "      <td>88.000000</td>\n",
       "      <td>88.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>86.000000</td>\n",
       "      <td>88.000000</td>\n",
       "      <td>87.000000</td>\n",
       "      <td>90.000000</td>\n",
       "      <td>87.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>86.000000</td>\n",
       "      <td>86.666667</td>\n",
       "      <td>86.666667</td>\n",
       "      <td>90.666667</td>\n",
       "      <td>88.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>86.000000</td>\n",
       "      <td>87.000000</td>\n",
       "      <td>86.500000</td>\n",
       "      <td>90.500000</td>\n",
       "      <td>88.500000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>86.400000</td>\n",
       "      <td>87.200000</td>\n",
       "      <td>86.400000</td>\n",
       "      <td>90.400000</td>\n",
       "      <td>88.400000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>87.333333</td>\n",
       "      <td>87.333333</td>\n",
       "      <td>86.666667</td>\n",
       "      <td>90.000000</td>\n",
       "      <td>88.666667</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>88.000000</td>\n",
       "      <td>87.428571</td>\n",
       "      <td>86.857143</td>\n",
       "      <td>90.000000</td>\n",
       "      <td>88.857143</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>88.250000</td>\n",
       "      <td>87.750000</td>\n",
       "      <td>87.500000</td>\n",
       "      <td>89.750000</td>\n",
       "      <td>89.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>88.666667</td>\n",
       "      <td>88.222222</td>\n",
       "      <td>88.000000</td>\n",
       "      <td>89.555556</td>\n",
       "      <td>89.111111</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>89.000000</td>\n",
       "      <td>88.600000</td>\n",
       "      <td>88.400000</td>\n",
       "      <td>89.600000</td>\n",
       "      <td>89.200000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           0          1          2          3          4\n",
       "0  86.000000  88.000000  86.000000  88.000000  88.000000\n",
       "1  86.000000  88.000000  87.000000  90.000000  87.000000\n",
       "2  86.000000  86.666667  86.666667  90.666667  88.000000\n",
       "3  86.000000  87.000000  86.500000  90.500000  88.500000\n",
       "4  86.400000  87.200000  86.400000  90.400000  88.400000\n",
       "5  87.333333  87.333333  86.666667  90.000000  88.666667\n",
       "6  88.000000  87.428571  86.857143  90.000000  88.857143\n",
       "7  88.250000  87.750000  87.500000  89.750000  89.000000\n",
       "8  88.666667  88.222222  88.000000  89.555556  89.111111\n",
       "9  89.000000  88.600000  88.400000  89.600000  89.200000"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "print('The Five Seeds are the columns')\n",
    "print('The columns represent the accuracy, with respect to number of samples')\n",
    "df = pd.DataFrame(overall)\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Accuracy vs Number of Points Queried')"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3Xl4FFXWwOHfSVgCssouO7gAgrJEIGyCuOGgOIIODqOgo4yionzjqOOGDuroiI6DooiyuCDjDo7bwCQEBUIgQNgFRHbDIpCwk5Cc74+qtE3I0lk61Umf93n6SXd19a2TSqdO1b237hVVxRhjTPiK8DoAY4wx3rJEYIwxYc4SgTHGhDlLBMYYE+YsERhjTJizRGCMMWHOEoExOYjICBFZ4OH27xaRPSJyRETqlGC534jI8JIqL5SIyDARmVPEz3r69w4Flgg8JCLxInJQRCp7HUsoE5HpIqIi0tVv2bkiUu5ughGRisDLwJWqWk1V9+d4v4W7L464j60i8kggZavqAFV9J8A44kXkjsL/Br7PDxSRJSJyVET2i8j7ItK4qOUVRFVnqOqVwSq/vLNE4BERaQH0BhS4rpS3XaE0t1dCDgDPeB1EYRVhXzcAooC1BaxXS1WrATcDT4rI1UWJLxhEZAjwAfAKUBe4EEgHvheRWkHYXln8PocUSwTeuRVYDEwHTrtcF5EqIvKSiGwTkTQRWSAiVdz3eonIIhFJFZEdIjLCXX7aGVzOy133LPIeEdkEbHKX/cst45CILBOR3n7rR4rIoyKyWUQOu+83FZGJIvJSjni/EJExOX9BEXlDRMbnWDZbRP7Pff6wiOxyy98gIv3z2V/vABeJyKW5vemeGV/u9/opEXnffZ59Fn2b+/seFJG7ROQSEVnl7svXzixSXnP3/w/+sYlITRGZIiIpbvzPiEik335fKCL/FJH9wFO5xFpZRF4RkZ/dxyvusvOBDe5qqSISl8/+AEBVE3CSRnu37B4istSNe6mI9PDbru87kv39EJHx7v7YIiID3PeexTlJec296nhNHP8Ukb3u92W1iLTP5XcT4CXgGVX9QFWPq+pu4A7gGHB/zr9Pjr9RhaLs41y+721EZK6IHHC/Wzf5vVfH/c4eEpElQOuC9nO5p6r28OAB/AiMAroAGUADv/cmAvFAYyAS6AFUBpoDh3HOAisCdYCO7mfigTv8yhgBLPB7rcBc4GygirvsD24ZFYA/A7uBKPe9vwCrgQsAAS521+0K/AxEuOvVxfkHb5DL79gH2AGI+7o2cBw4xy13B3CO+14LoHUe+2o6ztXA6OzfCTjX+fr61tkKXO73+ingfb+yFZiEc7Z9JXACmAXUd/fzXuBSv313Chjj7uffAWnA2e77nwNvAme5n18C/CnHZ+9z92uVXH6fv+GcBNQH6gGLgHE5Yq2Qx77wve/+XXq6+7+/+7c9CNzivn+z+7pOzu+IG2cGcCfOd+xu9+8qOdd1X18FLANqudttCzTKJb42bnwtc3nvaWBhzr9Pbr93Yfcxft939zM7gNvc9zsBvwDt3Pf/DXzkrtce2IXf/0o4PjwPIBwfQC/3n7Cu+/oHYIz7PALnYHlxLp/7K/B5HmXm/McdwZmJ4LIC4jqYvV2cM9NBeay3HrjCfX4v8HUe6wmwHejjvr4TiHOfn4tz8L0cqFhAXNNxEkFlt7wBFC0RNPZ7fz/wO7/XnwIP+O0730HRXbYE5wDbADiJ3wEe54A7z++z2wv4fTYD1/i9vgrYmiPWghJBqvv3Wg+Mdt+7BViSY/0EYETO74gb549+61V1y22Yx/fpMmAj0B33JCCf77binlDkeO8uYGPOv0/O37so+5jTE8HvgO9zvP8mMBYn6WUAbfzee44wTwRWNeSN4cAcVf3Fff0Bv1YP1cU5a92cy+ea5rE8UDv8X4jIgyKy3q1GSAVqutsvaFvv4FxN4P58L7eV1Pkv+zfOPzHA74EZ7ns/Ag/gHBD2isi/ReSc/IJX1ZPAOPdRFHv8nh/P5XU1v9e73PizbcO5kmmOc5WQ4lYppeIcZOr7rXvafs7FOW55OcsujLqqWltV26rqhDzKzS47r0ba3dlPVPWY+7RabiuqahzwGs7V6l4RmSwiNXJZNfs73SiX9xr5vZ+f4u7j5kC37M+6nx8GNMS5AquQ4/M591nYsURQysSp678JuFREdovIbpwqiItF5GKcf5QT5F5vuSOP5QBHcc7qsjXMZR3fgU2c9oCH3Fhqq2otnOoPCWBb7wOD3Hjb4lSx5GUmMEREmgPdcM68nWCcOuReOP+4CryQTznZpuFUT9yQY3kgv39hNHbru7M1w7lK2IFztlpXVWu5jxqqeqHfugX1ZvoZ53fOWXZx5Sw3u+xdRSjrjN9BVSeoahegHXA+TvVhThuAncCN/gtFJAIYjHOlAfn/vYq7j3cA8/0+W0udHlh3A/twqpWa+q3fLJ+ywoIlgtJ3PZCJ88/U0X20Bb4HblXVLGAq8LKInCNOo22MOF1MZwCXi8hNIlLBbfTq6JabDNwgIlVF5FzgjwXEUR3nH2IfUEFEngT8z/DeBsaJyHluQ+FF4vZpV9WdwFKcK4FPVfV4XhtR1RU4ye1t4L+qmgogIheIyGXu73UC54w8q6Cdp6qncC7xH87xVjIwVEQqikg0MKSgsgpQHxjtlncjzt/oa1VNAeYAL4lIDRGJEJHWkkcjdh5mAo+LSD0RqQs8iZNci+tr4HwR+b37/fgdzvfsyyKUtQdolf1CnIb1buJ0bz2K8zc74+/lXkU9iPP7/V5EokSkIc7fvy7wqrtqMtBHRJqJSE2cas/sMoq7j7/E2Q+3uH+/im78bVU1E/gMp4G5qoi0I0dnjXBkiaD0DQemqep2Vd2d/cC57B7m9pp4EKehdilOt8kXcOpltwPX4DTsHsD5Z7rYLfefOF309uBU3cwoII7/At/i1Ptuw/nH9r9cfhmnQW0OcAiYgtMol+0doAN5VAvl8AFOW8AHfssqA8/jJIndOAfev5750VzNBFJyLHsC5wrmIE6j5Ac5P1RIicB5bnzPAkP01z79twKVgHXu9j4h96qQvDwDJAGrcP7OyymBrrFufANxvh/7ca74BvpVQRbGv3Cu5A6KyASck4S3cH7fbW75L+YRx4c47RVjcL6nKUA0TmN8irvOXOBDnH2wjDOTVZH3saoexukQMBTnKmk3zv9Q9v069+JUge3GaX+aFki55Vl2DwFjCkVE+uCcxTZX+xKZfIjIlbgnA6qa7HU85kx2RWAKza0euB9425KAKYiqzsHpytnd61hM7uyKwBSKiLTFqdZYCVytqoc8DskYU0yWCIwxJsxZ1ZAxxoS5MjFYU926dbVFixZeh2GMMWXKsmXLflHVegWtVyYSQYsWLUhKSvI6DGOMKVNEJKC7pq1qyBhjwpwlAmOMCXOWCIwxJsxZIjDGmDBnicAYY8JcUBOBiNwvImtEZK2IPOAue1Gcqf9WicjnEoQ5TI0xxgQuaInAnc/0TpypDS8GBrrDI88F2qvqRTgjXwY64qQproQE+PvfnZ/hHkcoxGBxWBwhEkcw7yNoCyRmz3wkIvOBG1T1H37rLKb448abQCQkQN++kJEBkZFwyy3QpEnpx7FzJ7z3HmRmehdHKMRgcVgcgcaRlQWVK0NsLMTEBGVTQRtryB2cbDYQgzPpSCyQpKr3+a3zH+BDVT1jUg4RGQmMBGjWrFmXbdvCfja54hk9Gl599fRlp03AVUpy+76VdhyhEIPFYXEUJo7ISBg3Dv5auAoUEVmmqtEFrRe0qiFVXY8zGcQcnAlQknFm5soO8DGcGbJynUBFVSerarSqRterV+Ad0qYgy5c7PyMjoUoVWLTIOdMo7ceiRc72vYwjFGKwOCyOwsRRqZJzRR8kpTb6qIg8B+xU1ddFZATwJ6C/36TZeYqOjlYbYqIYEhOhe3cYORJatHC+UEG6xAxIQgLEx3sbRyjEYHFYHEGOI9ArgqAmAhGpr6p7RaQZzpVBd/fxMs60dfsCKccSQTFdcQWsXAk//QTVqnkdjTGmlASaCII96Nyn7oTnGcA9qpoqIq/hzB06V5x6t8WqeleQ4whf8fHwv//Byy9bEjDG5CqoiUBVe+ey7NxgbtP4UYXHHoPGjeHuu72OxhgTosrEMNSmiL75xmlwmjQJoqK8jsYYE6JsiInyKisLHn8cWraE227zOhpjTAizK4Ly6vPPYcUKeOcdp+uZMcbkwa4IyqPMTHjiCWjbFoYN8zoaY0yIsyuC8uiDD2D9evj4Y+dmFGOMyYddEZQ3GRnw1FPQqRPccIPX0RhjygC7Iihvpk51bhz76iuIsDxvjCmYHSnKkxMnnIGpYmJgwACvozHGlBF2RVCeTJoEu3Y5Q9d6MVqiMaZMsiuC8uLIEXjuOejfH/r18zoaY0wZYomgvJgwAfbtg2ef9ToSY0wZY4mgPEhNhRdfhGuvhW7dvI7GGFPGWCIoD8aPd5LBuHFeR2KMKYMsEZR1e/fCK6/ATTfBxRd7HY0xpgyyRFDWvfACHD8OTz/tdSTGmDLKEkFZtmsXTJwIt94Kbdp4HY0xpoyyRFCWPfOMM9z02LFeR2KMKcMsEZRVP/0Eb78Nd97pTEhvjDFFZImgrHr6aahQwZmK0hhjisESQVm0fj28/z7ccw+cc47X0RhjyjhLBGXR2LFQtSo88ojXkRhjygFLBGXNihXOhDNjxkDdul5HY4wpBywRlDVPPAG1a8Of/+x1JMaYcsISQVmSkOBMOPPQQ1CzptfRGGPKiaAmAhG5X0TWiMhaEXnAXXaj+zpLRKKDuf1y57HHoH59uO8+ryMxxpQjQUsEItIeuBPoClwMDBSRc4E1wA3Ad8HadrkUGwvz5sGjj8JZZ3kdjTGmHAnmFUFbIFFVj6nqKWA+cIOqrlfVDUHcbvmjCo8/Dk2awJ/+5HU0xphyJpiJYA3QW0TqiEhV4BqgaaAfFpGRIpIkIkn79u0LWpBlwldfweLF8OSTEBXldTTGmHImaIlAVdcDLwBzgG+BZCCzEJ+frKrRqhpdr169IEVZBmRlOVcDrVvDiBFeR2OMKYeC2lisqlNUtYuq9gEOAhuDub1y6ZNPYOVKeOopqFjR62iMMeVQhWAWLiL1VXWviDTDaSDuHsztlTunTjnVQe3awc03ex2NMaacCmoiAD4VkTpABnCPqqaKyG+BV4F6wFcikqyqVwU5jrLp/fdhwwb49FOIjPQ6GmNMOSWq6nUMBYqOjtakpCSvwyhd6elwwQVQpw4sXQoiXkdkjCljRGSZqhZ4v1awrwhMUU2ZAlu3whtvWBIwxgSVDTERio4fd2Yf69ULrrJaM2NMcNkVQSh6/XX4+Wf44AO7GjDGBF2BVwTi+IOIPOm+biYiXYMfWpg6fBiefx6uuAIuvdTraIwxYSCQqqHXgRggu//iYWBi0CIKd6+8Ar/84lQNGWNMKQikaqibqnYWkRUAqnpQRCoFOa7wdOAAjB8PgwZBV7voMsaUjkCuCDJEJBJQABGpB2QFNapwNX68UzU0bpzXkRhjwkggiWAC8DlQX0SeBRYAzwU1qnC0Zw/8618wdCh06OB1NMaYMFJg1ZCqzhCRZUB/QIDr3QHlTEn6+9/h5ElnTCFjjClFBSYCETkb2AvM9FtWUVUzghlYWNmxw7lxbPhwOP98r6MxxoSZQKqGlgP7cEYO3eQ+3yoiy0WkSzCDCxvjxjmTzzz5pNeRGGPCUCCJYC5wjarWVdU6wADgS2AUTtdSUxw//ghTpzozjzVv7nU0xpgwFEgi6K6q/81+oapzgBhVXQxUDlpk4eLpp6FSJWcuYmOM8UAgiSBFRB4Wkebu4yFgj9ul1LqRFsfatTBjBtx7LzRq5HU0xpgwFUgi+D3QBJjlPpq5yyKBm4IXWhh48kmoVg0eftjrSIwxYSyQ7qO/APfl8faPJRtOGFm2DD77DMaOdeYcMMYYjwTSfbQe8BBwIRCVvVxVLwtiXOXf44/D2WfD//2f15EYY8JcIFVDM4AfgJbA08BWYGkQYyr/FiyAb791qoRq1PA6GmNMmAskEdRR1SlAhqrOV9XbAbsaKCpV52qgQQOnkdgYYzwWyOij2XcQp4jIb4CfgbODF1I597//wfz5MGECVK3qdTTGGBNQInhGRGoCfwZeBWoADwQ1qvJKFR57DJo1g5EjvY7GGGOAwBLBQVVNA9KAfgAi0jOoUZVXX3wBS5fC229DZbsXzxgTGgJpI3g1wGUmP1lZ8MQTcN55zuByxhgTIvK8IhCRGKAHUE9E/Ps41sC5maxAInI/cCfO8NVvqeor7mimHwItcHog3aSqB4sUfVny0UewerUzIX2FQC7EjDGmdOR3RVAJqIaTLKr7PQ4BQwoqWETa4ySBrsDFwEARORd4BIhV1fOAWPd1+fb993DffdCqFfzud15HY4wxp8nz1FRV5wPzRWS6qm4rQtltgURVPQYgIvOBG4BBQF93nXeAeKD8jrGQkAD9+0NGBhw6BImJEBPjdVTGGOMTSBtBZRGZLCJzRCQu+xHA59YAvUWkjohUBa4BmgINVDXFXWc30CC3D4vISBFJEpGkffv2BfK7hKb4eCcJAGRmOq+NMSaEBFJZ/TEwCXgbyAy0YFVdLyIvAHOAo0Byzs+rqoqI5vH5ycBkgOjo6FzXKRM6dnR+ijjDTfft62k4xhiTUyCJ4JSqvlGUwt07kqcAiMhzwE6cIawbqWqKiDTCmQaz/Dp61Pn5pz/BrbdatZAxJuQEkgj+IyKjgM+Bk9kLVfVAQR8UkfqquldEmuG0D3THGbNoOPC8+3N2UQIvM+LioHp1ePVV6y1kjAlJgRyZsju9/8VvmQKtAvjspyJSB2eYintUNVVEngc+EpE/Atso73MaxMZCnz6WBIwxISuQ+QhaFrVwVe2dy7L9QP+illmm7NwJGzc61ULGGBOiCuw1JCJVReRxEZnsvj5PRAYGP7RyIM7tXNU/PPKeMaZsCqT76DQgHecuY4BdwDNBi6g8iYuDunWhQwevIzHGmDwFkghaq+o/cIejdm8Qk6BGVR6oOomgXz+ICGQ3G2OMNwI5QqWLSBWcBmJEpDV+vYdMHn78EXbsgMtsDh9jTGgLpCvLWOBboKmIzAB6AiOCGVS5kN0+YInAGBPiAuk1NFdEluPcAyDA/ar6S9AjK+tiY6FJE2fYaWOMCWGB9Br6Lc7dxV+p6pfAKRG5PvihlWFZWTBvnnM1INacYowJbYG0EYx1ZygDQFVTcaqLTF7WrIFffrFuo8aYMiGQRJDbOnabbH5iY52f/fp5G4cxxgQgkESQJCIvi0hr9/EysCzYgZVpcXFO20DTpl5HYowxBQokEdyHc0PZh8C/gRPAPcEMqkw7dQrmz7dqIWNMmZFvFY+IRAJPq+qDpRRP2ZeUBIcPW7dRY0yZke8VgapmAr1KKZbywdoHjDFlTCCNvitE5AucmcqOZi9U1c+CFlVZFhcHF1/sjDFkjDFlQCCJIArYD/jXdShgiSCnEydg4UIYNcrrSIwx5UBfd2rb+CDPdR7IncW3BTWC8mTRIjh50hqKjTFlSiB3Fp8vIrEissZ9fZGIPB780MqguDiIjITeZ8zHY/z07dvXd6ZjQoP9TcJbIN1H3wL+yq/DUK8ChgYzqDIrNha6doUaNbyOxBhjAhZIIqiqqktyLDsVjGDKtEOHYOnSkO42amd9v7J9EZpC5e8SKnGUlkASwS/uHATZ8xEMAVKCGlVZ9P33kJlp7QPGmDInkF5D9wCTgTYisgvYAgwLalRlUWwsVK4MMTFeR2KMMYUSSK+hn4DLReQsIEJVDwc/rDIoLg569oSoKK8jMWVIaXUPNCY/eVYNiUg3EVkpIkdEJAFoZkkgD/v2wcqVVi1kjCmT8msjmAg8CNQBXgZeKZWIyqLss7kQbig2xpi85JcIIlR1rqqeVNWPgXqFLVxExojIWhFZIyIzRSRKRC4TkeXusndEpOzPbRAbC9WrQ3S015EYY0yh5ZcIaonIDdmPXF7nS0QaA6OBaFVtD0QCvwfeAYa6y7YBw4v/a3gsLg4uvRQqlP2cZowJHSdPniQ5OZndu3cHdTv5JYL5wLV+D//XAwMsvwJQxT3rr4ozaF26qm50358LDC5C3KFjxw7YtMmqhYwxJW7btm2kpaUxbty4oG4nz1PY4o4xpKq7RGQ8sB04DswBPgL+ISLRqpoEDAFyncZLREYCIwGaNWtWnFCCKy7O+WkNxcaYEpKRkcHcuXN9VwLTpk3jiSeeoGHDhkHZXiA3lBWJiNQGBgEtgXOAs3DuPxgK/FNElgCHgczcPq+qk1U1WlWj69UrdPNE6YmLc4acbt8+z1XC7S5FY0zhHD9+nPj4eMaNG8cVV1xB7dq1+c1vfoOqApCZmRnUq4KgJQLgcmCLqu5T1QycYat7qGqCqvZW1a7Ad8DGfEsJZapOQ/Fll0FEMHelMaY8SUtL4+uvv+aRRx6hZ8+e1KxZk379+jF27Fj27t3LjTfeSMWKFX3rp6enM23atKC1FQTz6LUd6C4iVUVEgP7AehGpDyAilYGHgUlBjCG4Nm2CXbusfcAYk6/du3fz8ccfM3r0aDp16uQ743/ppZfIysrigQce4D//+Q/79+9n5cqVVKlSBeew+atgXhUE1M1FRHoALfzXV9V38/uMqiaKyCfAcpxB6lbgDFXxjIgMxElCb6hqXNFCDwHZ7QOWCIwxLlVl69atfPfdd3z//fd89913bNq0CYAqVaoQExPD2LFj6d27N926deOss846o4yEhATS09NPW5aens6iRYuCEnOBiUBE3gNaA8n8Wp+vQL6JAEBVxwJjcyz+i/so+2JjoWlTOPdcryMxxngkKyuLdevW+Q7633//Pbt27QKgVq1a9O7dmzvvvJM+ffrQuXPn06p88rJixQoghGYoA6KBdprdamEcWVkwbx4MHAg5LuGMMWXbyZMnWb9+Pbt37z6jp05GRgYrVqzwHfgXLFjAgQMHADjnnHPo3bs3ffr0oXfv3lx44YVElIH2w0ASwRqgITb09OlWrYL9+63bqDHlkH///fHjx5OYmOg7209ISODo0aMAnHvuuVx//fX07t2b3r1706pVqzPq9suCQBJBXWCd293zZPZCVb0uaFGVBdntA/36eRuHMaZEbdy40dc7Z9KkSUyePJlTp04hInTo0IHbbrvNd+Bv1KiRx9GWjEASwVPBDqJMiouD88+HJk28jsQYUwyHDx9mwYIFxMfHM2/ePJYuXep7T1Vp3749zzzzDD169KB27doeRho8gcxHML80AilTMjJg/ny45RavIzHGFNKRI0dYuHAh8+bNIz4+nqSkJDIzM6lYsSKdOnWiQoUKnDrlzMarqmzYsIEuXbqU2yQA+c9HsMD9eVhEDvk9DovIodILMQQlJcGRI9Zt1Jgy4OjRo8ydO5dHH33Ud1Z/9dVX89JLLxEZGckjjzzC3LlzSU1NpUuXLmc07gb7rt5QkN9YQ73cn9VLL5wyIjbW+WntA8aEnGPHjrFo0SJfVc+SJUs4deoUFSpU4JJLLuEvf/kL/fr1o0ePHmf04S/t/vuhwsZNLoq4OOjYEerU8ToSY8Le8ePHSUhI8FX1JCYmkpGRQWRkJNHR0Tz44IP07duXnj17Uq1atXzLKu3++6HCEkFhHT8OixbBvfd6HYkxYenEiRMsXrzYd+BfvHgx6enpREREEB0dzZgxY+jbty+9evWienWr0AiEJYLCWrQITp609gFjgiC3G7lOnjzJ4sWLfVU9ixcv5uTJk0RERNC5c2dGjx5Nv3796NWrFzVq1PD4NyhZpXVFEsgQE/cB76vqwVKIJ/TFxTkzkfXu7XUkxpQ72Tdy3X333XTq1In4+HgSEhI4ceIEIkKnTp249957fWf8tWrV8jrkciGQK4IGwFIRWQ5MBf4b1sNNxMZC167OHMXGmGLbtWsXS5YsITY2lpQUZwCDWbNmMWvWLDp16sTdd99N37596dOnjx34gySQ+wgeF5EngCuB24DXROQjYIqqbg52gCElLQ2WLoVHH/U6EmPKpMOHD7Ns2TISExNJTExkyZIlvgHa/IdmqFChArfeeitTpkzxKtSwElAbgaqqiOwGduMMKV0b+ERE5qrqQ8EMMKR8950z2JyNL2RMgU6dOsXatWtPO+ivW7eOrKwsAFq3bs2ll15K165dad26NTfeeCMnTpzwfXbmzJk8++yzQZue0fwqkDaC+4FbgV+At4G/qGqGiEQAm4DwSQRxcRAVBd27ex2JMSFFVdmxY4fvgJ+YmMiyZcs4duwYAGeffTbdunVj8ODBdOvWja5du1LHr/v1qFGjfAkiW/aNXBMnTizV3yUcBXJFcDZwg6pu81+oqlnuBDPhIy4OevZ0koExYSwtLY2lS5f6DvqJiYns2bMHgMqVK9OpUyfuuOMOunXrRrdu3QoclTNcb+QKFYEkgm+AA9kvRKQG0FZVE1V1fdAiCzV79zpDTz/3nNeRGFPiChp/f9WqVaed7f/www++988//3yuvPJK35n+xRdfTKVKlQq1/XC9kStUBJII3gA6+70+ksuy8i/7i2n3D5hyKLvb5t/+9jcefPDB0870V6xY4au7r1evHt26dWPYsGF07dqVSy65pFwPxhYuAkkE4t9d1K0SCr8b0WJjoUYN6NLF60iMKTFpaWl88803vvH333jjDd544w0AoqKi6NKlC6NGjaJr165069aN5s2bl8mJV0z+Ajmg/yQio3GuAgBGAT8FL6QQFRcHl17q3ExmTBmUlZXF+vXrWbx4MQkJCSxevJh169bhf1tQREQEvXr14pVXXqF9+/YBza9ryr5Ajmp3AROAx3EmrY8FRgYzqJCzfTv8+CPcc4/XkRgTsAMHDpCYmOg76CcmJnLokDOCfO3atenevTsDBgxgwoQJvobarKwsli5dSqNGjSwJhJFAbijbCwwthVhKXIk1PGVPS2n3D5gQld1nP/ugv3jxYjZs2AA4Z/kdOnTg5ptvJiYmhu7du3PeeecRERHBqFGjzijLum2Gn0DuI4gC/ghcCPj6Tarq7UGMK7TExUG9enDhhV5HYgwAe/c1ZuNwAAAgAElEQVTuPe1sf8mSJb4J1evVq0dMTAzDhw+ne/fuXHLJJXkOv2zdNnMXbr2WAqkaeg/4AbgK+BswDAio26iIjAHuwKlSWo0zREVP4EWc2dGOACNU9cdCR15aVJ2G4ssug4g8J3QzJmiyu29mH/QTEhL46Senma5ChQp07NiR2267je7duxMTE0PLli0DbtC1bpsGAksE56rqjSIySFXfEZEPgO8L+pCINAZGA+1U9bg7PtFQ4FFgkKquF5FROG0PI4r+KwTZxo3w88/WbdQERW7991NSUk476CclJfm6bzZq1IiYmBjuvvtuunfvTufOnalataqXv4IpBwJJBBnuz1QRaY8z3lD9QpRfRUQygKrAzzhXB9mDhtd0l4Wu7GkpLRGYIMjuvz9kyBAaN27M4sWL2b59OwCVKlWic+fOvoN+9+7dadq0qXXfNCUukEQwWURq45y5fwFUA54o6EOquktExgPbgePAHFWdIyJ3AF+LyHHgEBDaA/fExUGzZtC6tdeRmHLgwIEDLFq0iIULFxIXF+cbdnnhwoU0btyYXr16MWbMGGJiYujYsSOVK1f2OGITDvJNBO7AcofcSWm+A1oFWrCbPAYBLYFU4GMR+QNwA3CNqiaKyF+Al3HaEXJ+fiRuN9VmzZoFutmSlZUF8+bBddeBnYWZQlJVNm/ezMKFC1mwYAELFy5k/Xqnea1ixYqn3ZFbqVIlBg0aZD11jCfyTQTuXcQPAR8VoezLgS2qug9ARD7DaSi+WFUT3XU+BL7NY9uTgckA0dHR3kyEs3IlHDhg3UZNQNLT01mxYoXvwL9o0SLfQGy1atWiR48e/OEPf6BXr140adKEC/16oaWnpzNt2jSeeOIJG3bZlLpAqob+JyIP4hy0j2YvVNUDeX8EcKqEuotIVZyqof5AEnCjiJyvqhuBKwiwB5Insu8f6NfP2zhMSDp48CAJCQm+s/0lS5b4GnVbtWrFlVdeSa9evejZsydt27Ylwq/XmQ27bEJJIIngd+5P/9tqlQKqidyqn0+A5TiT2azAOcPfCXwqIlnAQSB070eIjYULLoDGjb2OxHhMVdmyZctp1Txr164FnC6cnTp14q677qJXr1706NGDRo0a5Vue9d83oSSQO4tbFrVwVR0LjM2x+HP3EdoyMpwZyYYP9zoSEwT5DbsMTt/95ORk30F/4cKFvoHZatasSUxMDDfffDM9e/aka9euhe7Caf33TSgJ5M7iW3Nbrqrvlnw4IWTJEjh61LqNllPZ3Tazq2JSU1NJSEjwHfSXLFnim12rRYsW9O/f31fNc+GFF55WzWNMWRdI1dAlfs+jcOr6lwPlOxHExTk9hdwzNlNyCjobL2mqyvHjx0lLSyMtLY3Nmzf7zu7ffPNN4uLi2LBhA6pKZGQkHTt25I477vAd+M8555ygx2iMlwKpGrrP/7WI1AL+HbSIQkVcHHTsCH7zqpqSkfNsPD9ZWVkcPnyYQ4cO+Q7k2Y/CLDt16lSu5WdmZnLkyBGeeuopevXqRdeuXfMcl8eY8qoog+sfxbk3oPw6dgwWLYLRo72OpFxQVQ4ePEhKSgpr1qzxnY1PnjwZcA7GeR3MDx8+fNp4+bmJjIykZs2a1KhRg5o1a1KzZk2aNm1K+/btz1ielZXFmDFjTmuo3b9/PyNHjrRumyZsBdJG8B+cXkLgDBTXjqLdV1B2LFoE6enWPlCAjIwM9uzZw+7du0lJSSElJSXX57t37z6jhww4QydPmjSJunXrnnbAbtCgge/A7X8Q93/4L69atWrAwy7YsMvGnCmQK4Lxfs9PAdtUdWeQ4gkNsbHOTGS9e5dIcaVdJ17cOA4fPhzQwf2XX37J9Wy9Tp06NGrUiEaNGnH++ef7nleuXJkHHnjgtKRQuXJlVq5cWWr7xbptGnOmQBLBdiBFVU8AiEgVEWmhqluDGpmX4uKgWzcoobri7Drxhx9+mGeffbZEyiyKn376ibS0NO68804GDx6c50E+e1x7fxUrVqRhw4Y0bNiQli1b0qNHDxo2bOg7yGc/b9CgAZUqVcp1+6FwNm7dNo05UyCJ4GOgh9/rTHfZJbmvXsalpUFSEjz2WLGKUVWSkpKYMGGCb2Cxd999l3ff9b6z1ZdffsmXX34JQPXq1X0H8y5dupxxYM9+fvbZZxe7y6SdjZuCWGL2RiCJoIKq+v57VTVdRHI/5SsP5s93Bpsr4vhCv/zyC++//z5Tp05l9erVREZG+t6LjIykd+/eDBs2rKSiDdj777/P/PnzAefs/qabbuLNN9/krLPOKrUY7GzcmNAUSCLYJyLXqeoXACIyCPgluGF5KC4OoqKge+CjY2dmZjJ37lymTp3KrFmzyMjIoGvXrrzwwguMHTuWzMxM33qJiYnMnDmzVNsKUlJSuO++X3sBZ2Rk8NlnnzF+/PhSTQTGmNAUyLX+XcCjIrJdRLYDDwN/Cm5YHoqNhV69IIBx4Lds2cKTTz5Jy5YtGTBgAHFxcdxzzz2sWrWKxMREtm7dmufAYqVp3LhxIRGHMSY0BXJD2WacUUSrua+PBD0qr+zZA2vWQD5VN8ePH+fzzz9nypQpxMXFISJcddVVvPzyy1x77bWnTSQSKnXioRKHMSY0BXIfwXPAP1Q11X1dG/izqj4e7OBKXXaddS73DyxfvpwpU6bwwQcfkJqaSsuWLRk3bhzDhw+nadOmuRYXKnXioRKHMSY0BdJGMEBVH81+oaoHReQanKkry5fYWKhZEzp3BpxpBWfMmMHUqVNJTk4mKiqKwYMHc/vtt9O3b18beMwYUy4EkggiRaSyqp4E5z4CoHxOpBoXR1afPsTOm8fUqVP5/PPPOXnyJJ07d2bixIncfPPNp00vaIwx5UEgiWAGECsi09zXt1EORx7dtnAh0zdvZtqBA2z7z3+oXbs2I0eO5Pbbb6djx45eh2eMMUETSGPxCyKyEmcOYoBxqvrf4IZVOk6cOMHs2bOZMmUK//vf/wC4vE0bXrj/fgYNGkRUVJTHERpjTPAFNPqoqn6LO8m8iPQSkYmqek8BHwtZK1euZMqUKcyYMYMDBw7QvHlzxrZvz4iff6b5woXOPATGGBMmAkoEItIJuBm4CdgCfBbMoEqK/yBrUVFRfPDBB0ydOpVly5ZRqVIlfvvb3/LHP/6R/pddRkTTpnDFFZYEjDFhJ89EICLn4xz8b8a5k/hDQFS1XynFVmzZg7316dOHHTt2cOLECS6++GImTJjAsGHDOPvss50Vf/gBUlJs2GljTFjK74rgB+B7YKCq/gggImNKJaoSkD2iJsCmTZsYMWIE9913H506dTpz7PrYWOenJQJjTBjKryP8DUAKME9E3hKR/kCZqTfxHz6hUqVKVK1alc6dO+c+gUlcHDRvDq1alWKExhgTGvJMBKo6S1WHAm2AecADQH0ReUNEriytAIsiJSWFadOm+V6np6czbdo03xSJp8nMhHnznKsBax8wxoShAm+NVdWjqvqBql4LNAFW4Aw8F7IKNcjaypVw8GCRh502pjyIj4+3oUfCWKHGSFDVg6o6WVUDOmqKyBgRWSsia0RkpohEicj3IpLsPn4WkVlFCz1vhRpkLS7O+dmvzLSBG2NMiQqo+2hRiEhjYDTQTlWPi8hHwFBV7e23zqfA7JLedqEGWYuNhbZt4ZxzSjoMY4wpE4I9aloFoIqIVACqAj9nvyEiNYDLgBK/IghYejp8/731FjLGhLWgJQJV3QWMB7bj9D5KU9U5fqtcD8Sq6qHcPi8iI0UkSUSS9u3bF5wglyyBo0ctERhjwlrQEoE7b8EgoCVwDnCWiPzBb5WbgZl5fd5ti4hW1eh69eoFJ8i4OKenkFuFZIwx4SiYVUOXA1tUdZ+qZuAMS9EDQETqAl2Br4K4/YLFxkKnTpB9h7ExxoShYCaC7ThTXFYV5y6u/sB6970hwJeqeiKI28/fsWOQkGDdRo0xYS+YbQSJwCfAcmC1u63J7ttDyadaqFQsXAgZGdY+YIwJe0HrPgqgqmOBsbks7xvM7QYkNhYqVIBevbyOxBhjPBXURBDS4uKge3eoVs3rSEwYs7t5TSgIz0SQmgrLlsHjj3sdiTElKiMjg507d3LihHfNb6b0RUVF0aRJEypWrFikz4dnIpg/H7KyrKHYlDs7d+6kevXqtGjRIveRdk25o6rs37+fnTt30rJlyyKVEew7i0NTXBxUqQLdunkdiTEl6sSJE9SpU8eSQBgREerUqVOsq8DwTASxsU4jceXKXkdiTImzJBB+ivs3D79EsGcPrF1r1ULGGOMKv0SQPey03T9gTNDMmjULEeGHH34ocN3p06fz88++8Si54447WLduXbFj6Nu3L0lJScUuJ1CTJk3i3XffLbXtlaTwTAQ1a0Lnzl5HYkxoSEiAv//d+VlCZs6cSa9evZg5s+D7RnMmgrfffpt27dqVWCwlRVXPmPDK31133cWtt95aihGVnPDrNRQb6wwyFxnpdSTGBNcDD0Bycv7rpKXBqlVOL7qICLjoIudEKS8dO8Irr+Rb5JEjR1iwYAHz5s3j2muv5emnn/a998ILL/D+++8TERHBgAEDiI6OJikpiWHDhlGlShUSEhIYMGAA48ePJykpic2bN/Piiy8CTsJISkritdde4/3332fChAmkp6fTrVs3Xn/9dSID+J/OzMzkkUceIT4+npMnT3LPPffwpz/9iSNHjjBo0CAOHjxIRkYGzzzzDIMGDWLr1q1cddVVdOvWjWXLlvH1119z4YUXcv/99/Pll19SpUoVZs+eTYMGDXjqqaeoVq0aDz74IH379qVbt27MmzeP1NRUpkyZQu/evTl27BgjRoxgzZo1XHDBBfz8889MnDiR6OjoAmMPpvC6ItiyxXlYtZAxjrQ0JwmA8zMtrdhFzp49m6uvvprzzz+fOnXqsGzZMgC++eYbZs+eTWJiIitXruShhx5iyJAhREdHM2PGDJKTk6lSpYqvnMGDB/P555/7Xn/44YcMHTqU9evX8+GHH7Jw4UKSk5OJjIxkxowZAcU2ZcoUatasydKlS1m6dClvvfUWW7ZsISoqis8//5zly5czb948/vznP6OqAGzatIlRo0axdu1amjdvztGjR+nevTsrV66kT58+vPXWW7lu69SpUyxZsoRXXnnFlwxff/11ateuzbp16xg3bpxv33gtvK4I5s1zflpDsQkHBZy5A78OvJieDpUqwYwZEBNTrM3OnDmT+++/H4ChQ4cyc+ZMunTpwv/+9z9uu+02qlatCsDZBYz6W69ePVq1asXixYs577zz+OGHH+jZsycTJ05k2bJlXHLJJQAcP36c+vXrBxTbnDlzWLVqFZ988gkAaWlpbNq0iSZNmvDoo4/y3XffERERwa5du9izZw8AzZs3p3v37r4yKlWqxMCBAwHo0qULc+fOzXVbN9xwg2+drVu3ArBgwQLfvmnfvj0XXXRRQHEHW3glgthYaNAAQrD+0RhPxMQ4/xfx8U6VaTGTwIEDB4iLi2P16tWICJmZmYiIr3qnsIYOHcpHH31EmzZt+O1vf4uIoKoMHz6cv//974UuT1V59dVXueqqq05bPn36dPbt28eyZcuoWLEiLVq08PXLP+uss05bt2LFir7umpGRkZw6dSrXbVV2u6fnt06oCJ+qIVWnofiyy5zJaIwxjpgY+Otfi50EAD755BNuueUWtm3bxtatW9mxYwctW7bk+++/54orrmDatGkcO3YMcJIGQPXq1Tl8+HCu5f32t79l9uzZzJw5k6FDhwLQv39/PvnkE/bu3esrZ9u2bQHFd9VVV/HGG2+QkZEBwMaNGzl69ChpaWnUr1+fihUrMm/evIDLK6yePXvy0UcfAbBu3TpWr14dlO0UVvhcEaxfD7t3W/uAMUE0c+ZMHn744dOWDR48mJkzZ/LGG2+QnJxMdHQ0lSpV4pprruG5555jxIgR3HXXXb7GYn+1a9embdu2rFu3jq5duwLQrl07nnnmGa688kqysrKoWLEiEydOpHnz5mfE85vf/MY3/k5MTAwffvghW7dupXPnzqgq9erVY9asWQwbNoxrr72WDh06EB0dTZs2bYKyf0aNGsXw4cNp164dbdq04cILL6Rmfo3zpUSyG0RCWXR0tBalP3BfdwrK+Ph4eO01uO8+2LwZWrUq2QALE4eHLI7QiiEY1q9fT9u2bb0Ow+QhMzOTjIwMoqKi2Lx5M5dffjkbNmygUqVKxS47t7+9iCxT1QK7JIXPFUFcHLRoUepJwBhjsh07dox+/fqRkZGBqvL666+XSBIorvBIBJmZTo8htxXfGGO8UL169VK92zlQ4dFYnJzszEFg3UaNMeYM4ZEIYmOdn/36eRuHMcaEoPCoGoqLc+4daNTIk82XtwbJ8sD+Jr8qrw3nJnDlOhHEx8c7d0zWrg233+51OMYYE5LKf9VQYiIcO2b3DxiTh5MnT5KcnMzu3btLpLzIyEg6duxI+/btufbaa0lNTS2Rcrdu3Ur79u1LpCx/GzZsoG/fvnTs2JG2bdsycuTIEt+Gv/j4eN8QFV988QXPP/98ULcXiPKfCOLinDuJ3ctfY8zptm3bRlpaGuPGjSuR8qpUqUJycjJr1qzh7LPPZuLEiSVSbrCMHj2aMWPGkJyczPr167nvvvtKbdvXXXcdjzzySKltLy/lumoIcBqKO3d2qoeMCSMPPPAAyQUMQ33y5ElSUlIAZ2KVFStW5NuvvWPHjrwSyGB2rpiYGFatWgWQ71DPAwYMoFevXixatIjGjRsze/ZsqlSpwrJly7jdrda98sorfeWeOHGCu+++m6SkJCpUqMDLL79Mv379mD59OrNmzeLo0aNs2rSJBx98kPT0dN577z0qV67M119/fcZgdykpKTRp0sT3ukOHDoBzBXLLLbdw9OhRAF577TV69OhBfHw8Y8eOpVatWqxevZqbbrqJDh068K9//Yvjx48za9YsWrduzYgRI4iKiiIpKYlDhw7x8ssv+64EsvkPrT1ixAhq1KhBUlISu3fv5h//+AdDhgwhKyuLe++9l7i4OJo2bUrFihW5/fbbGTJkSMB/h4IE9YpARMaIyFoRWSMiM0UkShzPishGEVkvIqODFsDRo7B4sXUbNSYP/mPqqGqJjrGTmZlJbGws1113HUCBQz3fc889rF27llq1avHpp58CcNttt/Hqq6+ycuXK08qeOHEiIsLq1auZOXMmw4cP9w0St2bNGj777DOWLl3KY489RtWqVVmxYgUxMTG5ziA2ZswYLrvsMgYMGMA///lPX1VW/fr1mTt3LsuXL+fDDz9k9OhfD1UrV65k0qRJrF+/nvfee4+NGzeyZMkS7rjjDl599VXfelu3bmXJkiV89dVX3HXXXQVOMJ+SksKCBQv48ssvfVcKn332GVu3bmXdunW89957ZwzDURKCdkUgIo2B0UA7VT0uIh8BQwEBmgJtVDVLRAIbP7YoJk+GjAxo2DBomzCFZ71TSkdBZ+4pKSm08rvTXlU5ePAg//73v2lYjP+Z48eP07FjR3bt2kXbtm254oorfOXnNdRzy5Yt6dixI/DrsM2pqamkpqbSp08fAG655Ra++eYbwBnOObsKp02bNjRv3pyNGzcC0K9fP6pXr0716tWpWbMm1157LeCc6Wdfnfi77bbbuOqqq/j222+ZPXs2b775JitXriQjI4N7773XN+dBdvkAl1xyCY3cXoitW7f2Xa106NCBednD3QM33XQTERERnHfeebRq1arAqTuvv/56IiIiaNeunW/fLFiwgBtvvJGIiAgaNmxIvyB0gw92G0EFoIqIVACqAj8DdwN/U9UsAFXdG5QtJyTAQw85zx97rESn4TOmPBg3btwZUy9mZmYWu60gu41g27ZtqKqvjWDGjBm+oZ6Tk5Np0KCB7ww5e8hmKP6wzf5lRURE+F5HRETkWe4555zD7bffzuzZs6lQoQJr1qzhn//8Jw0aNGDlypUkJSWRnp5e6G1IjpGOc77OL/bSHAcuaIlAVXcB44HtQAqQpqpzgNbA70QkSUS+EZHzcvu8iIx010nat29f4QOIj/915qX0dOe1McYnISHhtIMbQHp6OosWLSqR8qtWrcqECRN46aWXOHXqVKGHeq5Vqxa1atViwYIFAKfNQta7d2/f640bN7J9+3YuuOCCIsX57bff+oal3r17N/v376dx48akpaXRqFEjIiIieO+998jMzCx02R9//DFZWVls3ryZn376qUgx9uzZk08//ZSsrCz27NkTlCvqYFYN1QYGAS2BVOBjEfkDUBk4oarRInIDMBXonfPzqjoZmAzO6KOFDqBvX6hc+deZl6zXkDGnWbFiBRDcG8o6derERRddxMyZM4s01PO0adO4/fbbEZHTGotHjRrF3XffTYcOHahQoQLTp08/7Wy6MObMmcP9999PVFQUAC+++CINGzZk1KhRDB48mHfffZerr776jAlqAtGsWTO6du3KoUOHmDRpkm8bhTF48GBiY2Np164dTZs2pXPnziU+dHXQhqEWkRuBq1X1j+7rW4HuwGXAAFXdIs51Uqqq5vtbFXUYahISSmzmJWPKAhuGOnSMGDGCgQMHlkjvniNHjlCtWjX2799P165dWbhw4RntOKE6DPV2oLuIVAWOA/2BJOAQ0A/YAlwKbMyzhOKKibEEYIwp8wYOHEhqairp6ek88cQTxWrMz03QEoGqJorIJ8By4BSwAqeqpwowQ0TGAEeAO4IVgzHGeGX69OklVlawe9oF9YYyVR0LjM2x+CTwm2Bu15hwpqoF9k4x5Utxq/jL/xATxoSRqKgo9u/fX6pdD423VJX9+/cXqSE6W/kfYsKYMNKkSRN27txJkbpcmzIrKirqtGEyCssSgTHlSMWKFWnZsqXXYZgyxqqGjDEmzFkiMMaYMGeJwBhjwlzQ7iwuSSKyDyi58XG9URf4xesgQojtj1/Zvjid7Y/TFWd/NFfVegWtVCYSQXkgIkmB3OodLmx//Mr2xelsf5yuNPaHVQ0ZY0yYs0RgjDFhzhJB6ZnsdQAhxvbHr2xfnM72x+mCvj+sjcAYY8KcXREYY0yYs0RgjDFhzhJBkIlIUxGZJyLrRGStiNzvdUxeE5FIEVkhIl96HYvXRKSWiHwiIj+IyHoRCduZlERkjPs/skZEZopI0YfTLINEZKqI7BWRNX7LzhaRuSKyyf1ZOxjbtkQQfKeAP6tqO5ypOu8RkXYex+S1+4H1XgcRIv4FfKuqbYCLCdP9IiKNgdFAtKq2ByKBod5GVeqmA1fnWPYIEKuq5wGx7usSZ4kgyFQ1RVWXu88P4/yjN/Y2Ku+ISBOciYne9joWr4lITaAPMAVAVdNVNdXbqDxVAagiIhWAqsDPHsdTqlT1O+BAjsWDgHfc5+8A1wdj25YISpGItAA6AYneRuKpV4CHgCyvAwkBLYF9wDS3quxtETnL66C8oKq7gPE4c52nAGmqOsfbqEJCA1VNcZ/vBhoEYyOWCEqJiFQDPgUeUNVDXsfjBREZCOxV1WVexxIiKgCdgTdUtRNwlCBd+oc6t+57EE5yPAc4S0T+4G1UoUWdvv5B6e9viaAUiEhFnCQwQ1U/8zoeD/UErhORrcC/gctE5H1vQ/LUTmCnqmZfIX6CkxjC0eXAFlXdp6oZwGdAD49jCgV7RKQRgPtzbzA2YokgyMSZRXwKsF5VX/Y6Hi+p6l9VtYmqtsBpCIxT1bA961PV3cAOEbnAXdQfWOdhSF7aDnQXkaru/0x/wrThPIcvgOHu8+HA7GBsxBJB8PUEbsE5+012H9d4HZQJGfcBM0RkFdAReM7jeDzhXhV9AiwHVuMcm8JqqAkRmQkkABeIyE4R+SPwPHCFiGzCuWp6PijbtiEmjDEmvNkVgTHGhDlLBMYYE+YsERhjTJizRGCMMWHOEoExxoQ5SwSm2EREReQlv9cPishTJVT2dBEZUhJlFbCdG93RP+eVQFlfi0itAtYZISLnFHdbJUFErhORQt3RLCJbRaRusGIypcsSgSkJJ4EbQu3A4A5eFqg/Aneqar/ibldVrwlg8LgROEMpeEpEKqjqF6oalP7ppmywRGBKwimcm3/G5Hwj5xm9iBxxf/YVkfkiMltEfhKR50VkmIgsEZHVItLar5jLRSRJRDa64xVlz2nwoogsFZFVIvInv3K/F5EvyOUuXRG52S1/jYi84C57EugFTBGRF3Os31dEvhORr0Rkg4hMEpGIvMpyl28Vkboi0sK9ynjLHWd/johUcfdHNM6NZMnusufdOStWicj4XOKu435+rTs43Ta/bfiPX++7GhOR1iLyrYgsc/dJG7+/ySQRSQT+4V6dvOa+V09EPnX361IR6Znb9gHJ47tgyiJVtYc9ivUAjgA1gK1ATeBB4Cn3venAEP913Z99gVSgEVAZ2AU87b53P/CK3+e/xTlpOQ9nfJ4oYCTwuLtOZSAJZ8CyvjiDt7XMJc5zcIYyqIcz4FsccL37XjzOWPg5P9MXOAG0whkjfy4wpICytgJ1gRY4SbKju/wj4A85twfUATbw6w2etXKJYwLwpPv8NziDj2VvY43fev77PhY4z33eDWdIj+x9+iUQ6b4eAbzmPv8A6OU+b4YzNEqe2/f6u2ePknkU5tLZmDyp6iEReRdncpHjAX5sqbpD7IrIZiB72OHVgH8VzUeqmgVsEpGfgDbAlcBFflcbNXESRTqwRFW35LK9S4B4Vd3nbnMGznwAswqIc4mq/uR+ZibO1UNGgGVtUdVk9/kynAN3Tmk4yWaKOLO25TZzWx/gBgBV/UpEDuYXsDij3fYAPnaG7gGchJntY1XNzOWjlwPt/D5Twy2rUNs3ZYslAlOSXsEZK2aa37JTuFWQbpVKJb/3Tvo9z/J7ncXp382c46AoTtXEfar6X/83RKQvzhVBScpt+4Hy/x0zgSpnFK56SkS64gy0NrUpfOoAAAGNSURBVAS4F7gswPJ9+9eVPb1jBJCqqh3z+Fxe+ygC6K6qJ/wX+iUGUw5ZG4EpMap6AKf6449+i7cCXdzn1wEVi1D0jSIS4bYbtMKpRvkvcLc4Q3wjIudLwZO6LAEudevWI4GbgfkBbL+riLR0E9nvgAXFKCvbYaC6G3s1oKaqfo3TznJxLut/B/zeXX8AkD137R6gvluHXxkYCM4VGrBFRG50PyMiklu5Oc3BGQgP93PZiSSv7ZtywBKBKWkv4dRdZ3sL54C5EoihaGfr23EOvN8Ad7lnq2/jNAYvdxtL36SAK1y3GuoRYB6wElimqoEM67sUeA1nWOQtwOfFKCvbdGCSiCTjJIQvxRmBdAHwf7ms/zTQR0TW4lTRbHd/pwzgbzj7Zy7wg99nhgF/dPf9WpyJXwoyGoh2G63XAXflt31TPtjoo8bkw61qelBVB3odiz9xJveJVtVfvI7FlH12RWCMMWHOrgiMMSbM2RWBMcaEOUsExhgT5iwRGGNMmLNEYIwxYc4SgTHGhLn/B+Tz4cw9LH9dAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plt.scatter()\n",
    "#plt.ylim((60,100))\n",
    "plt.plot([i+1 for i in range(10)],accuracy_active[:10],marker='.',label='Active Learning',c='r')\n",
    "plt.errorbar([i+1 for i in range(10)],mean_random,random_variance,marker='^',label='Random Sampling',c='black')\n",
    "plt.legend(loc='best')\n",
    "plt.xlabel('Number of points queried')\n",
    "plt.ylabel('Accuracy in Percentage')\n",
    "plt.title('Accuracy vs Number of Points Queried')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A few changes that could be observed.\n",
    "* As we increase the number of data points, clearly active learning and random begin competing. Though, in the above plot active learning beats random, it is usually not the case.\n",
    "* Also, it was observed that there is a lot of dependence on the initial way of shuffling the dataset.\n",
    "* Kindly note that there were cases when active learning *failed* to beat random.\n",
    "* Note that the accuracy increasing in random is not *unexpected*. It is, in fact, as expected since ultimately the algorithm gets to see more of the data. This was a uniform trend across all the runs that I have done thus far."
   ]
  }
 ],
 "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}