Classifier.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.ensemble import RandomForestClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "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>time</th>\n",
       "      <th>note</th>\n",
       "      <th>num_smp</th>\n",
       "      <th>duration</th>\n",
       "      <th>num_ep</th>\n",
       "      <th>avg_mag_roc</th>\n",
       "      <th>avg_mag_acc</th>\n",
       "      <th>max_amp</th>\n",
       "      <th>min_amp</th>\n",
       "      <th>num_max</th>\n",
       "      <th>num_min</th>\n",
       "      <th>d_above</th>\n",
       "      <th>d_below</th>\n",
       "      <th>d_inc</th>\n",
       "      <th>d_dec</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.019365</td>\n",
       "      <td>28</td>\n",
       "      <td>170</td>\n",
       "      <td>0.003832</td>\n",
       "      <td>1</td>\n",
       "      <td>214</td>\n",
       "      <td>27</td>\n",
       "      <td>6581</td>\n",
       "      <td>-4000</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>0.001655</td>\n",
       "      <td>0.002177</td>\n",
       "      <td>0.001859</td>\n",
       "      <td>0.001973</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.023175</td>\n",
       "      <td>28</td>\n",
       "      <td>168</td>\n",
       "      <td>0.003787</td>\n",
       "      <td>1</td>\n",
       "      <td>212</td>\n",
       "      <td>23</td>\n",
       "      <td>6731</td>\n",
       "      <td>-3981</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>0.001678</td>\n",
       "      <td>0.002109</td>\n",
       "      <td>0.001905</td>\n",
       "      <td>0.001882</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.026984</td>\n",
       "      <td>28</td>\n",
       "      <td>168</td>\n",
       "      <td>0.003787</td>\n",
       "      <td>1</td>\n",
       "      <td>214</td>\n",
       "      <td>24</td>\n",
       "      <td>7048</td>\n",
       "      <td>-4118</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>0.001655</td>\n",
       "      <td>0.002132</td>\n",
       "      <td>0.001791</td>\n",
       "      <td>0.001995</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.030816</td>\n",
       "      <td>28</td>\n",
       "      <td>168</td>\n",
       "      <td>0.003787</td>\n",
       "      <td>1</td>\n",
       "      <td>210</td>\n",
       "      <td>24</td>\n",
       "      <td>7063</td>\n",
       "      <td>-4264</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>0.001655</td>\n",
       "      <td>0.002132</td>\n",
       "      <td>0.001882</td>\n",
       "      <td>0.001905</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.034626</td>\n",
       "      <td>28</td>\n",
       "      <td>169</td>\n",
       "      <td>0.003810</td>\n",
       "      <td>1</td>\n",
       "      <td>214</td>\n",
       "      <td>22</td>\n",
       "      <td>7383</td>\n",
       "      <td>-4318</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>0.001655</td>\n",
       "      <td>0.002154</td>\n",
       "      <td>0.001927</td>\n",
       "      <td>0.001882</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       time   note   num_smp   duration   num_ep   avg_mag_roc   avg_mag_acc  \\\n",
       "0  0.019365     28       170   0.003832        1           214            27   \n",
       "1  0.023175     28       168   0.003787        1           212            23   \n",
       "2  0.026984     28       168   0.003787        1           214            24   \n",
       "3  0.030816     28       168   0.003787        1           210            24   \n",
       "4  0.034626     28       169   0.003810        1           214            22   \n",
       "\n",
       "    max_amp   min_amp  num_max   num_min   d_above   d_below     d_inc  \\\n",
       "0      6581     -4000        2         2  0.001655  0.002177  0.001859   \n",
       "1      6731     -3981        2         2  0.001678  0.002109  0.001905   \n",
       "2      7048     -4118        2         2  0.001655  0.002132  0.001791   \n",
       "3      7063     -4264        2         2  0.001655  0.002132  0.001882   \n",
       "4      7383     -4318        2         2  0.001655  0.002154  0.001927   \n",
       "\n",
       "      d_dec  \n",
       "0  0.001973  \n",
       "1  0.001882  \n",
       "2  0.001995  \n",
       "3  0.001905  \n",
       "4  0.001882  "
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "contours = pd.read_csv('contours.csv')\n",
    "contours.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "# pandas not trimming spaces automatically is a bit absurd, no?\n",
    "contour_predictors = contours.drop([\"time\", \" note\"], axis=1)\n",
    "contour_results = contours[\" note\"]\n",
    "\n",
    "train_len = len(contours) * 3 // 4\n",
    "train_predictors = contour_predictors[0:train_len]\n",
    "test_predictors = contour_predictors[train_len:]\n",
    "train_results = contour_results[0:train_len]\n",
    "test_results = contour_results[train_len:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.041666666666666664\n"
     ]
    }
   ],
   "source": [
    "print( 1 / 24 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LDA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "lda = LinearDiscriminantAnalysis()\n",
    "model = lda.fit(contour_predictors, contour_results)\n",
    "predictions = model.predict(contour_predictors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15304\n",
      "0.19580348004094167\n"
     ]
    }
   ],
   "source": [
    "num_right = 0\n",
    "for i in range( len(predictions) ):\n",
    "    if(predictions[i] == contours[\" note\"][i]):\n",
    "        num_right += 1\n",
    "        \n",
    "print(num_right)\n",
    "print(num_right / len(contours))\n",
    "\n",
    "num_right_lda = num_right"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "lda = LinearDiscriminantAnalysis()\n",
    "model = lda.fit(train_predictors, train_results)\n",
    "predictions = model.predict(test_predictors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3294\n",
      "0.16857727737973388\n"
     ]
    }
   ],
   "source": [
    "num_right = 0\n",
    "for i in range( len(predictions) ):\n",
    "    if(predictions[i] == test_results.tolist()[i]):\n",
    "        num_right += 1\n",
    "        \n",
    "print(num_right)\n",
    "print(num_right / len(test_results))\n",
    "\n",
    "num_right_lda2 = num_right"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## GNB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "gnb = GaussianNB()\n",
    "model = gnb.fit(contour_predictors, contour_results)\n",
    "predictions = model.predict(contour_predictors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8452\n",
      "0.10813715455475947\n"
     ]
    }
   ],
   "source": [
    "num_right = 0\n",
    "for i in range( len(predictions) ):\n",
    "    if(predictions[i] == contours[\" note\"][i]):\n",
    "        num_right += 1\n",
    "        \n",
    "print(num_right)\n",
    "print(num_right / len(contours))\n",
    "\n",
    "num_right_gnb = num_right"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "gnb = GaussianNB()\n",
    "model = gnb.fit(train_predictors, train_results)\n",
    "predictions = model.predict(test_predictors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1725\n",
      "0.0882804503582395\n"
     ]
    }
   ],
   "source": [
    "num_right = 0\n",
    "for i in range( len(predictions) ):\n",
    "    if(predictions[i] == test_results.tolist()[i]):\n",
    "        num_right += 1\n",
    "        \n",
    "print(num_right)\n",
    "print(num_right / len(test_results))\n",
    "\n",
    "num_right_gnb2 = num_right"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Random Forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "forest = RandomForestClassifier()\n",
    "model = forest.fit(contour_predictors, contour_results)\n",
    "predictions = model.predict(contour_predictors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "78156\n",
      "0.9999488229273286\n"
     ]
    }
   ],
   "source": [
    "num_right = 0\n",
    "for i in range( len(predictions) ):\n",
    "    if(predictions[i] == contours[\" note\"][i]):\n",
    "        num_right += 1\n",
    "        \n",
    "print(num_right)\n",
    "print(num_right / len(contours))\n",
    "\n",
    "num_right_forest = num_right"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "forest = RandomForestClassifier()\n",
    "model = forest.fit(train_predictors, train_results)\n",
    "predictions = model.predict(test_predictors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17342\n",
      "0.8875127942681679\n"
     ]
    }
   ],
   "source": [
    "num_right = 0\n",
    "for i in range( len(predictions) ):\n",
    "    if(predictions[i] == test_results.tolist()[i]):\n",
    "        num_right += 1\n",
    "        \n",
    "print(num_right)\n",
    "print(num_right / len(test_results))\n",
    "\n",
    "num_right_forest2 = num_right"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Linear Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "lm = LinearRegression()\n",
    "lm.fit(contour_predictors, contour_results)\n",
    "\n",
    "coefficients = pd.DataFrame(data={\"predictor\": contour_predictors.columns, \\\n",
    "                                  \"coefficient\": lm.coef_})\n",
    "predictions = lm.predict(contour_predictors)\n",
    "predictions = predictions.round()\n",
    "\n",
    "comment = \"\"\"\n",
    "# coefficient, error, t values\n",
    "MSE = (sum((auto_predictee - predictions) ** 2)) / \\\n",
    "    (len(auto_predictors) - len(auto_predictors.columns) - 1)\n",
    "RSE = math.sqrt(MSE)\n",
    "\n",
    "variance = MSE * (np.linalg.inv(np.dot(auto_predictors.T,auto_predictors)).diagonal())\n",
    "standard_deviation = np.sqrt(variance)\n",
    "\n",
    "results = pd.DataFrame()\n",
    "results[\"predictors\"] = auto_predictors.columns\n",
    "results[\"coefficient\"] = coefficients[\"coefficient\"]\n",
    "results[\"variance\"] = variance\n",
    "results[\"std. error\"] = standard_deviation\n",
    "results[\"t-value\"] = coefficients[\"coefficient\"] / standard_deviation\n",
    "\n",
    "print(\"Mean squared error:\")\n",
    "print(MSE)\n",
    "print(results)\n",
    "\"\"\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "31512\n",
      "0.4031729785056295\n"
     ]
    }
   ],
   "source": [
    "num_right = 0\n",
    "for i in range( len(predictions) ):\n",
    "    if(predictions[i] == contour_results.to_list()[i]):\n",
    "        num_right += 1\n",
    "        \n",
    "print(num_right)\n",
    "print(num_right / len(contours))\n",
    "\n",
    "num_right_lg = num_right"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "lm = LinearRegression()\n",
    "lm.fit(train_predictors, train_results)\n",
    "\n",
    "coefficients = pd.DataFrame(data={\"predictor\": test_predictors.columns, \\\n",
    "                                  \"coefficient\": lm.coef_})\n",
    "predictions = lm.predict(test_predictors)\n",
    "predictions = predictions.round()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7100\n",
      "0.3633572159672467\n"
     ]
    }
   ],
   "source": [
    "num_right = 0\n",
    "for i in range( len(predictions) ):\n",
    "    if(predictions[i] == test_results.tolist()[i]):\n",
    "        num_right += 1\n",
    "        \n",
    "print(num_right)\n",
    "print(num_right / len(test_results))\n",
    "\n",
    "num_right_lg2 = num_right"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Perceptron"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def multiclass_perceptron(examples, targets, num_classes, num_iterations=1, previous_weights = None):\n",
    "    num_examples, num_features = examples.shape\n",
    "    weights = previous_weights\n",
    "    if weights is None:\n",
    "        weights = np.zeros(num_classes * num_features)\n",
    "        weights = weights.reshape(num_classes, num_features)\n",
    "    \n",
    "    for i in range(num_iterations):\n",
    "        for i in range(num_examples):\n",
    "            example = examples[i]\n",
    "            target = targets[i]\n",
    "            predicted = 0\n",
    "            predicted_score = np.dot(example, weights[0])\n",
    "            \n",
    "            # get the dot product of w and each F(X_t,y), and record the highest scoring\n",
    "            for j in range(1, num_classes):\n",
    "                score = np.dot(example, weights[j])\n",
    "                if(score > predicted_score):\n",
    "                    predicted = j\n",
    "                    predicted_score = score\n",
    "            \n",
    "            # if there was a mistake, update weights\n",
    "            if(predicted != target):\n",
    "                weights[target] = weights[target] + example \n",
    "                weights[predicted] = weights[predicted] - example\n",
    "    \n",
    "    return weights\n",
    "\n",
    "def test_multiclass(examples, targets, weights, num_classes):\n",
    "    num_examples = examples.shape[0]\n",
    "    num_correct = 0\n",
    "    \n",
    "    for i in range(num_examples):\n",
    "        example = examples[i]\n",
    "        target = targets[i]\n",
    "        \n",
    "        predicted = 0\n",
    "        predicted_score = np.dot(example, weights[0])\n",
    "\n",
    "        for j in range(1, num_classes):\n",
    "            score = np.dot(example, weights[j])\n",
    "            if(score > predicted_score):\n",
    "                predicted = j\n",
    "                predicted_score = score\n",
    "                    \n",
    "        if target == predicted:\n",
    "            num_correct += 1\n",
    "    \n",
    "    return num_correct"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5649\n",
      "0.07227482088024564\n"
     ]
    }
   ],
   "source": [
    "perceptron_predictors = contour_predictors.to_numpy()\n",
    "perceptron_results = (contour_results - 28).to_numpy()\n",
    "num_classes = 24\n",
    "\n",
    "weights = multiclass_perceptron(perceptron_predictors, perceptron_results, num_classes, num_iterations=10)\n",
    "num_right = test_multiclass(perceptron_predictors, perceptron_results, weights, num_classes)\n",
    "\n",
    "print(num_right)\n",
    "print(num_right / len(contours))\n",
    "num_right_perceptron = num_right"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "195\n",
      "0.009979529170931423\n"
     ]
    }
   ],
   "source": [
    "perceptron_predictors = train_predictors.to_numpy()\n",
    "perceptron_results = (train_results - 28).to_numpy()\n",
    "perceptron_predictors2 = test_predictors.to_numpy()\n",
    "perceptron_results2 = (test_results - 28).to_numpy()\n",
    "num_classes = 24\n",
    "\n",
    "weights = multiclass_perceptron(perceptron_predictors, perceptron_results, num_classes, num_iterations=10)\n",
    "num_right = test_multiclass(perceptron_predictors2, perceptron_results2, weights, num_classes)\n",
    "\n",
    "print(num_right)\n",
    "print(num_right / len(test_predictors))\n",
    "num_right_perceptron2 = num_right"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Perceptron\n",
      "0.07227482088024564\n",
      "0.009979529170931423\n",
      "GNB\n",
      "0.10813715455475947\n",
      "0.0882804503582395\n",
      "Forest\n",
      "0.9999488229273286\n",
      "0.8875127942681679\n",
      "LDA\n",
      "0.19580348004094167\n",
      "0.16857727737973388\n",
      "Linear Regression\n",
      "0.4031729785056295\n",
      "0.3633572159672467\n"
     ]
    }
   ],
   "source": [
    "print(\"Perceptron\")\n",
    "print(num_right_perceptron / len(contours))\n",
    "print(num_right_perceptron2 / len(test_predictors))\n",
    "print(\"GNB\")\n",
    "print(num_right_gnb / len(contours))\n",
    "print(num_right_gnb2 / len(test_predictors))\n",
    "print(\"Forest\")\n",
    "print(num_right_forest / len(contours))\n",
    "print(num_right_forest2 / len(test_predictors))\n",
    "print(\"LDA\")\n",
    "print(num_right_lda / len(contours))\n",
    "print(num_right_lda2 / len(test_predictors))\n",
    "print(\"Linear Regression\")\n",
    "print(num_right_lg / len(contours))\n",
    "print(num_right_lg2 / len(test_predictors))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEiCAYAAAD05tVnAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAmcElEQVR4nO3deZwcVbn/8c+XsIQlCVvgQkICsgjITgSULbIooBBEvBJBDJcfqAiKggrCZVUBQUERxIAaQNlRbkQk7DshC8RAiMHIlgRk34msz++Pc5oUnZ6ZnmSqJ5n6vl+veU1tXf1UdXU/dc6pOqWIwMzMqmuR7g7AzMy6lxOBmVnFORGYmVWcE4GZWcU5EZiZVZwTgZlZxTkR9EBKfi/pJUnjWvi+oyT9qMllH5e0U9kxLcwkDZL0uqReXblsd5I0VNLMbnrvhWIfdYfKJAJJ20i6R9Irkl6UdLekj3d3XCXZBtgZGBgRW9TPlDRCUkg6s276sDx9VIvinG+SfijpsfwFnynp8m6OZ98cy+uSZkt6vzD+emfWFRFPRsQyEfFeVy67ICr8SNf+QtIbhfFt52GdHzrZKHMf5ZOgtyW9lv8eknSKpH7zGm8rVSIRSOoLXAucDSwPDABOBN7qzrhKNBh4PCLeaGeZfwH/LWnRwrSvAo+UGlkXkvRV4CvAThGxDDAEuLk7Y4qIP+Yfm2WAXYGnauN52gd8ZjpH4Ue6uJ82Lky7s1sDbM5PI6IP0B84ANgKuFvS0t0bVscqkQiAdQAi4tKIeC8iZkfEDRExGUDSCZL+UFtY0ur5jGTRPL58rmp5Kle3XFNYdpikSZJelfQvSbvk6f0k/VbS05JmSfpR7YsvaS1Jt+fSyfO1s9hcpXOmpGfz+h6UtEGjDZK0qqTRuXQzXdJBefqBwAXAJ/KZ1Ilt7JN/Aw8Cn6ltI/BJYHTd++whaYqklyXdJmm9wrxNJd2fz4AuB3rXvfZzed+8nEtjG7WxLVtImpC3+RlJP28j5nofB8ZExL8AIuLfETGysN4DJE3N8T0q6WuFeUNzCeL7eX8/LWlPSbtJeiTv1x8Wll9E0lH5M35B0hV5nzUtnzX+WtJ1kt4APiXps5IeyNs+Q9IJheXrj8PbJJ2sVJp9TdINklbs7LJ5/v6Snsjb8r9q52y0yRi/KunJfDwfU5i/ZN7ulyQ9nD+zTpG0hKQz8vqfkXSepCXzvBUlXZuPsRcl3Zk/q4uBQcBf8vfg+2Xuo6KI+E9EjAf2AFYgJQUkrSnplry+5yX9UdKyed5c8ebpV0r6t9JvxR2SPtbZ/deUiOjxf0Bf4AXgQtJZ2nJ1808A/lAYXx0IYNE8/lfgcmA5YDFg+zx9C+AVUjXMIqSSxrp53p+B3wBLAysB44Cv5XmXAsfk1/QGtsnTPwNMBJYFBKwHrNLGNt0BnJtfvwnwHLBDnjcCuKud/TECuAv4MnB5nnZIjvdHwKg8bR3gjbx9iwHfB6YDi+e/J4Dv5Hl7A+8AP8qv3RR4FtgS6EUqbTwOLJHnP046kwe4F/hKHl4G2KoQ62Tgy21sx37Ai8D3SKWBXnXzPwusmffl9sCbwGZ53lDgXeC4HP9BeR9eAvQBPgbMBtbIy38bGAsMBJbI++rSDo67ocDMwviofLxsXfjshwIb5vGNgGeAPds4Dm8jleTWAZbM46fOw7LrA6+TqhAXB87In91O7WxHRzGen99nY1JJe708/1TgTlJJfDXgoeI+aWffBbBWHj6TdIKyfP5s/gKckuedApyXP8PFgG0B1R9jLdhHo8jHft30i5jzHVuL9F1aglRquAM4q7Ds4/XrB/4nb/MSwFnApFJ+I8tY6YL4R/pRHQXMJP0AjAZWzvNOoI1EAKwCvE9d8sjL/QY4s8H0lfOXYcnCtOHArYWDYySpDr/4uh1IVTNbAYu0sy2rAe8BfQrTTmHOD/gImksES5K+1P1IP3Jb8+FE8L/AFYXXLQLMIv0wbAc8VfvS5fn3MCcR/Bo4ue59pzEniX5w0OcvxInAivPwue4L3ERKWC8AP2hn2WuAb+fhoaQf+l55vE/+zLcsLD+ROT94U4EdC/NWIf0wLNrO+w1l7kRwUQfbc1btmKLxD9exhWUPAa6fh2WPo5DEgKWAt2njR67JGAcW5o8D9snDjwK7FOYdTCcSASmJvwGsWZj3CeCxPHwS8H/kpFG3jg+OsbL3EW0nglOBG9t4zZ7AA23F22D5ZXP8/Tr7PenorypVQ0TE1IgYEREDgQ2AVUkHdEdWA16MiJfamPevBtMHk85Ons5F1pdJSWOlPP/7pAN8nFK1y//kGG8BfgWcAzwraaRS+0a9VXNMrxWmPUEqkTQtImaTSjvHAitExN0N3ueJwvLvAzPy+6wKzIp8hBZiqBkMHFHb/rwPVsuvq3cg6azsH5LGS/pcJ7bhjxGxE+lL8nXgZEm16q5dJY3NVQYvA7sBKxZe/kLMaTicnf8/U5g/m1RCqW3PnwvbMpWUjFduNtZsRnFE0paSbpX0nKRX8jas2PilQKrSq3mzEF9nll21GEdEvElKog01GWNT78WHj5Fm9Cf9CE8s7Pvr83SA00ml1BuUqv+O6uT6u2QftWMAqdSKpJUlXaZUVfwq8Afa+awl9ZJ0qlJ15KukREF7r5lXlUkERRHxD1IGr9W/v0E62Gr+qzA8A1i+VpdXZwap6qHR9LdIZ7jL5r++EfGx/P7/joiDImJV4GvAuZLWyvN+GRGbk4qm65CqPeo9lWPqU5g2iHS23lkXAUeQDspG7zO4NiJJpB/zWcDTwIA8rRhDzQzgx4XtXzYiloqIS+vfJCL+GRHDSYnyNOAqdbKBLSLeiYgrSVVJG0haAriaVKRfOSKWBa4jJeB5MQPYtW57ekdEZ/d51I1fQiqdrhYR/UjVHPMaY7OeJlVxAaken1SX3Zb5ifFp0jFTM6itBdvwPCkhf6yw3/tFblCOiNci4oiI+AipTv67knbMr63f153R2X00F0nLADuRqsYAfpJj2jAi+pKqNov7sT7eLwPD8jr6kUo0UMLxUYlEIGldSUdIGpjHVyNV1YzNi0wCtlO6hK0fcHTttRHxNPA30o/1cpIWk7Rdnv1b4ABJO+YGqgGS1s2vuQH4maS+ed6akrbP7//FWizAS6QD4H1JH89nX4uRktN/SNVSHxIRM0jVMKdI6q3UCHsgjX/MO3I7qd7y7AbzrgA+m7dvMVLCeCu/972kKrZv5X2yF6nNpOZ84Ot5eyRpaaVGxz71byJpP0n9c4nj5Tx5ru1u8LoRtXXmfbwrqW7/PlK97hKkev9387xPN7E/2nIe8GNJg/N795c0bD7WV9OHVLr7j6QtSF/+sl0F7C7pk5IWJ1WNtvfjMj8xXgEcnb87A4HDOhNoPibOB86UtBJA/p7VSn2fU7r4QqT2l/eYc+w8A3ykM+9X0Nl99AGlxu3NSVWRLwG/z7P6kNodXpE0gLlP8urj7UP6vr1AOlH9yTxtSRMqkQiA10iNlvcpXa0xltRodQRARNxIagyeTKoXvrbu9V8h1Qf/g9QAenh+3TjSFQFnkg7C25lzBr0/6cfoYdLBcBWpXhnSlRP3KV1XPppUb/0oqVH7/Lz8E6QD4PQ2tmk46QzhKVLD9PERcVNndkrehoiImyPixQbzppHOWs4mnZntDuweEW9HxNvAXqT2hheBLwF/Krx2AqkB9ld5e6bnZRvZBZiS98cvSPXLswFy1dm+bbzuVeCHwJOkBPJT4BsRcVeuNvsW6YfoJdKP1+g21tOMX+TX3yDpNdIxtOV8rK/mEOCkvM7jSPGWKiKmkH6QLyOd+b5OOq7bupx6fmI8kXQsP0Y6Obp4HkL+Aen4GZurSG4CPprnrZ3HXyednJwbEbfmeacAx+YqpSM784bzsI8Avp/30QukkvZE4JMx5zLuE4HNSL8Vf6XwfWkj3otI+24W6XdkLCWpta6bWUXlKoyXgbUj4rFuDmeB1NP3UVVKBGZWIGl3SUvltpgzSPeUPN69US1YqrSPSksEkn6ndKPOQ23Ml6RfKt0MNVnSZmXFYmZzGUaqVnyKVL2yT7h6oF5l9lFpVUO5QfV10nXTc90dK2k3Uh3cbqS61l9ERFfUuZqZWSeUViKIiDvI18+2YRgpSUREjAWWlbRKO8ubmVkJurONYAAfvtFkJp28IcrMzObfoh0v0v0kHUy6NZ2ll15683XXXbebIzKzhcXEZ57peKGFxOYrd/ZG9jkmTpz4fET0bzSvOxPBLD58x+FA2rgzNlKPkiMBhgwZEhMmTCg/OjPrEXTGGd0dQpeZcGSnbof4EEltdu/RnVVDo4H989VDWwGv5DtyzcyshUorEUi6lNT74opKj6Y7ntQRGxFxHqnfl91Idwy+Se6z28zMWqu0RJA7EWtvfgDfLOv9zcysOb6z2Mys4pwIzMwqzonAzKzinAjMzCrOicDMrOKcCMzMKs6JwMys4pwIzMwqzonAzKzinAjMzCrOicDMrOKcCMzMKs6JwMys4pwIzMwqzonAzKzinAjMzCrOicDMrOKcCMzMKs6JwMys4pwIzMwqzonAzKzinAjMzCrOicDMrOKcCMzMKs6JwMys4pwIzMwqzonAzKzinAjMzCrOicDMrOKcCMzMKs6JwMys4pwIzMwqzonAzKzinAjMzCrOicDMrOJKTQSSdpE0TdJ0SUc1mD9I0q2SHpA0WdJuZcZjZmZzKy0RSOoFnAPsCqwPDJe0ft1ixwJXRMSmwD7AuWXFY2ZmjZVZItgCmB4Rj0bE28BlwLC6ZQLom4f7AU+VGI+ZmTVQZiIYAMwojM/M04pOAPaTNBO4Djis0YokHSxpgqQJzz33XBmxmplVVnc3Fg8HRkXEQGA34GJJc8UUESMjYkhEDOnfv3/LgzQz68nKTASzgNUK4wPztKIDgSsAIuJeoDewYokxmZlZnTITwXhgbUlrSFqc1Bg8um6ZJ4EdASStR0oErvsxM2uh0hJBRLwLHAqMAaaSrg6aIukkSXvkxY4ADpL0d+BSYERERFkxmZnZ3BYtc+URcR2pEbg47bjC8MPA1mXGYGZm7evuxmIzM+tmTgRmZhXnRGBmVnFOBGZmFedEYGZWcU4EZmYV50RgZlZxTgRmZhXnRGBmVnFOBGZmFedEYGZWcR0mAkkbtiIQMzPrHs2UCM6VNE7SIZL6lR6RmZm1VIeJICK2BfYlPWRmoqRLJO1cemRmZtYSTbURRMQ/gWOBHwDbA7+U9A9Je5UZnJmZla+ZNoKNJJ1JerjMDsDuEbFeHj6z5PjMzKxkzTyY5mzgAuCHETG7NjEinpJ0bGmRmZlZSzSTCD4LzI6I9wAkLQL0jog3I+LiUqMzM7PSNdNGcBOwZGF8qTzNzMx6gGYSQe+IeL02koeXKi8kMzNrpWYSwRuSNquNSNocmN3O8mZmthBppo3gcOBKSU8BAv4L+FKZQZmZWet0mAgiYrykdYGP5knTIuKdcsMyM7NWaaZEACkJrA/0BjaTRERcVF5YZmbWKh0mAknHA0NJieA6YFfgLsCJwMysB2imsXhvYEfg3xFxALAx4M7nzMx6iGYSweyIeB94V1Jf4FlSB3RmZtYDNNNGMEHSssD5wETgdeDeMoMyM7PWaTcRSBJwSkS8DJwn6Xqgb0RMbkVwZmZWvnYTQUSEpOuADfP4460IyszMWqeZNoL7JX289EjMzKxbNNNGsCWwr6QngDdIdxdHRGxUamRmZtYSzSSCz5QehZmZdZtmEkGUHoWZmXWbZtoI/gpcm//fDDwK/K2ZlUvaRdI0SdMlHdXGMv8t6WFJUyRd0mzgZmbWNZrpdG7D4njukvqQjl4nqRdwDrAzMBMYL2l0RDxcWGZt4Ghg64h4SdJKnYzfzMzmUzMlgg+JiPtJDcgd2QKYHhGPRsTbwGXAsLplDgLOiYiX8rqf7Ww8ZmY2f5rpdO67hdFFgM2Ap5pY9wBgRmF8JnMnkHXye9wN9AJOiIjrm1i3mZl1kWYai/sUht8ltRVc3YXvvzapd9OBwB2SNsx3Mn9A0sHAwQCDBg3qorc2MzNoro3gxHlc9yw+3DndwDytaCZwX37QzWOSHiElhvF1MYwERgIMGTLEVzGZmXWhDtsIJN2YO52rjS8naUwT6x4PrC1pDUmLA/sAo+uWuYZUGkDSiqSqokebitzMzLpEM43F/YtVNblht8OreyLiXeBQYAwwFbgiIqZIOknSHnmxMcALkh4GbgW+FxEvdHIbzMxsPjTTRvCepEER8SSApME0eZNZRFxHeqpZcdpxheEAvpv/zMysGzSTCI4B7pJ0O6mfoW3JDbdmZrbwa6ax+Pp8E9lWedLhEfF8uWGZmVmrNNNY/HngnYi4NiKuJT2ycs/SIzMzs5ZoprH4+Ih4pTaSG46PLy0iMzNrqWYSQaNlmmlbMDOzhUAziWCCpJ9LWjP/nUl6iL2ZmfUAzSSCw4C3gcvz32ya6H3UzMwWDs1cNfQG8MGzBCQNAr4JnF5iXGZm1iJNdUMtqb+kQyTdSboDeOVywzIzs1Zps0QgqQ+wF/BlUh9AfwLWiIiBLYrNzMxaoL2qoWeBccCxwF0REfmeAjMz60Haqxo6GlgCOBc4WtKarQnJzMxaqc1EEBFnRcRWzHm85DXAqpJ+IGmdVgRnZmbl67CxOD9z+Cf5IfZDgL7U9ShqZmYLr049vD4iHoqIYyJirbICMjOz1upUIjAzs57HicDMrOKcCMzMKq7DLiYkbQ2cAAzOy4v0lMmPlBuamZm1QjPdSf8W+A6px9H3yg3HzMxarZlE8EpE/K30SMzMrFs0kwhulXQ6qa+ht2oTI+L+0qIyM7OWaSYRbJn/DylMC2CHrg/HzMxarZnnEXyqFYGYmVn36PDyUUn98qMqJ+S/n0nq14rgzMysfM3cR/A74DXgv/Pfq8DvywzKzMxap5k2gjUj4guF8RMlTSopHjMza7FmSgSzJW1TG8k3mM0uLyQzM2ulZkoE3wAuzO0CAl4ERpQZlJmZtU4zVw1NAjaW1DePv1p2UGZm1jrtPbx+v4j4g6Tv1k0HICJ+XnJsZmbWAu2VCJbO//s0mBclxGJmZt2gzUQQEb/JgzdFxN3FebnB2MzMeoBmrho6u8lpZma2EGqvjeATwCeB/nXtBH2BXmUHZmZmrdFeiWBxYBlSsuhT+HsV2LuZlUvaRdI0SdMlHdXOcl+QFJKGtLWMmZmVo702gtuB2yWNiognOrtiSb2Ac4CdgZnAeEmjI+LhuuX6AN8G7uvse5iZ2fxrpo3gAknL1kYkLSdpTBOv2wKYHhGPRsTbwGXAsAbLnQycBvyniXWamVkXa+bO4hUj4uXaSES8JGmlJl43AJhRGJ/JnGcbACBpM2C1iPirpO+1tSJJBwMHAwwaNKiJt7ZGdMYZ3R1Cl4gjj+zuEMx6lGZKBO9L+uDXV9JguuA+AkmLAD8Hjuho2YgYGRFDImJI//795/etzcysoJkSwTHAXZJuJ/U1tC357LwDs4DVCuMD87SaPsAGwG35buX/AkZL2iMiJjSxfjMz6wLN9DV0fa7C2SpPOjwinm9i3eOBtSWtQUoA+wBfLqz3FWDF2rik24AjnQTMzFqrzaohSevm/5sBg4Cn8t+gPK1dEfEucCgwBpgKXBERUySdJGmPrgjezMzmX3slgiOAg4CfNZjX1MPrI+I64Lq6ace1sezQjtZnZmZdr737CA7K//3wejOzHqy9Lib2au+FEfGnrg/HzMxarb2qod3z/5VIfQ7dksc/BdwDOBGYmfUA7VUNHQAg6QZg/Yh4Oo+vAoxqSXRmZla6Zm4oW62WBLJnSFcRmZlZD9DMDWU3576FLs3jXwJuKi8kMzNrpWZuKDtU0ueB7fKkkRHx53LDMjOzVmmmRABwP/BaRNwkaSlJfSLitTIDMzOz1uiwjUDSQcBVQO0ZxgOAa0qMyczMWqiZxuJvAluTnkxGRPyTdEmpmZn1AM0kgrfyg2UAkLQoXdANtZmZLRiaSQS3S/ohsKSknYErgb+UG5aZmbVKM4ngB8BzwIPA10idyB1bZlBmZtY67V41lB9APyUi1gXOb01IZmbWSu2WCCLiPWBa8VGVZmbWszRzH8FywBRJ44A3ahMjwg+XMTPrAZpJBP9behRmZtZt2nseQW/g68BapIbi3+bHT5qZWQ/SXhvBhcAQUhLYlcaPrDQzs4Vce1VD60fEhgCSfguMa01IZmbWSu2VCN6pDbhKyMys52qvRLCxpFfzsEh3Fr+ahyMi+pYenZmZla69R1X2amUgZmbWPZrpYsLMzHowJwIzs4pzIjAzqzgnAjOzinMiMDOrOCcCM7OKcyIwM6s4JwIzs4pzIjAzqzgnAjOzinMiMDOruFITgaRdJE2TNF3SUQ3mf1fSw5ImS7pZ0uAy4zEzs7mVlggk9QLOIT3UZn1guKT16xZ7ABgSERsBVwE/LSseMzNrrMwSwRbA9Ih4NCLeBi4DhhUXiIhbI+LNPDoWGFhiPGZm1kCZiWAAMKMwPjNPa8uBwN9KjMfMzBpo78E0LSNpP9LzkbdvY/7BwMEAgwYNamFkZmY9X5mJYBawWmF8YJ72IZJ2Ao4Bto+ItxqtKCJGAiMBhgwZEvMakM44Y15fusCJI4/s7hDMrIcos2poPLC2pDUkLQ7sA4wuLiBpU+A3wB4R8WyJsZiZWRtKSwT5gfeHAmOAqcAVETFF0kmS9siLnQ4sA1wpaZKk0W2szszMSlJqG0FEXAdcVzftuMLwTmW+v5mZdcx3FpuZVZwTgZlZxTkRmJlVnBOBmVnFORGYmVWcE4GZWcU5EZiZVZwTgZlZxTkRmJlVnBOBmVnFORGYmVWcE4GZWcU5EZiZVZwTgZlZxTkRmJlV3ALxzGIzK1dPeUyrH9FaDpcIzMwqzonAzKzinAjMzCrOicDMrOKcCMzMKs6JwMys4nz5qFVCT7l8EnwJpXU9lwjMzCrOicDMrOKcCMzMKs6JwMys4pwIzMwqzonAzKzinAjMzCrOicDMrOKcCMzMKs6JwMys4pwIzMwqzonAzKziSk0EknaRNE3SdElHNZi/hKTL8/z7JK1eZjxmZja30hKBpF7AOcCuwPrAcEnr1y12IPBSRKwFnAmcVlY8ZmbWWJklgi2A6RHxaES8DVwGDKtbZhhwYR6+CthRkkqMyczM6igiylmxtDewS0T8vzz+FWDLiDi0sMxDeZmZefxfeZnn69Z1MHBwHv0oMK2UoLvOisDzHS7VM3nbq6vK278wbPvgiOjfaMZC8WCaiBgJjOzuOJolaUJEDOnuOLqDt72a2w7V3v6FfdvLrBqaBaxWGB+YpzVcRtKiQD/ghRJjMjOzOmUmgvHA2pLWkLQ4sA8wum6Z0cBX8/DewC1RVl2VmZk1VFrVUES8K+lQYAzQC/hdREyRdBIwISJGA78FLpY0HXiRlCx6goWmGqsE3vbqqvL2L9TbXlpjsZmZLRx8Z7GZWcU5EZiZVZwTQSdJer3BtBMkzZI0SdI/Jf2p/i5qSZtICkm7tC7aedfGdn5d0v7dEc/8kvRe/nweknSlpKW6IYY9G9xdv8CTtLKkSyQ9KmmipHslfV7S0HxM715Y9lpJQ/PwbbmLmUmSpub7gboqpuLn+RdJy3bRekdI+lVXrKtuvcV9MSnfZ9XlJK0u6cudfZ0TQdc5MyI2iYi1gcuBWyQVb94YDtyV/y+UIuK8iLiorPUrKeuYnJ0/nw2At4GvNxlTV15QsSepu5Wy36fL5Dv9rwHuiIiPRMTmpIs6BuZFZgLHtLOKfSNiE2Br4LR8BWFXKH6eLwLf7KL1lmnfHPMmEXFVMy+Yh+NidcCJYEEQEZcDN5A/kPxl+iIwAthZUu/ui27e5ZLPkXn4NkmnSRon6RFJ2+bpvSSdLmm8pMmSvpanLyPpZkn3S3pQ0rA8ffV8pnQR8BAfvvekLHcCa0laWtLv8jY8UIhphKTRkm4Bbs6x/z7HPVnSF/Jyn85nx/fnUsYyefrjkn6alx8naS1JnwT2AE7PZ4Rr5n14lqQJwLcl7ZjjeDDHtURhfScW9t26LdhHNTsAb0fEebUJEfFERJydR/8OvCJp5w7WswzwBvBeCTHeCwwAkLRF/kwekHSPpI/m6SOUSurXK5Xaf1p7saQD8jE8jpSwatNXl3RL/sxvljQoTx8l6deSxuZS0tD8eU2VNKrZoCUtL+mavP6xkjbK00+QdLGku0lXVfaXdHX+To2XtHVebvtCCeMBSX2AU4Ft87TvNL0HI8J/nfgDXm8w7QTgyLpphwO/zsNbAzfn4UuAL3T3dszvdgK3AT/Lw7sBN+Xhg4Fj8/ASwARgDdKlyn3z9BWB6YBIZzDvA1u1YntyHP8HfAP4CbBfnr4s8AiwNClhzwSWz/NOA84qrGu5vA13AEvnaT8AjsvDjwPH5OH9gWvz8Chg78J6bgPOzcO9gRnAOnn8IuDwwvoOy8OHABe08Dj4Fqm022jeUOBaYDvg9jztWmBoYfumAZOB2cDXSvg8ewFXkrqqAegLLJqHdwKuzsMjgEdJN632Bp4gnXSsAjwJ9AcWB+4GfpVf8xfgq3n4f4BrCp/jZfn4HQa8CmxIOrGeCGzSIN7avpiU/1YAzgaOz/N3ACYVvmcTgSXz+CXANnl4EDC1EN/WeXgZ0rE9tHa8deZvgSyO9hDFzvOGkw4c8v/9gatbHlHX+1P+P5H0gw7waWCjQh1oP2Bt0g/rTyRtR/rhHwCsnJd5IiLGlhzrkpIm5eE7Sfew3APsUSvlkH4gBuXhGyPixTy8E4V7XCLiJUmfI1Xz3J0KfCxOOjOtubTw/8x24ro8//8o8FhEPJLHLyRVd5yVx4v7eq/2NrRMks4BtiFVr30PICLukISkbRq8ZN+ImKBUTXqPpOsj4okuCKX2eQ4ApgI35un9gAslrQ0EsFjhNTdHxCt5Ox4GBpMS+m0R8VyefjmwTl7+E8zZ1xcDPy2s6y8REZIeBJ6JiAfz66eQvguTGsS8b0RMqI3k/fUFgIi4RdIKkvrm2aMjYnYe3glYX3P64+ybS593Az+X9EfgTxExU/PYZ6cTQXk2BSYodcf9BWCYpGNICWIFSX0i4rVujXD+vZX/v8ecY0mks9cxxQUljSCddW0eEe9Iepz0wwupyqBssyPVVRdjEql0Nq1u+pZNxCRSsmirzSfaGK7X7LY32tetMIX8YwUQEd+UtCKppFf0Y+BY4N1GK4mI5yTdD2xJOhufX7MjYhOlRv8xpKT5S+Bk4NaI+LzS801uK7zmrcLw/O7H2rrer1vv+/O53pricbEIqcT8n7plTpX0V1KJ/G5Jn5nXN3MbQQlyHfKnSWeDOwKTI2K1iFg9IgaTSgOf784YSzQG+IakxQAkrSNpadKZ2rM5CXyKdDbW3cYAh+WEgKRN21juRgqNkZKWA8YCW0taK09bWtI6hdd8qfC/VlJ4DejTxntMA1avrQ/4CnB75zanFLcAvSV9ozBtriuuIuIGUpXZRo1Wkn+wNwX+1ZXBRcSbpOqrIzSnv7Jan2YjmljFfcD2+Wx8MVJbXs09zCkJ7ksqSXalO/N6UbrS6vmIeLXBcjcAh9VGJG2S/68ZEQ9GxGmkLn3Wpf1jrE1OBJ23lKSZhb/v5unfyQ00/wT2A3bIxc3hwJ/r1nE1C/7VQ21tZ0cuAB4G7lfqZvw3pDOkPwJDclF6f+AfpUTdOSeTqg4m5yL9yW0s9yNgOaVLFf8OfCp/tiOASyVNJv3YFxtxl8vTvw3UGu0uA76XG/bWLL5BPts7ALgy76P3gfPoZpEqoPck/Vg+lhtULyS1idT7MXM39v8xV+FMBEZFxMQSYnyA1A4xnFR9c4qkB2jizDwinibVyd9LqmqZWph9GHBA/hy/Qvosu9IJwOZ5/acyp9+1et8ifXcm5yqt2hVvh+djcjLwDvA30n54T9LfO9NY7C4mzLpYrvYaEnXP1TBbULlEYGZWcS4RmJlVnEsEFaGSbsnvCpJOkrRTd8dhVlUuEVSEpNcjonbn64XAIxHx4/lc56IR0fByQTNbeLhEUE3FW/LXVLrtfqKkO5W7L8jTxyp1afAj5U7olG6nv1PSaOBhtd2lxCqS7iiUQrbNy47K4w/WrmrI0/bOwwtiNwtmPZoTQcXkG9x2ZM5jQ0eSbgDbHDgSODdP/wXwi4jYkHRXcNFmwLcjYh3gQOCViPg48HHgIElrkPpZGpNv4tqYdKflJsCAiNggr/f3dbH1Jt2+/6U8f1FSVxA1z0fEZsCvc6xm1gWcCKqjdkv+v0ldO9yodJv6J0nXrk8iXfO/Sl7+E6Q+XCD1dVI0LiIey8OfBvbPr7+P1IfK2qQbXA6QdAKwYb6L+lHgI5LOVuqOu/7mmUbdLGxXmN+oSwszm09OBNVR62JhMKl7hG+SPv+XY07XuJtExHpNrKt4+3utS4na69eIiBsi4g7Sj/gsYJSk/SPiJVLp4DbSTTEXdHIbuqubBbMezYmgYoq35ANvAo9J+iJ88DyAjfOiY5nTx8w+c61ojoZdSkgaTOqM63zSD/5mSn3ULBIRV5P6pdmsbl0LajcLZj2az6oqKCIeyLelDyf1dfJrSceSulu4jNTH/OHAH5Q6yrseeKWN1V1Aqqa5X5KA50hdEgwldafwDvA6qVuJAcDvNefhM0fXxfUfSbVuFhYlVS91ezcLZj2dLx+1hpQ6CZudu9rdBxgeEcO6Oy4z63ouEVhbNgd+lc/yXyY9mMPMeiCXCMzMKs6NxWZmFedEYGZWcU4EZmYV50RgVkdSSPpDYXxRSc9JuraT63k83zsxX8uYlc2JwGxubwAbSFoyj+/MnOfgmvU4TgRmjV0HfDYPDwcurc2QtLyka3Jvq2MlbZSnryDpBklTJF1A6n6j9pr9JI3LvbH+Jnf+Z7ZAcCIwa+wyYJ/cI+pGpA71ak4EHoiIjYAfAhfl6ccDd0XEx4A/A4MAJK0HfAnYOvf39B7pjm6zBYJvKDNrICImS1qdVBq4rm72NuR+mCLillwS6EvqZG+vPP2vkl7Ky+9IukFvfLo/jyWBZ0vfCLMmORGYtW00cAap36QV5mM9Ai6MiKM7XNKsG7hqyKxtvwNOjIgH66bfSa7akTSU9MCcV4E7SA/kQdKuwHJ5+ZuBvSWtlOctn3tnNVsguERg1oaImAn8ssGsE4Df5R5c3wS+mqefCFwqaQpwD/BkXs/DuXfXG3LPq++QngfxRLlbYNYc9zVkZlZxrhoyM6s4JwIzs4pzIjAzqzgnAjOzinMiMDOrOCcCM7OKcyIwM6s4JwIzs4r7/6g2MxHbw9wFAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as pyplot\n",
    "\n",
    "x = ['LDA', 'Linear\\nRegression', 'Perceptron', 'GNB', 'Random Forest']\n",
    "correct_predictions = np.array([num_right_lda, num_right_lg, num_right_perceptron, num_right_gnb, num_right_forest])\n",
    "correct_predictions = correct_predictions / len(contours)\n",
    "\n",
    "x_pos = [i for i, _ in enumerate(x)]\n",
    "\n",
    "pyplot.bar(x_pos, correct_predictions, color='darkcyan')\n",
    "pyplot.xlabel(\"Model\")\n",
    "pyplot.ylabel(\"Prediction Accuracy\")\n",
    "pyplot.title(\"Success of Models: Same Training and Testing Data\")\n",
    "pyplot.ylim([0, 1.0])\n",
    "\n",
    "pyplot.xticks(x_pos, x)\n",
    "\n",
    "pyplot.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as pyplot\n",
    "\n",
    "x = ['LDA', 'Linear\\nRegression', 'Perceptron', 'GNB', 'Random Forest']\n",
    "correct_predictions = np.array([num_right_lda2, num_right_lg2, num_right_perceptron2, num_right_gnb2, num_right_forest2])\n",
    "correct_predictions = correct_predictions / len(test_predictors)\n",
    "\n",
    "x_pos = [i for i, _ in enumerate(x)]\n",
    "\n",
    "pyplot.bar(x_pos, correct_predictions, color='darkcyan')\n",
    "pyplot.xlabel(\"Model\")\n",
    "pyplot.ylabel(\"Prediction Accuracy\")\n",
    "pyplot.title(\"Success of Models: Different Training and Testing Data\")\n",
    "pyplot.ylim([0, 1.0])\n",
    "\n",
    "pyplot.xticks(x_pos, x)\n",
    "\n",
    "pyplot.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LDA limited"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "contour_predictors = contours[[\" duration\", \" num_smp\"]]\n",
    "contour_results = contours[\" note\"]\n",
    "\n",
    "lda = LinearDiscriminantAnalysis()\n",
    "model = lda.fit(contour_predictors, contour_results)\n",
    "predictions = model.predict(contour_predictors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7631\n",
      "0.09763306038894576\n"
     ]
    }
   ],
   "source": [
    "num_right = 0\n",
    "for i in range( len(predictions) ):\n",
    "    if(predictions[i] == contours[\" note\"][i]):\n",
    "        num_right += 1\n",
    "        \n",
    "print(num_right)\n",
    "print(num_right / len(contours))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LDA less training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1465\n",
      "0.053189558145445306\n"
     ]
    }
   ],
   "source": [
    "contours_reduced = contours[contours[\"time\"] % 0.5 < 0.2]\n",
    "contours_reduced = contours_reduced[contours_reduced[\"time\"] % 0.5 > 0.02]\n",
    "\n",
    "contour_predictors = contours_reduced.drop([\"time\", \" note\"], axis=1)\n",
    "contour_results = contours_reduced[\" note\"]\n",
    "\n",
    "lda = LinearDiscriminantAnalysis()\n",
    "model = lda.fit(contour_predictors, contour_results)\n",
    "predictions = model.predict(contour_predictors)\n",
    "\n",
    "num_right = 0\n",
    "for i in range( len(predictions) ):\n",
    "    if(predictions[i] == contours[\" note\"][i]):\n",
    "        num_right += 1\n",
    "        \n",
    "print(num_right)\n",
    "print(num_right / len(contours_reduced))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This suggests that the model is not correctly predicting at all"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "575\n",
      "0.0419340723453909\n"
     ]
    }
   ],
   "source": [
    "contours_reduced = contours[contours[\"time\"] % 1 < 0.2]\n",
    "contours_reduced = contours_reduced[contours_reduced[\"time\"] % 1 > 0.02]\n",
    "\n",
    "contour_predictors = contours_reduced.drop([\"time\", \" note\"], axis=1)\n",
    "contour_results = contours_reduced[\" note\"]\n",
    "\n",
    "lda = LinearDiscriminantAnalysis()\n",
    "model = lda.fit(contour_predictors, contour_results)\n",
    "predictions = model.predict(contour_predictors)\n",
    "\n",
    "num_right = 0\n",
    "for i in range( len(predictions) ):\n",
    "    if(predictions[i] == contours[\" note\"][i]):\n",
    "        num_right += 1\n",
    "        \n",
    "print(num_right)\n",
    "print(num_right / len(contours_reduced))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n",
      "0.022071307300509338\n"
     ]
    }
   ],
   "source": [
    "contours_reduced = contours[contours[\"time\"] % 1 < 0.03]\n",
    "contours_reduced = contours_reduced[contours_reduced[\"time\"] % 1 > 0.02]\n",
    "\n",
    "contour_predictors = contours_reduced.drop([\"time\", \" note\"], axis=1)\n",
    "contour_results = contours_reduced[\" note\"]\n",
    "\n",
    "lda = LinearDiscriminantAnalysis()\n",
    "model = lda.fit(contour_predictors, contour_results)\n",
    "predictions = model.predict(contour_predictors)\n",
    "\n",
    "num_right = 0\n",
    "for i in range( len(predictions) ):\n",
    "    if(predictions[i] == contours[\" note\"][i]):\n",
    "        num_right += 1\n",
    "        \n",
    "print(num_right)\n",
    "print(num_right / len(contours_reduced))"
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}