Part II - Sentiment Analysis Classifications - Review and Comparison.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1 align=\"center\">PART II</h1>\n",
    "<h1 align=\"center\">Sentiment Analysis Classifications - Review and Comparison</h1>\n",
    "\n",
    "First, we need to create word vectors. For simplicity, we will use a pretrained Word2Vec model\n",
    "with Ukrainian words-vectors, each of which has a dimension of 300.\n",
    "\n",
    "This sample of word vectors was created on the basis of fiction literature. We chose the lematized version of this model because we already have our sample, which we processed in the previous part, which would fit perfectly here.\n",
    "\n",
    "The model can be found on [this website](https://lang.org.ua/uk/models/).\n",
    "\n",
    "To get started, let's download the necessary libraries:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/jupyter/notebook/jupyterenv/lib/python3.7/site-packages/gensim/similarities/__init__.py:15: UserWarning: The gensim.similarities.levenshtein submodule is disabled, because the optional Levenshtein package <https://pypi.org/project/python-Levenshtein/> is unavailable. Install Levenhstein (e.g. `pip install python-Levenshtein`) to suppress this warning.\n",
      "  warnings.warn(msg)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import pickle\n",
    "import gensim, logging\n",
    "import gensim.models.keyedvectors as word2vec\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also let's write a style for alignment in the middle of all graphs, images, etc:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       ".output_png {\n",
       "    display: table-cell;\n",
       "    text-align: center;\n",
       "    vertical-align: middle;\n",
       "}\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.display import HTML\n",
    "HTML(\"\"\"\n",
    "<style>\n",
    ".output_png {\n",
    "    display: table-cell;\n",
    "    text-align: center;\n",
    "    vertical-align: middle;\n",
    "}\n",
    "</style>\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we will load the sample data we processed in the previous part:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('documents.pql', 'rb') as f:\n",
    "     docs = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of documents: 38271\n"
     ]
    }
   ],
   "source": [
    "print(\"Number of documents:\", len(docs))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will load our word2vec model. \n",
    "\n",
    "This may take some time, as the model contains 325 250  words, so we will get a 325 250 x 300 embedding matrix that contains all the values of the word vectors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = word2vec.KeyedVectors.load_word2vec_format('ubercorpus.lowercased.lemmatized.word2vec.300d.txt', binary=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's get a list of all the words from our dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "words = list(model.index_to_key)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just to make sure everything is loaded correctly, we can look at the dimensions of the dictionary list and the embedding matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['в', 'на', 'у', 'і', 'з', 'що', 'не', 'бути', 'до', 'за', 'та', 'це', 'україна', 'який', 'як', 'про', 'рік', 'а', 'він', 'для', 'від', 'свій', 'вони', 'його', 'цей', 'також', 'я', 'ми', 'той', 'й', 'категорія', 'один', 'мати', 'час', 'такий', 'із', 'але', 'могти', 'під', 'рок', 'президент', 'по', 'те', 'вона', 'після', 'сказати', 'країна', 'український', 'інший', 'так'] \n",
      "\n",
      "Total words: 325250 \n",
      "\n",
      "Word-Vectors shape: (325250, 300)\n"
     ]
    }
   ],
   "source": [
    "print(words[:50], \"\\n\\nTotal words:\", len(words), \"\\n\\nWord-Vectors shape:\", model.vectors.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also find a word like \"гарний\" in our word list and then access the corresponding vector through the embedding matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 4.516500e-02  1.251880e-01  2.108905e+00  1.637814e+00 -4.077700e-02\n",
      "  7.728100e-01 -6.516440e-01  1.463697e+00  3.339670e-01 -6.916780e-01\n",
      " -1.779990e-01  4.337260e-01  7.660550e-01  9.300980e-01 -1.599930e-01\n",
      "  2.290509e+00 -5.549170e-01  6.714390e-01 -4.648900e-02 -2.138202e+00\n",
      "  8.052800e-02  7.673460e-01 -2.694449e+00 -2.138186e+00  6.990550e-01\n",
      " -2.908490e-01 -4.759980e-01 -1.400164e+00 -1.804889e+00 -7.014440e-01\n",
      " -1.354321e+00 -4.605037e+00 -2.812303e+00  1.006020e+00 -4.980150e-01\n",
      "  7.537600e-01 -2.421496e+00  2.177093e+00 -1.282774e+00  2.158463e+00\n",
      "  5.019600e-01 -1.288280e-01 -1.434353e+00  1.179314e+00 -4.570560e-01\n",
      "  1.129010e-01  3.679680e-01  1.147463e+00 -2.718560e-01 -4.053980e-01\n",
      " -1.606960e+00 -1.048291e+00 -1.496587e+00  1.050120e-01 -4.461910e-01\n",
      " -6.268950e-01  1.559451e+00  4.125400e-02 -5.025610e-01 -4.405390e-01\n",
      "  5.498720e-01  6.160980e-01 -1.434053e+00 -3.693590e-01  9.504800e-01\n",
      "  5.033900e-02  6.530420e-01  1.092300e-01  1.099505e+00 -5.173930e-01\n",
      "  4.521600e-01  1.316980e-01 -3.447960e-01 -7.792470e-01  4.075340e-01\n",
      "  2.820041e+00  6.610030e-01  1.821168e+00 -2.971770e-01  2.257176e+00\n",
      " -4.745060e-01  7.594480e-01 -1.059868e+00  4.989820e-01 -6.173830e-01\n",
      " -2.095330e-01 -1.048407e+00  1.104115e+00 -1.824441e+00 -7.781510e-01\n",
      " -1.405824e+00  1.900557e+00  1.561251e+00 -5.875850e-01  6.799540e-01\n",
      " -6.634080e-01 -9.003320e-01  6.962900e-01  3.224510e-01 -8.991510e-01\n",
      " -1.563059e+00 -2.476330e-01  1.111810e+00  1.516762e+00 -4.468200e-02\n",
      "  1.487850e-01  8.789210e-01  5.810020e-01 -2.065040e+00 -1.307946e+00\n",
      "  2.704060e-01 -3.004260e-01  1.676520e-01 -4.670730e-01 -8.944330e-01\n",
      " -8.709880e-01  4.661530e-01  1.457993e+00  1.050520e+00  6.903990e-01\n",
      " -4.668420e-01 -2.977720e-01 -6.520110e-01 -4.240160e-01  1.385360e+00\n",
      " -1.531143e+00 -7.018450e-01 -1.360379e+00 -3.853250e-01 -6.779430e-01\n",
      "  7.717840e-01  2.329505e+00 -3.088810e+00 -5.592070e-01  1.253934e+00\n",
      " -3.597530e-01  2.797611e+00 -1.321196e+00  1.598887e+00 -3.396500e-02\n",
      " -2.289097e+00 -2.030717e+00 -3.379030e-01 -1.262551e+00 -1.726981e+00\n",
      "  1.345031e+00 -9.934130e-01 -5.192000e-02  3.973530e-01 -1.113024e+00\n",
      "  4.641050e-01 -2.380500e-01 -7.213880e-01  1.025990e+00  2.684590e-01\n",
      "  2.634822e+00  3.545000e-03  7.753260e-01 -3.080920e-01  6.404260e-01\n",
      " -2.668700e-01  1.035281e+00  1.010995e+00 -3.801760e-01 -1.426072e+00\n",
      "  1.388289e+00 -2.210900e-02  1.207970e+00  1.500790e-01 -2.480071e+00\n",
      " -1.091718e+00 -6.491920e-01  4.927010e-01 -5.941840e-01 -1.082866e+00\n",
      " -2.401680e-01 -4.719710e-01 -3.661100e-02 -2.696187e+00 -1.971875e+00\n",
      " -1.766649e+00  2.520458e+00 -1.510660e+00  4.006100e-01  1.887000e-01\n",
      "  2.494095e+00  1.282755e+00  5.740700e-01 -4.948240e-01 -1.204628e+00\n",
      " -4.393090e-01 -1.551810e+00 -5.508650e-01  1.180141e+00  5.349000e-01\n",
      " -3.927950e-01  3.057980e-01 -2.361397e+00 -2.555871e+00  3.770730e-01\n",
      " -1.843960e-01  1.260310e+00 -2.991300e-01  1.357152e+00  2.762030e-01\n",
      " -1.426540e-01  2.562699e+00 -2.766109e+00 -6.215030e-01  8.803670e-01\n",
      " -4.308790e-01 -1.505190e-01  1.637587e+00 -3.374747e+00 -2.139150e-01\n",
      " -1.022518e+00 -9.176170e-01 -4.530680e-01 -4.203490e-01 -2.261070e-01\n",
      "  1.221680e-01  2.331910e+00  3.362230e-01  6.551530e-01  1.143581e+00\n",
      " -7.167460e-01  2.392504e+00 -1.617920e-01  8.335320e-01 -8.565140e-01\n",
      "  7.399930e-01  1.845600e-01 -4.017020e-01  2.454532e+00  5.603370e-01\n",
      "  1.802996e+00  6.780390e-01 -2.002757e+00 -9.561370e-01 -7.767850e-01\n",
      "  9.824630e-01 -1.245443e+00  9.280790e-01 -1.547359e+00  2.366216e+00\n",
      " -4.846720e-01  3.108160e-01 -6.243190e-01 -4.067400e-01  5.230150e-01\n",
      "  1.288720e-01 -6.330400e-02  1.113130e-01 -3.313499e+00  8.942980e-01\n",
      "  1.350776e+00  1.687170e-01  1.575140e-01  9.406630e-01 -4.680350e-01\n",
      " -1.198706e+00  7.283940e-01 -9.805220e-01  3.098200e-01  1.521724e+00\n",
      "  8.548450e-01  6.333460e-01  7.915220e-01  7.365100e-02  3.720840e-01\n",
      "  1.694675e+00 -2.111160e-01 -2.955300e-02 -7.750320e-01  2.498540e-01\n",
      " -3.456620e-01  3.002160e-01 -1.370374e+00 -1.828510e+00 -8.564450e-01\n",
      "  8.271900e-02  4.551800e-01  5.323970e-01 -2.781900e-02  1.758917e+00\n",
      "  9.635140e-01  6.156260e-01  1.877432e+00  1.220439e+00 -2.122004e+00\n",
      " -1.924871e+00  1.741680e-01 -6.280090e-01  2.112647e+00 -7.545850e-01\n",
      "  5.964110e-01 -7.919390e-01  5.867780e-01 -2.834060e-01  6.274380e-01]\n"
     ]
    }
   ],
   "source": [
    "print(model['гарний'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 align=\"center\">Word Average Embedding Model</h2>\n",
    "\n",
    "Well, let's start analyzing our vectors. Our first approach will be the **word average embedding model**. \n",
    "\n",
    "The essence of this naive approach is to take the average of all word vectors from a sentence to get one 300-dimensional vector that represents the tone of the whole sentence that we feed the model and try to get some quick result.\n",
    "\n",
    "We didn't have to put a try/except, but even though I cleaned up our sample, there were a couple of hundred words left after the processing that needed to be searched for and removed, such as `жорда`, `дарба`, `еріот`, `енрон`. These are not even words, so their absence will not affect anything."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sent_embed(words, docs):\n",
    "    x_sent_embed, y_sent_embed = [], []\n",
    "    count_words, count_non_words = 0, 0  \n",
    "    \n",
    "    # recover the embedding of each sentence with the average of the vector that composes it\n",
    "    # sent - sentence, state - state of the sentence (pos/neg)\n",
    "    for sent, state in docs:\n",
    "        # average embedding of all words in a sentence\n",
    "        sent_embed = []\n",
    "        for word in sent:\n",
    "            try:\n",
    "                # if word is present in the dictionary - add its vector representation\n",
    "                count_words += 1\n",
    "                sent_embed.append(model[word])\n",
    "            except KeyError:\n",
    "                # if word is not in the dictionary - add a zero vector\n",
    "                count_non_words += 1\n",
    "                sent_embed.append([0] * 300)\n",
    "        \n",
    "        # add a sentence vector to the list\n",
    "        x_sent_embed.append(np.mean(sent_embed, axis=0).tolist())\n",
    "        \n",
    "        # add a label to y_sent_embed\n",
    "        if state == 'pos': y_sent_embed.append(1)\n",
    "        elif state == 'neg': y_sent_embed.append(0)\n",
    "            \n",
    "    print(count_non_words, \"out of\", count_words, \"words were not found in the vocabulary.\")\n",
    "    \n",
    "    return x_sent_embed, y_sent_embed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40358 out of 1560217 words were not found in the vocabulary.\n"
     ]
    }
   ],
   "source": [
    "x, y = sent_embed(words, docs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 align=\"center\">Cosine Similarity</h2>\n",
    "\n",
    "To measure the similarity of 2 words, we need a way to measure the degree of similarity between 2 embedding vectors for these 2 words. Given 2 vectors $u$ and $v$, cosine similarity is determined as follows:\n",
    "\n",
    "$$\\text{cosine_similarity(u, v)} = \\frac {u . v} {||u||_2 ||v||_2} = cos(\\theta)$$\n",
    "\n",
    "where: \n",
    "\n",
    "* $u.v$ - dot product (or inner product) of two vectors;\n",
    "\n",
    "* $||u||_2$ - norm (or length) of the vector $u$;\n",
    "    \n",
    "    * **Note**: norm of $u$ is defined as $ ||u||_2 = \\sqrt{\\sum_{i=1}^{n} u_i^2}$)\n",
    "\n",
    "* $\\theta$ is the angle between $u$ and $v$. \n",
    "\n",
    "This similarity depends on the angle between $u$ and $v$. If $u$ and $v$ are very similar, their cosine similarity will be close to 1; if they are dissimilar, the cosine similarity will take a smaller value. \n",
    "\n",
    "**`cosine_similarity()`** is a method that used to estimate the similarity between word vectors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cosine_similarity(u, v):\n",
    "    \"\"\"\n",
    "    Cosine similarity reflects the degree of similariy between u and v\n",
    "        \n",
    "    Arguments:\n",
    "        u -- a word vector of shape (n,)          \n",
    "        v -- a word vector of shape (n,)\n",
    "\n",
    "    Returns:\n",
    "        cosine_similarity -- the cosine similarity between u and v defined by the formula above.\n",
    "    \"\"\"\n",
    "    \n",
    "    distance = 0.0\n",
    "    \n",
    "    # compute the dot product between u and v\n",
    "    dot = np.dot(u,v)\n",
    "    \n",
    "    # compute the L2 norm of u\n",
    "    norm_u = np.sqrt(sum(u**2))\n",
    "    \n",
    "    # Compute the L2 norm of v\n",
    "    norm_v = np.sqrt(sum(v**2))\n",
    "    \n",
    "    # Compute the cosine similarity defined by formula above\n",
    "    cosine_similarity = dot/(norm_u*norm_v)\n",
    "    \n",
    "    return cosine_similarity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 align=\"center\">Split Corpus</h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, for further work, we will divide our corpus for training, testing and development sets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "# train test\n",
    "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.15, random_state=1)\n",
    "\n",
    "# train dev\n",
    "x_train, x_val, y_train, y_val = train_test_split(x_train, y_train, test_size=0.15, random_state=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length of x_train: 27650 | Length of y_train: 27650\n",
      "Length of x_test:   5741 | Length of y_test:  5741\n",
      "Length of x_val:    4880 | Length of y_val:   4880\n"
     ]
    }
   ],
   "source": [
    "print('Length of x_train:', len(x_train), '| Length of y_train:', len(y_train))\n",
    "print('Length of x_test:  ', len(x_test), '| Length of y_test: ', len(y_test))\n",
    "print('Length of x_val:   ', len(x_val), '| Length of y_val:  ', len(y_val))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of x_train set: (27650, 300)\n"
     ]
    }
   ],
   "source": [
    "print(\"Shape of x_train set:\", np.array(x_train).shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 align=\"center\">Visualization of Classification Report</h2>\n",
    "\n",
    "We will need these methods when we start to visualize our data, so we will write them now."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following function takes the conclusion of the `classification_report` function as an argument and plots the results ( function is based on [this](https://stackoverflow.com/a/31689645/14467732) solution)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_classification_report(classification_report, title='Classification Report', cmap='RdBu'):\n",
    "    \n",
    "    lines = classification_report.split('\\n')\n",
    "\n",
    "    classes, plotMat, support, class_names = [], [], [], []\n",
    "    \n",
    "    for line in lines[2 : (len(lines) - 5)]:\n",
    "        t = line.strip().split()\n",
    "        if len(t) < 2: continue\n",
    "        classes.append(t[0])\n",
    "        v = [float(x) for x in t[1: len(t) - 1]]\n",
    "        support.append(int(t[-1]))\n",
    "        class_names.append(t[0])\n",
    "        plotMat.append(v)\n",
    "\n",
    "    xlabel = 'Metrics'\n",
    "    ylabel = 'Classes'\n",
    "    \n",
    "    xticklabels = ['Precision', 'Recall', 'F1-score']\n",
    "    yticklabels = ['{0} ({1})'.format(class_names[idx], sup) for idx, sup  in enumerate(support)]\n",
    "    \n",
    "    figure_width = 25\n",
    "    figure_height = len(class_names) + 7\n",
    "    correct_orientation = False\n",
    "    \n",
    "    heatmap(np.array(plotMat), title, xlabel, ylabel, xticklabels, yticklabels, figure_width, figure_height, correct_orientation, cmap=cmap)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This function is designed to create a heatmap with text in each cell using the matplotlib library (code based on idea from [here](https://stackoverflow.com/a/16124677/14467732)):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def heatmap(AUC, title, xlabel, ylabel, xticklabels, yticklabels, figure_width=40, figure_height=20, correct_orientation=False, cmap='RdBu'):\n",
    "    fig, ax = plt.subplots()\n",
    "    c = ax.pcolor(AUC, edgecolors='k', linestyle='dashed', linewidths=0.2, cmap=cmap)\n",
    "\n",
    "    # put the major ticks at the middle of each cell\n",
    "    ax.set_yticks(np.arange(AUC.shape[0]) + 0.5, minor=False)\n",
    "    ax.set_xticks(np.arange(AUC.shape[1]) + 0.5, minor=False)\n",
    "\n",
    "    # set tick labels\n",
    "    ax.set_xticklabels(xticklabels, minor=False)\n",
    "    ax.set_yticklabels(yticklabels, minor=False)\n",
    "\n",
    "    # set title and x/y labels\n",
    "    plt.title(title)\n",
    "    plt.xlabel(xlabel)\n",
    "    plt.ylabel(ylabel)      \n",
    "\n",
    "    # remove last blank column\n",
    "    plt.xlim( (0, AUC.shape[1]) )\n",
    "\n",
    "    # turn off all the ticks\n",
    "    ax = plt.gca()    \n",
    "    for t in ax.xaxis.get_major_ticks():\n",
    "        t.tick1On = False\n",
    "        t.tick2On = False\n",
    "    for t in ax.yaxis.get_major_ticks():\n",
    "        t.tick1On = False\n",
    "        t.tick2On = False\n",
    "\n",
    "    # add color bar\n",
    "    plt.colorbar(c)\n",
    "\n",
    "    # add text in each cell \n",
    "    show_val(c)\n",
    "\n",
    "    # proper orientation (origin at the top left instead of bottom left)\n",
    "    if correct_orientation:\n",
    "        ax.invert_yaxis()\n",
    "        ax.xaxis.tick_top()       \n",
    "\n",
    "    # resize \n",
    "    fig = plt.gcf()\n",
    "    fig.set_size_inches(cm_to_inch(figure_width, figure_height))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This function just inserts the text into the cells of the heatmap (idea is taken from [here](https://stackoverflow.com/a/25074150/14467732)):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_val(pc, fmt=\"%.2f\", **kw):\n",
    "    pc.update_scalarmappable()\n",
    "    ax = pc.axes\n",
    "    for p, color, value in zip(pc.get_paths(), pc.get_facecolors(), pc.get_array()):\n",
    "        x, y = p.vertices[:-2, :].mean(0)\n",
    "        if np.all(color[:3] > 0.5):\n",
    "            color = (0.0, 0.0, 0.0)\n",
    "        else:\n",
    "            color = (1.0, 1.0, 1.0)\n",
    "        ax.text(x, y, fmt % value, ha=\"center\", va=\"center\", color=color, **kw)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The last auxiliary function is intended to specify the size of the figure in centimeters in matplotlib, because by default there is only the method `set_size_inches`, therefore, we will convert inches to centimeters and use this method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cm_to_inch(*dim):\n",
    "    inch = 2.54\n",
    "    return tuple(i/inch for i in dim[0]) if type(dim[0]) == tuple else tuple(i/inch for i in dim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 align=\"center\">KNN Model</h2>\n",
    "\n",
    "The K-nearest neighbors (KNN) algorithm is a type of supervised machine learning algorithms. KNN is extremely easy to implement in its most basic form, and yet performs quite complex classification tasks.  It is a lazy learning algorithm since it doesn't have a specialized training phase. Rather, it uses all of the data for training while classifying a new data point or instance.  KNN is also a non-parametric learning algorithm, which means that it doesn't assume anything about the underlying data.\n",
    "\n",
    "\n",
    "KNN  algorithm simply calculates the distance of a new data point to all other training data points. The distance can be of any type e.g Euclidean or Manhattan etc. It then selects the K-nearest data points, where K can be any integer. Finally it assigns the data point to the class to which the majority of the K data points belong.\n",
    "\n",
    "Now, let's build KNN classifier model.\n",
    "\n",
    "First, we import the `KNeighborsClassifier` module and create KNN classifier object by passing argument number of neighbors in `KNeighborsClassifier()` function. Then, fit our model on the train set using `fit()` and perform prediction on the test set using `predict()`.\n",
    "\n",
    "One way to help find the best value of neighbors is to plot the graph of neighbor value and the corresponding error rate for the dataset. We will plot the mean error for the predicted values of test set for all the neighbor values between 1 and 25.\n",
    "To do so, let's first calculate the mean of error for all the predicted values where neighbor ranges from 1 and 25:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "\n",
    "error = []\n",
    "\n",
    "# calculating error for neighbor values between 1 and 25\n",
    "for i in range(1, 25):\n",
    "    knn = KNeighborsClassifier(n_neighbors=i)\n",
    "    knn.fit(x_train, y_train)\n",
    "    pred_i = knn.predict(x_test)\n",
    "    error.append(np.mean(pred_i != y_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next step is to plot the error values against neighbor values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Mean Error')"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10, 5))\n",
    "plt.plot(range(1, 25), error, color='black', linestyle='dashed', marker='o', markerfacecolor='green', markersize=10)\n",
    "plt.title('Error Rate Neighbor Value')\n",
    "plt.xlabel('Neighbor Value')\n",
    "plt.ylabel('Mean Error')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see, it is best to take k=5, but still mean error a little higher than normal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nearest Neighbors Result (k=20):\n",
      "-----------------------------------\n",
      "Accuracy Score (k=20): 72.91%\n",
      "Accuracy (x_train, y_train): 99.99%\n"
     ]
    }
   ],
   "source": [
    "# create KNN Classifier\n",
    "knn = KNeighborsClassifier(n_neighbors=20, weights='distance')\n",
    "\n",
    "# train the classifier using the training sets\n",
    "knn.fit(x_train, y_train)\n",
    "\n",
    "# predict the response for test dataset\n",
    "y_pred = knn.predict(x_test)\n",
    "\n",
    "print(\"Nearest Neighbors Result (k=20):\\n\" + '-' * 35)\n",
    "print(\"Accuracy Score (k=20):\", str(round(knn.score(x_test, y_test), 4) * 100) + '%')\n",
    "print(\"Accuracy (x_train, y_train):\", str(round(knn.score(x_train, y_train), 4) * 100) + '%')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The accuracy of the model is good, we can work with it.\n",
    "\n",
    "Now let's explore our KNN Classification results with help of `classification_report` function from sklearn.metrics:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Classification KNN:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.73      0.59      0.66      2499\n",
      "           1       0.73      0.83      0.78      3242\n",
      "\n",
      "    accuracy                           0.73      5741\n",
      "   macro avg       0.73      0.71      0.72      5741\n",
      "weighted avg       0.73      0.73      0.72      5741\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import classification_report\n",
    "print('\\nClassification KNN:\\n', classification_report(y_test, knn.predict(x_test)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now finally let's visualize our classification report:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 708.661x255.118 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_classification_report(classification_report(y_test, knn.predict(x_test)), title='KNN Classification Report')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 align=\"center\">Logistic Regression</h2>\n",
    "\n",
    "Logistic Regression is a Machine Learning classification algorithm that is used to predict the probability of a categorical dependent variable. In logistic regression, the dependent variable is a binary variable that contains data coded as 1 (yes, success, etc.) or 0 (no, failure, etc.). In other words, the logistic regression model predicts P(Y=1) as a function of X."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LogisticRegression(multi_class='ovr', n_jobs=1, solver='liblinear')"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "\n",
    "logit = LogisticRegression(solver='liblinear', multi_class='ovr', n_jobs=1)\n",
    "logit.fit(x_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy Score: 77.7%\n"
     ]
    }
   ],
   "source": [
    "print(\"Accuracy Score:\", str(round(logit.score(x_test, y_test), 4) * 100) + '%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Classification Logistic Regression:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.76      0.71      0.73      2499\n",
      "           1       0.79      0.83      0.81      3242\n",
      "\n",
      "    accuracy                           0.78      5741\n",
      "   macro avg       0.77      0.77      0.77      5741\n",
      "weighted avg       0.78      0.78      0.78      5741\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print('\\nClassification Logistic Regression:\\n', classification_report(y_test, logit.predict(x_test)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's visualize our classification report:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkcAAAD+CAYAAAAwGaFjAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAA1c0lEQVR4nO3deZxe4/3/8dd7ZrKKLJKIyIIQJYJoQ9GqpZZURapajVqqqPKztJZaSq3VUmpr0a+qfaeL0BBaa4k2QWyxJ8gmm0QsIZmZz++Pc2ZyZjJzzz1m7pm5Z97Px+PmPte5znVd556T+3zu67rOOYoIzMzMzCxR0toNMDMzM2tLHByZmZmZZTg4MjMzM8twcGRmZmaW4eDIzMzMLMPBkZmZmVmGgyPrsCT9SdKvvsB2QyV9LKm0EO1qqyQ9IOlHrVDvTpJmF7D8GseBpKMkzU//xn3T/w8rQL2vSNqpucs1s6aT73NkxUDSO8DhEfGvYq1b0iHAX4DlQCUwEzg9Iu5vahuLnaRtgLOB7Uk+m7eAqyPi+jSAuCUiBrdAOzoBy4BtI+KFZiz3BmB2RJzRXGXmqOsxYFugHPgMeAI4OiLmFbruetpyS0Rc29J1mzWFe47MWtbkiOgB9AauAu6Q1Lu5KymmXi1J2wGPAI8DGwF9gaOAb7VCcwYAXYFXWqHu5nRMepxtBPQALm7JypXw+cWKlg9eK2qSuki6TNLc9HWZpC6Z9SdLmpeuO1xSSNooXXeDpF+n7/tJul/SUkkfSHpSUomkm4GhwH3p8MrJktZPyylLt11L0vVpHUsk/aOhdkdEJXAzsAYwPLMvF0t6Lx3W+ZOkbo3Yl6slTZT0CbCzpHUl/VXSQkkzJR2XKWsbSVMlLUvruiRN7yrpFkmL089iiqQB6brHJB2evi+RdIakdyUtkHSTpF7puqrP50fpviySdHqOj+Mi4MaIuDAiFkXi2YjYr56/+amS3pb0kaTpkvbJrNtI0uOSPkzrvTNNl6RL07Yuk/SSpJHZ40DSxsDraVFLJT2Srs9+zt0k/T7d7w8l/afqbyTpbknvp+lPSNosTT8COAA4OT2G7kvT35G0a+ZvX+dxrHRYUdKJafvnSfpxjs+zWkQsBf4BjMp8RptIejg9zl+XtF9m3Q3pcfdw+vk+Lmm9zPrt02Piw/T/22fWPSbpfElPAZ+SHN87AH9M9/uP+bTZrC1wcGTF7nSSIYRRwJbANsAZAJLGACcAu5L8gt4pRzknArOB/iS9B78EIiIOAt4DxkZEj4j4XR3b3gx0BzYD1gYubajRSnp2fgysBN5Nky8ANk73ZSNgEHBmI/blh8D5wJrA08B9wAtpOd8Efi5pjzTv5cDlEdET2BC4K03/EdALGELSg3MkyTBgbYekr52BYSS9E7VPfl8HvpTWfaakTev4HLoD2wH31FFHfd4mOen2As4BbpE0MF13HvAQ0AcYDPwhTd8d+AbJ59sL2A9YnC00It4g+RsC9I6IXeqo+2LgKyTDf2sBJ5MMAwI8QBLorg08B9yalntN+v536TE0to5y6z2OU+uk7R4EHAZcKalPXR9OlqS+wHdJhimRtAbwMHBb2s7xwFWSRmQ2O4Dkc+wHTKvaD0lrAf8EriA5Ni4B/pnWUeUg4AiSY/AQ4EnSXqyIOKah9pq1FQ6OrNgdAJwbEQsiYiHJyfKgdN1+wPUR8UpEfEoyp6U+K4GBwHoRsTIinow8JuSlJ+VvAUdGxJJ028dzbLKtpKUkc0EuBg6MiAWSRHJSOT4iPoiIj4DfkJy88t2XeyPiqbRXanOgf0ScGxErImIG8OdMeSuBjST1i4iPI+KZTHpfYKOIqEh7cJbVUdcBwCURMSMiPgZOA8Yr7U1LnRMRy9O5Oy+QnPRr60PyPZT3fJiIuDsi5kZEZUTcCbxJEkxUtX89YN2I+Cwi/pNJXxPYhGSu5auNnYOjZJjoUOBnETEn/XyejojP03ZdFxEfpctnA1tW9ablIddxXNX+c9PjayLwMUngWZ8rJH0ILCIJco5N0/cC3omI6yOiPCKeB/4KfD+z7T8j4ol0P04HtpM0BPg28GZE3JxuezvwGpAN9m5Ij9HyiFiZ576btTkOjqzYrcuqnhfS9+tm1s3KrMu+r+0ikl/XD0maIenUPOsfAnwQEUvyzP9MRPQmCQomkPSAQNJj1R14Nh3OWgo8mKZDfvuSTVsPWLeqrLS8X5L0ikHS+7Ax8Fo6PLJXmn4zMIlkLtRcSb9TMkm5tro+97JM+QDvZ95/StK7VNsSkp6XgXWsq5OkgyVNy+zXSJIAAJKeHAH/U3I12KEAEfEISc/WlcACSddI6plvnal+JPOR3q6jTaWSLkiH+5YB72S2yUeu4xhgcUSUZ5br+zyrHBcRvYAtWNWLBslx8dVax8UBJD1TVaqPozTw/SBtS+02VrVzUF3bmhUzB0dW7OaSfOFXGZqmQdIbkb3CaUh9haS/+E+MiGHA3sAJkr5ZtTpH/bOAtdTISdXpSeco4CBJW5H8wl8ObBYRvdNXr3RSbb77km3nLGBmpqzeEbFmROyZ1v9mROxPMrRyIXCPpDXSnolzImIEydDRXsDBddRV1+deDsxv5OfwKTAZ2Def/On8lz8DxwB900DzZZKAiIh4PyJ+EhHrAj8lGTLaKF13RUR8BRhBEhj+ojFtJfkbfUYyDFnbD4FxJMOevYD1q5qc/r+hXshcx/EXFhEvAb8mGYYTyXHxeK3jokdEHJXZrPrYktSDZPhwbh1trGrnnGyVtZvQ1H0waw0OjqyYdFIyYbjqVQbcDpwhqb+kfiRzdG5J898F/FjSpunclnrvaSRpLyWTeQV8CFSwai7JfJJ5NatJh2YeIDkJ95HUSdI38tmZiPgAuBY4Mx0K+zNwqaS10zYNyswRyntfUv8DPpJ0ipJJxKWSRkraOi37QEn903qXpttUStpZ0ubpnKhlJMM5lXWUfztwvKQN0hPob4A7a/Vu5Otk4BBJv6iavyJpS0l31JF3DZIT7sI0349Jeo5Il78vqSqIXJLmrZS0taSvpr1gn5AEOXXtV73Sz+o64BIlk91LJW2nZOL0msDnJPOYupN8Hln1HkOpXMdxU91I0qO3N3A/sLGkg9JjtVP62WTng+0p6euSOpPMPXomImYBE9NtfyipTNIPSALNXLeiaGi/zdokB0dWTCaS9K5Uvc4m+VU8FXgReIlkIuyvASLiAZLJo4+SDJlVzav5vI6yhwP/IpnLMRm4KiIeTdf9luTEtVTSSXVsexBJEPEasAD4eSP26TKSk9EWwClV7UyHZv5FOq+kkftCRFSQ9PqMIrmf0iKSQKxqDswY4BVJH5NMzh4fEctJhlfuIQmMXiW5vP7mOqq4Lk1/Ii3/M1bNa2mUiHga2CV9zZD0AXANyd+7dt7pwO9J/kbzSeZWPZXJsjXw33S/JpDMD5oB9CQJPpeQDAUtJhlKbayTSI6zKSTDTReSfI/elJY7B5jOqr9Plb8AI9Jj6B91lFvvcdxUEbGC5G/8q3Qu2+4kc8/mkgx9Xgh0yWxyG3AWyf59BTgwLWcxyTF1IsnndzKwV0QsylH95cD3lFzFeUVz7I9ZS/BNIK3DSH8dvwx0+YI9HG1Ge9oXazvUgjerNGvL3HNk7ZqkfZTcQ6YPyS/k+4o1mGhP+2Jm1pY5OLL27qckQ11vk8wjOip39jatPe2LmVmb5WE1MzMzswz3HJmZmZllODgyMzMzyyhrOEvHtWav3tF3QN437jWr04L5Cwn/DrEm6ty5DHXu1nBGs1wi+HDezEUR0b/hzM2jpOfgoPyznHli+eJJETGmhZrUIAdHOfQfvB6/uW21W62YNcqpx53J3GWe22dNM+orw/h8/W1buxlW5CrLVzLlnD1rPwamsCo+p9Om++TMsuK5a/N91E6LcHBkVnDCT1Ews45LlJR1bu1GNIqDIzOzYiA1nMesLZJQSWlrt6JRHByZmZlZwQhQqYMjMzMzs4REqYfVzMzMzFIeVjMzMzNbRYBKiut2Jg6OzMzMrHBU4qvVzMzMzLI8rGZmZmZWRfLVamZWU/gGkGbWgUnFdxPI4pohZVaUHBxZ00VUtnYTzL4gUVJSmvOVVynSGEmvS3pL0ql1rB8q6VFJz0t6UdKeafpukp6V9FL6/10aqss9R2ZmZlY4avqcI0mlwJXAbsBsYIqkCRExPZPtDOCuiLha0ghgIrA+sAgYGxFzJY0EJgGDctXn4MjMzMwKRs3zbLVtgLciYgaApDuAcUA2OAqgZ/q+FzAXICKez+R5BegmqUtEfF5fZQ6OzMyKQXh41opU89wEchAwK7M8G/hqrTxnAw9JOhZYA9i1jnL2BZ7LFRiB5xyZmZlZQSXBUa4X0E/S1MzriC9Q0f7ADRExGNgTuFlSdZwjaTPgQuCnDRXkniMzsyKQ+Y43KyqSKOnU4LDaoogYnWP9HGBIZnlwmpZ1GDAGICImS+oK9AMWSBoM/B04OCLebqgx/tdmVmBCrd0EM7PWo7x6jhoyBRguaQNJnYHxwIRaed4DvplUqU2BrsBCSb2BfwKnRsRT+VTm4MjMzMwKqqnBUUSUA8eQXGn2KslVaa9IOlfS3mm2E4GfSHoBuB04JCIi3W4j4ExJ09LX2rnq87CaWcEJ3+vIms49kFa8SkqafvxGxESSy/OzaWdm3k8HvlbHdr8Gft2YuhwcmZkVA8dGVqQkUVJaXANVDo7MzMysoJqj56glOTgyMzOzwhHIwZGZmZlZQohSD6uZmZmZpdxzZGZmZlaTgyMzMzOzlASlZQ6OzMzMzKpJDo7MLCN8A0hrDuHjyIqTJF/Kb2a1+aRmTecg24pZSZmvVjMzMzNLCEo8rGZmZs3OHUdWpISvVjMzs4JwdGRFSqLUw2pmZtbc5CfPWhHz1WpmVkNyUvOvfmuiIju5mFVJhtVauxWN4+DIzMzMCkd4WM3MzMxsFXlYzcxq87CaNYMiO7mYVZHwTSDNzMzMqkhQ5mE1MzMzs1VK3XNkZmZmlhBycGRmZmZWRYLOHlaz9mDaU49y0+/OorKygp332Z9xhx5TY/1NF53N9ClPA/D5Z8tZ9sFi/vKf6QDcdtn5PP/kIwB894ifsd0ee7ds461N2X37kVzyix9SUiKu/8eTXHT9xBrrh6yzFn859zB6r9md0pISTv/DPTz4n5cYvdkGXP2rHwHJDeTO+9O93Pvoc62xC9YGbDusL8fvsTElEhOmzeHmp9+tsX5Azy6cufdm9OjaiVLBlY+8xeS3F9OzWyd+u+/mbLpuT/75wjx+P+n1VtqDjkuCMvccWbGrrKjg+t+ewS//dBt9Bwzk9AO+zVd23J3BG25cnefgX5xd/f7B26/jnddeAeC5J/7NzFdf5oI7J7Fy5QrOO+z7bPm1neneY82W3g1rA0pKxOWnHsieR/2e2fM/YPKtZ3L/49N4dcbc6jynHT6Wex6ewjV3P8amw9bl3j/8nI2/fTKvvD2HbQ84l4qKStbp14upd57D/U9Mo6KishX3yFpDieCkb32J4259ngXLPuP6w7bhyTcW8c6iT6rz/PjrG/Dv6fP523NzWL/fGlw6fhT7/PEpVpRXcM3jbzOsfw+G9e/RinvRcYnmmXMkaQxwOVAKXBsRF9RaPxS4Eeid5jk1Iiam604DDgMqgOMiYlKuugrWzyXpOkkLJL3cQL6fSzo4fX+epBclTZP0kKR10/QD0vSXJD0tactaZZRKel7S/Zm0WyW9LunltC2d0vS9JJ3b/Hvcfrz18jTWGbI+AwavR1mnzmy3xzimPvZQvfmffuBeth8zDoA5M95g0698ldKyMrp2687QjTfhhacea6GWW1uz9chhvD1rATPnLGRleQV3TfovY3caVSNPRNBzjW4A9OzRjXkLlwKw/LMV1YFQ186diPDtEDqqEev2YvYHy5m7dDnllcHDr8znGxv3r5EngDW6JL/3e3QpY+FHnwPw2cpKXpj1ISvKHVS3Fkl0LivN+cqjjFLgSuBbwAhgf0kjamU7A7grIrYCxgNXpduOSJc3A8YAV6Xl1auQg4A3pI2ol6Qy4FDgtjTpoojYIiJGAfcDZ6bpM4EdI2Jz4DzgmlpF/Qx4tVbarcAmwOZAN+DwNP2fwFhJ3Ru5Px3GkgXz6LvOwOrlvgPWYcmCeXXmXTh3NgvnzmLkNl8DYL2NR/DCU4/x+fLlLFvyAdOnTGbx/Ll1bmvt36C1ezN7/gfVy3PmL2Hd/n1q5Dnv/+7lh3tux4wHL2bCH37Ozy+8tXrd1iOHMe2e83ju7nM55vyb3WvUQfVfswsLln1Wvbzgo8/ov2aXGnmufWIGe2w+kAnHfZ1Lxo/y8FkbU1qinK88bAO8FREzImIFcAcwrlaeAHqm73sBVSefccAdEfF5RMwE3krLq1fBgqOIeAL4oIFsuwDPRUR5us2yzLo1SO+cFxFPR8SSNP0ZYHBVJkmDgW8D19aqf2KkgP9VbZMuPwbs9cX2zLImT7qXbXbdk5LSJAjfYvsdGfX1XTjrR+P4w6lHM3yLL1NS0vCvgvYs8Ak9lx+M+So33fcUw8acxN7HXsYNv/5J9d10p7w8g1Hf+xXbH3geJx+6J106d9yZABE+jnLZfbN1mPjCXPa+4j+ccMc0zh63mR/V20ZIzRIcDQJmZZZnp2lZZwMHSpoNTASObcS2NbT29PGvAc9mEySdL2kWcACreo6yDgMeyCxfBpwMdZ+B0uG0g4AHM8lTgR3qyX+EpKmSpn60ZHGeu9G+9Fl7IIvfX9VTtHj++/RZe2CdeZ9+cAJfG/OdGmn7/OQ4LrjrIU7/v9uJCAaut0Ehm2tt2JwFSxk8YK3q5UED+jB34ZIaeX78nR2456H/AfDfF9+mS+dO9Otdc27IazPn8fGnn7PZRoOxjmfhR5+zds+u1ctrr9m1etisythR6/KvV+cD8PKcD+lcVkLv7p1atJ1WNyE6l5bkfAH9qs696euIL1DV/sANETEY2BO4Wfpij7xt7eBoILAwmxARp0fEEJJhsRqXSEnamSQ4OiVd3gtYEBE1AqxargKeiIgnM2kLgHXryhwR10TE6IgYvWafvo3dn3Zhw8225P33ZrJgznuUr1zB5En38pUdd1st35yZb/HJsg8ZvuVXqtMqKyr4aGly8nv3jem89+ZrbLHdji3Wdmtbpr4yk42GDmD9dfvRqayU/fb4Kvc/Nq1Gnvfe/4Cdt0mmDmyywUC6dunEwiUfsf66/ShNvjQZOrAvX9pgIO/OXdTSu2BtwKtzlzFkrW4M7N2VshKx22YDePKNGqcO5n/4GVuvnwTi6/ftTueyUpZ8urI1mmu15NlztKjq3Ju+ak+fmQMMySwPTtOyDgPuAoiIyUBXoF+e29bQ2n3Uy0kaX5dbSbrFzgKQtAXJ0Nm3IqKqS+drwN6S9kzL6Snplog4MN3mLKA/8NNaZXdN67Y6lJaVccip5/Hbow6gsrKSncb9gCEbfYm7r7qIDUZsyeiddgdg8oP3sv2YvWs8ULC8fCXnHPpdALqt0YOjz7+C0rLWPsystVRUVPLzC2/hn1edQElJCTfe+x+mz5jLWUd9h2env8P9j0/jlEvu5Opf/YifHbg7EcHhZ/4FgK9tNZxf/HhPVpZXUFkZHPebm1m89ONW3qNW1IEnpFdEcPGDr3P5/ltRUiLunzaXmYs+4Sc7DuO1uct48s1FXP6vN/nltzdl/FeHEgHn3fdK9fZ/P+ZrdO9SRqdSseOX+nPcbc/XuNLNCq8ZrlabAgyXtAFJYDMe+GGtPO8B3wRukLQpybl+ITABuE3SJSQdI8NJptvUS4W8AkTS+sD9ETGynvVHAoMj4ox0eXhEvJm+P5ZkEvb30svzHgEOjoin6ylrJ+CkiNgrXT6cZLL3NyNiea28JwKdal8GWNuwzbaM39w2MVcWswadctyvmLes4XxmuWz75fVZscH2rd0MK3KV5SuZcs6ez0bE6Jaqc+DwkXHIZXflzHPBXps12Ka0I+Qyksv0r4uI89Orz6dGxIT0qrQ/Az1I5iyfHBEPpdueThITlAM/j4gH6qqjSsF+0ku6HdiJZBxxNnBWRPylVrYHgJszyxdI+hLJ/KF3gSPT9DOBviSX3wGU5/GH/VNaxuR0m79FRNUl/DsDp32R/TIzaw3ZHlqzYtMc9zlK71k0sVbamZn300lGlOra9nzg/HzrKlhwFBH755HnXUmLq3qMImLfevIdzqpL8esr6zGSq9CqluvcN0kDgG4R8VJD7TNrDkKkF16aNYGDIytOVXOOiklbmAxyKsnE7DdbqL6hwIktVJeZmVmH5merfQER8TrQYnfriogpLVWXWcI9R2bWcYm872XUZrR6cGRmZnnwnCMrYg6OzMzMzFIlHlYzMzMzy/CEbDMzM7NVhCgtsmFhB0dmZmZWMAI6uefIzMzMLCUocXBkZmZmlhB4WM3MzMysiofVzGw14RtAmllHJnlYzcxqc3BkTRdR2dpNMPtCBJR4WM3MzMws4WE1MzMzsyzfBNLMzAoiPDxrxcnDamZmZmYZQh5WMzOz5icV14M7zap5WM3MahPCV6yZWUeVDKu1disax8GRmZmZFUxytVpx9Xw6ODIrOPccWXMosp/eZlUEpcUVGzk4MjMrCo6NrEj5ajUzMzOzjORqteLqOiqu1pqZmVlxSYfVcr3yKkYaI+l1SW9JOrWO9ZdKmpa+3pC0NLPud5JekfSqpCuk3F1Z7jkyMzOzgmmOYTVJpcCVwG7AbGCKpAkRMb0qT0Qcn8l/LLBV+n574GvAFunq/wA7Ao/VV597jszMzKygSqWcrzxsA7wVETMiYgVwBzAuR/79gdvT9wF0BToDXYBOwPxclTU6OJLUR9IWDec0MzOzjk6AlPuVh0HArMzy7DRt9fqk9YANgEcAImIy8CgwL31NiohXc1WWV3Ak6TFJPSWtBTwH/FnSJflsa2ZmZh1biXK/gH6SpmZeRzShuvHAPRFRASBpI2BTYDBJQLWLpB1yFZDvnKNeEbFM0uHATRFxlqQXm9BwMzMz6wCU39DZoogYnWP9HGBIZnlwmlaX8cDRmeV9gGci4uO0PQ8A2wFP1ldZvsNqZZIGAvsB9+e5jZkB4RtAWnMIH0dWvJphWG0KMFzSBpI6kwRAE1avR5sAfYDJmeT3gB0llUnqRDIZu+nDasC5wCTg7YiYImkY8Gae25p1cD6pWdM5yLZilsewWk4RUQ4cQxKLvArcFRGvSDpX0t6ZrOOBOyJq/Jq4B3gbeAl4AXghIu7LVV9ew2oRcTdwd2Z5BrBvPtuamZlZxyXI94q0nCJiIjCxVtqZtZbPrmO7CuCnjakr3wnZG0v6t6SX0+UtJJ3RmIrMzKwJ3HFkRawZhtVaVL7Dan8GTgNWAkTEiyRdV2Zm1iIcHVnxKmng1dbke7Va94j4X627bZcXoD1mZlYH+cmzVqQkKM1nYlEbkm9wtEjShqQ/XSR9j+RGSmbWgOSk5l/91kRtcezBLE/FdvjmGxwdDVwDbCJpDjATOLBgrTIzM7N2QbTNobNc8r1abQawq6Q1gJKI+KiwzTIzM7N2oQiH1fK9Wu1nknoCnwKXSnpO0u6FbZpZe1FcXwrWRhXbuIRZhhp4tTX59nQdGhHLgN2BvsBBwAUFa5WZmZm1C6LpN4FsafnOOapq+p4kz1Z7RfLPGDMzM8tNtNNhNeBZSQ+RBEeTJK0JVBauWWZmZtZeFNuwWr49R4cBo4AZEfGppLWAHxesVWZmZtZOiJIiG2zKNzjaDpgWEZ9IOhD4MnB54ZrVRnz+KeUzpxEREFBSUlJjUmRDf+uIIPvsu6hM3peUltbI11A5lZWZTrpIypWESlZ1/Kn6P/W1BSIqM8vep+x2hdynoSxl+FprNNCGzH5U3RNJqnHjv4ZuAhhJpauVI9XsIG6wnAiy92VKyhHZkfR8bkjofaqnjC+4T53nz2Bkz061S0r/ndT6d9OAms/kTMtRzd/wjS2nrv34wm0B71N95TRxnyoqypmSxzbNSQQlRXavt3yDo6uBLSVtCZwIXAvcBOxYqIa1BWt178T+owa1djOsyD01YyYxe3FrN8OK3Ea7jOAbr8xs7WZYkVtZWcn/tUbFUVwzcfKdc1QeSeg5DvhjRFwJrFm4ZpmZmVl7oajM+Wpr8u05+kjSaSR3xf6Gkj7GTg1sY2ZmZh1etNueox8AnwOHRcT7wGDgooK1yszMzNqHCKisyP1qY/J9fMj7wCWZ5fdI5hyZmZmZ5dQWh85yyffxIdtKmiLpY0krJFVI+rDQjTNrD4rrGg1rq3wcWVGLytyvNibfOUd/BMYDdwOjgYOBjQvVKLP2pPoyXrMmCIdHVqwioLK8tVvRKPnOOSIi3gJKI6IiIq4HxhSuWWZmZtY+BFRW5n61Mfn2HH0qqTMwTdLvgHk0IrAyMzOzjqtdzjkCDgJKgWOAT4AhwL6FapRZuxIeDrGm81FkRasdX632bvp2OXBO4ZpjZmZm7U6R9RzlDI4kvUSOHywRsUWzt8isncnnmV1mDSnxcWRFrNiG1RrqOfouMACYVSt9CPB+QVpkZmZm7UjzXK0maQzJQ+9LgWsj4oJa6y8Fdk4XuwNrR0TvdN1QkufCDkkaxJ4R8U59dTUUHF0KnJYZVqtqQM903dj8dsnMzMw6pGj640MklQJXArsBs4EpkiZExPRV1cTxmfzHAltlirgJOD8iHpbUA8jZoIYmZA+IiJdqJ6Zp6zewrZmBb3JkzcKHkRUr0SwPnt0GeCsiZkTECuAOYFyO/PsDtwNIGgGURcTDABHxcUR8mquyhoKj3jnWdWtgWzPDJzUz6+gCKipyvxo2iJpTfGanaauRtB6wAfBImrQxsFTS3yQ9L+mitCeqXg0FR1Ml/aSOig8Hnm1gWzMzM+vognweH9JP0tTM64gm1DgeuCciqqKuMmAH4CRga2AYcEiuAhqac/Rz4O+SDmBVMDQa6Azs84WabGZmZh1KHkNniyJidI71c0gmU1cZnKbVZTxwdGZ5NjAtImYASPoHsC3wl/oqyxkcRcR8YHtJOwMj0+R/RsQjOTYzMzMzSzXL1WpTgOGSNiAJisYDP6ydSdImQB9gcq1te0vqHxELgV2Aqbkqy/cmkI8Cj+bVfDMzM7MqVXfIblIRUS7pGGASyaX810XEK5LOBaZGxIQ063jgjohVjyaIiApJJwH/liSSkbA/56ov32ermZmZmX0h0QwPl42IicDEWmln1lo+u55tHwbyvnG1gyMzMzMrnAgoX9HarWgUB0dmZmZWMEEQ+V2u32Y4ODIrMD9N3ZpDcT2ZyiwjgGYYVmtJDo7MCizwjSCtOTjMtiIVlYSH1czMzMwy3HNkZmbNzf1GVryCaOKl/C3NwZFZoYVPa2bWgUVA+crWbkWjODgyMysCnrdmRSvw1WpmVpN8WrNm4OPIilfT75Dd0hwcmZmZWeFEEB5WMzMzM6viniMzq0XylUbWdB5Us6IVODgyMzMzqxIeVjMzMzPL8rCamZmZ2Sq+lN/MzMwsyzeBNDMzM1sl/PgQMzMzsxrCD541MzMzS0RlULmivLWb0SgOjszMzKyAwj1HZlZTJb6BnzVdpW8lasUqICocHJmZmZkByU0gK1b4ajVrBx58/ClOOOciKiorOfQH3+GUow6tsf6E8y7m8clTAPh0+WcsWPwBi198EoD35szjiFPPZfa8+Uhw3/V/ZP3B67b4PljbMGKPHdnv8jMpKS3lqWvvZNKFV9dY//1LfsXGO28HQOfuXVlz7X6c0GcLAI594EY22HYr3vrPFK4ae1iLt93ajl5f2ZqhRx2DSkpY+OBE5t11e431Q4/4f6y55SgASrt0oax3H5773t50XnsAw888FyRUVsb8e//Owon3tcIedGweVktJGgNcDpQC10bEBfXkuwz4W0Q8IelWYDSwEvgf8NOIWJnJuzUwGRgfEfekaRcC306znBcRd6bpuwAXA52BZ4HDIqJc0l7ANhFxZnPvc3tRUVHBcWdewIM3X83gdQaw7bgDGLvrjowYvmF1nkt+dVL1+z/ecDvTpr9evXzIib/itKMPZ7cdtuXjTz6lpKSDDypFxx0OUUkJ+195LpfvdiBLZr/PaVMm8OKEh5n36lvVee4+4bzq9zsd8yOGbLVZ9fJDF/0fnbt3Y4ef/rBF290WddyjCCgpYb2jf8brv/wFKxYtZLMrrmbJM0/z2XvvVmd575qrqt8P2Hsfum+4EQArP1jM9OOPIVaupKRrVzb/v+tY+szTrPxgcYvvRocV0SzDag3FFZIuBXZOF7sDa0dE78z6nsB04B8RcUyuukqa3No6SCoFrgS+BYwA9pc0oo58fYFtI+KJNOlWYBNgc6AbcHitMi8EHsqkfRv4MjAK+CpwkqSekkqAG0mCqJHAu8CP0s3+CYyV1L3Zdrid+d8LL7PhekMYNnQwnTt3Yr+xezDh4cfqzX/HfQ/yg7FjAJj+5tuUV1Sw2w7bAtBjje5079atJZptbdD624xiwVvvsmjmLCpWrmTKHfexxbjd682/9f57M/X2CdXLrz/yNJ9/9ElLNNXasB5f2oTP583h8/fnEeXlLH78Efpst329+dfaaRcWP/YIAFFeTqxMfmOXdOqcPAnaWlREULmyPOerIfnEFRFxfESMiohRwB+Av9Uq5jzgCfJQkOAI2AZ4KyJmRMQK4A5gXB359gUerFqIiImRIuk5GpzJeyzwV2BBJm0E8ERElEfEJ8CLwBigL7AiIt5I8z2c1kVa9mPAXk3ey3Zq7vsLGDJwQPXy4HUGMPf9hXXmfXf2XN6ZNZddtt8agDdnvkfvnmvyvSNPZPS3x3Pyby6loshuG9/cOvJXcZ9BA1gya2718tLZ8+gzaECdedcaOoh+GwzhtUeebqnmFZWOfBx16tuPzxeu+upfsWgRnfv2rzNv57UH0GWddVj2wvOr0vr1Z+TVf2bLm+9g3t13uNeoFVRWVOZ85SHfuKLK/kD12KukrwADyHSw5FKo4GgQMCuzPDtNq+1rJENeNUjqBBxEGjhJGgTsA1xdK+sLwBhJ3SX1I+lOGwIsAsokjU7zfS9NrzIV2KGR+2R1uPP+Sez7rW9SWloKQHl5Of+Z8jy/++XxPHPvLcycNZsb75nQQCntXUc+reVv9PixPHfPxKKbm9BS5OMoL3133JklTz4BmeNoxaKFvHzUT3jx0IPot+selPXu04ot7IDSq9VyvfKQb1yBpPWADYBH0uUS4PfASXXlr0uhgqN8DQTq6pK4iqRH6Ml0+TLglIio8QlGxEPAROBpkghxMlCR9g6NBy6V9D/gIyDbfbEAqHOGsKQjJE2VNHXh4qVfdL+K2rrrrM2sefOrl2e/P59116n7V9pd903iB3uPqV4eNHAAW266McOGDqasrIxxu+3M8y+/VvA2W9u0ZM58+gxZ9U+t9+CBLJkzv868o8ePZcrtHT2QtrqsXLyILv3Xrl7u3K8fKxbX3Zu91o47Vw+prVbOB4tZ/s5M1hy5eUHaaXXLc1itX9W5N30d0YQqxwP3RETVef//ARMjYna+BRQqOJpDzZ6awWlabcuBrtkESWcB/YETMsmjgTskvUPSC3SVpO8ARMT56RjjbiQ/0d9I0ydHxA4RsQ3JGOMbmfK6pnWvJiKuiYjRETG6f9/e+e1tO7P1Fpvx1jvvMXPWHFasWMld901i7K47rZbvtbdnsuTDZWz35S1rbPvhso9YuPgDAB6dPIVNhw9rqaa3TR34B/+7U15g7eHr03f9wZR26sTW48fy4oSHV8s34EsbskafXsyY/FwrtNLauo9ff40u6w6i84B1UFkZfXfchaXPTF4tX9fBQyhbc00+fvWV6rRO/fqhzp0BKO3RgzU3G8lns2ettq0VUDohu4Geo0VV5970dU2tUvKNKyAJjrKXM24HHJPGEBcDB0uq8yKxKoW6Wm0KMFzSBiSNHw/UdbnJq8BGJHOAkHQ4sAfwzWwvUURsUPVe0g3A/RHxj3SCVu+IWCxpC2AL0vFESWtHxAJJXYBTgPMz9W4MvNxM+9rulJWVcfk5p7Dnwf+PispKDvn+ODbbeEPOuuQqRm8+grG77QTAnfdNYr+xe6DMBMfS0lIu/OUJ7H7AkQTBl0duyuHjv9tKe9I2iI57pVFlRQV3HnMmx026iZLSUp6+7i7mTX+Tseccz7tTX+LF+/4FwNbjxzLljtUvrz7xibtYZ5MN6dJjDX47azI3H3YK0x/Kaz5lu9OBY2yorOTdq/7AJudfCCWlLHzoAZa/+w6DDjqET958g6XPJPPU+u60C4sfe7TGpt2GrMfQI45M/hEK5v31Lpa/M7MVdqJja4ar1fKKKyRtAvQhGUlK6o44ILP+EGB0RJyaqzJFgS4zlrQnyXBYKXBdRJxfR54dSC7XPzBdLie5suyjNMvfIuLcWtvcQBIc3SOpK1D1U3MZcGRETEvzXUQy6boEuDoiLsuUcT9wWkS8lGsfRm8xIv474bZG7LXZ6o7Z4TBitieAWtNstMsIvtHps9ZuhhW5lZWVfP3hx5+NiNEN524em6/TNyYcuGfOPMN+f0uDbaorrpB0LjA1Iiakec4GutYX/GSCo5yX8hfsPkcRMZFkPlCuPE9K+q2k3hGxNCIabE9EHJJ5/xnJFWt15fsF8Iva6ZIGAN0aCozMzMysGQREM1y1XFdcUfuehRFxdgNl3ADc0FBdbeEO2ScCQ4GlLVTf0LROMzMzKzg/eLbRIuK/LVzflJasz8zMrEOLoHJFwzd6bEtaPTgyMzOz9iuCfG/02GY4ODIzM7MC8rCamZmZ2SqVULmiuB4j5eDIrMA66j2OrHn5OLJiFYSH1cyspvTec2ZNEg6PrFgFRGVxHb8OjszMzKxgIqDCw2pmZmZmqQiiwj1HZpZVoEf0WMfio8iKWaWDIzMzM7NEBFSs9LCamWXI07GtGZT4OLJi5WE1MzMzs5p8Kb+ZmZlZKiqhcoWDIzPL8miINQMfRla8fBNIM6tF+EojM+vAfBNIMzMzs1UiwjeBNDMzM8vy1WpmZmZmqQjfBNLMzMxslQjfBNLMzMysWnhYzczMzKxaAOFL+c3MzMxSEVQU2U0gS1q7AWbtXXF1JltbVVynFrNVIqAyIucrH5LGSHpd0luSTq1j/aWSpqWvNyQtTdNHSZos6RVJL0r6QUN1uefIrMAC393YmoPDbCteFXkGQPWRVApcCewGzAamSJoQEdOr8kTE8Zn8xwJbpYufAgdHxJuS1gWelTQpIpbWV5+DIzMzMyuYAFY0/Q7Z2wBvRcQMAEl3AOOA6fXk3x84CyAi3qhuS8RcSQuA/sDS+irzsJqZWRFwv5EVqwAqIvcrD4OAWZnl2WnaaiStB2wAPFLHum2AzsDbuSpzz5FZoTWxO9nMrJhF5DWs1k/S1MzyNRFxzRescjxwT0TUuLmSpIHAzcCPIiLnND4HR2ZmRcDz1qyY5dE7tCgiRudYPwcYklkenKbVZTxwdDZBUk/gn8DpEfFMQ41xcGRWYPJpzZqBjyMrVpVEc8w5mgIMl7QBSVA0Hvhh7UySNgH6AJMzaZ2BvwM3RcQ9+VTmOUdmZmZWUE2dcxQR5cAxwCTgVeCuiHhF0rmS9s5kHQ/cEVFjHG8/4BvAIZlL/Uflqs89R2ZmZlYwec45yqOcmAhMrJV2Zq3ls+vY7hbglsbU5eDIrMAkX2lkTedBNStWzXQpf4tycGRmZmYFU3UpfzFxcGRmZmYF1RzDai3JwZGZmZkVTISH1czMzMyqBcX34GQHR2ZmZlZA4WE1MzMzsyqVeFjNzMzMbJX8Hy7bZjg4MjMzs4JJLuUvrujIwZFZgVXiG/hZ01X6VqJWpHwTyHbmsxXlvDHr/erlkpISpPxPc5WVlUQd0XJpaWmj2lFRUbFamiRKSvJ/NF5EUFm5+vUC3qfC71PpOn3o1qtnzm3rql+ocVFVQNRxAm3MZ5G0JS2sdmsaGeF5n+or5Ivt04puXVnYu9dq2wpR0sgdqYg6/t2gRn2uEVFnwFaqxj2yszLC+1SPQuxTeUXLXzdWjDeBVF3/2C0haSHwbmu3o43rByxq7UZY0fNxZM3Fx1LD1ouI/i1VmaQHSf4uuSyKiDEt0Z58ODiyJpE0NSJGt3Y7rLj5OLLm4mPJmkPj+grNzMzM2jkHR2ZmZmYZDo6sqa5p7QZYu+DjyJqLjyVrMs85MjMzM8twz5GZmZlZhoOjDkRShaRpkl6WdLek7s1Q5rmSds2x/khJBze1HisOtY6x+yT1buby35HUL33/cXOWba0jc8xUvdaX1FfSo5I+lvTH1m6jdTweVutAJH0cET3S97cCz0bEJZn1ZRFR3moNtKJX6xi7EXgjIs5vxvLfAUZHxKJsXVa86vo7SloD2AoYCYyMiGNaqC3+DjTAPUcd2ZPARpJ2kvSkpAnAdEmlki6SNEXSi5J+WrWBpFMkvSTpBUkXpGk3SPpe+v4CSdPT7S5O086WdFL6fpSkZ9L1f5fUJ01/TNKFkv4n6Q1JO7T0h2EFMRkYBCBpQ0kPSno2Pd42SdMHpMfCC+lr+zT9H2neVyQd0Yr7YK0gIj6JiP8An+XKJ2mz9HtjWvq9MjxNPzhdfkHSzWna+pIeSdP/LWlomn6DpD9J+i/wu/qOVetY/PiQDkhSGfAt4ME06cskv85mpieiDyNia0ldgKckPQRsAowDvhoRn0paq1aZfYF9gE0iIuoZTrkJODYiHpd0LnAW8PN0XVlEbCNpzzS93qE6a/sklQLfBP6SJl0DHBkRb0r6KnAVsAtwBfB4ROyTblPVg3BoRHwgqRswRdJfI2JxC++GtYxukqal72dGxD6N2PZI4PKIuFVSZ6BU0mbAGcD2aQ9j1XfVH4AbI+JGSYeSHHvfSdcNTvNXSPo3dR+r1oE4OOpYsl9CT5KcuLYH/hcRM9P03YEtqnqDgF7AcJJg5fqI+BQgIj6oVfaHJL/y/iLpfuD+7EpJvYDeEfF4mnQjcHcmy9/S/z8LrP9Fd9BaXdUxNgh4FXhYUg+S4+xurXomVJf0/7sABwNERAXJcQRwnKSqk+QQkmPQwVH7tDwiRn3BbScDp0saDPwtDWh2Ae6OiEVQ47tqO+C76fubgd9lyrk7DYxyHavWgTg46lhW+xJKvwA+ySaR9O5MqpVvj1wFR0S5pG1Iegu+BxxD435tfZ7+vwIfl8VseUSMUjLZfxJwNHADsDTfE6CknUiC8e3SXsrHgK6FaKwVlzRgPitdPDwibkuHw74NTMxOA2ikqu/AEhpxrFr75TlHVtsk4ChJnQAkbZxOjnwY+HF60qOOYbUeQK+ImAgcD2yZXR8RHwJLMvOJDgIex9qltIfxOOBE4FNgpqTvAyhRdXz8GzgqTS9Nexh7AUvSwGgTYNsW3wFrkyLi7xExKn1NlTQMmBERVwD3AlsAjwDfT4f6s99VTwPj0/cHkPSe1y5/GfUfq9aB+Be61XYtybDWc0q6lRYC34mIByWNAqZKWgFMBH6Z2W5N4F5JXUl6n06oo+wfAX9KA6wZwI8LthfW6iLieUkvAvuTnIyulnQG0Am4A3gB+BlwjaTDSHoNjyKZC3ekpFeB14FnWqP91rqUXJnYE+gs6TvA7hExvVa2/YCDJK0E3gd+k85VOx94XFIF8DxwCHAscL2kX5B8r9X3/VPfsWodiC/lNzMzM8vwsJqZmZlZhoMjMzMzswwHR2ZmZmYZDo7MzMzMMhwcmZmZmWU4ODKzJpEUkm7JLJdJWpjeKT3XdqPSx8XUt360pCuas61mZvlwcGRmTfUJMDJ9DhrAbsCcPLYbBdQZHCl5OvrUiDiueZpoZpY/B0dm1hwmkjzCAZKbPt5etULSGpKuS5+e/rykcelDQs8FfpA+Uf0Hks6WdLOkp4CbJe1U1fskqYek6yW9lD5Vfd/0jto3SHo5TT++pXfazNonB0dm1hzuAMand0jfAvhvZt3pwCMRsQ2wM3ARyZ2HzwTuTB8FcWeadwSwa0TsX6v8XwEfRsTmEVH1iIhRwKCIGBkRmwPXF2jfzKyDcXBkZk0WES+SPHZmf5JepKzdgVMlTQMeI3mI7NB6ipoQEcvrSN8VuDJT3xKSR9AMk/QHSWOAZU3YBTOzag6OzKy5TAAuJjOklhKwb+aBoUMj4tV6yviknvTVpAHSliQB15EkzwU0M2syB0dm1lyuA86JiJdqpU8Cjk0fZIykrdL0j0geWJyPh4GjqxYk9ZHUDyiJiL8CZwBfbkrjzcyqODgys2YREbMjoq5L788jmWP0oqRX0mWAR4ERVROyGyj+10CfdPL1CyRzlwYBj6XDdbcApzXHfpiZKSJauw1mZmZmbYZ7jszMzMwyHByZmZmZZTg4MjMzM8twcGRmZmaW4eDIzMzMLMPBkZmZmVmGgyMzMzOzDAdHZmZmZhn/H1n5Bx339CaNAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 708.661x255.118 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_classification_report(classification_report(y_test, logit.predict(x_test)), title='Logistic Regression Classification Report')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 align=\"center\">Random Forest Classifier</h2>\n",
    "\n",
    "The Random forest or Random Decision Forest is a supervised Machine learning algorithm used for classification, regression, and other tasks using decision trees.\n",
    "\n",
    "The Random forest classifier creates a set of decision trees from a randomly selected subset of the training set. It is basically a set of decision trees (DT) from a randomly selected subset of the training set and then It collects the votes from different decision trees to decide the final prediction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy Score: 75.74%\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "clf = RandomForestClassifier(n_estimators=100)\n",
    "clf.fit(x_train, y_train)\n",
    "\n",
    "print(\"Accuracy Score:\", str(round(clf.score(x_test,y_test), 4) * 100) + '%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Classification Random Forest:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.77      0.62      0.69      2499\n",
      "           1       0.75      0.86      0.80      3242\n",
      "\n",
      "    accuracy                           0.76      5741\n",
      "   macro avg       0.76      0.74      0.75      5741\n",
      "weighted avg       0.76      0.76      0.75      5741\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print('\\nClassification Random Forest:\\n', classification_report(y_test, clf.predict(x_test)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's visualize our classification report:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 708.661x255.118 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_classification_report(classification_report(y_test, clf.predict(x_test)), title='Random Forest Classification Report')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 align=\"center\">SVM Model</h2>\n",
    "\n",
    "Support vector machines (SVMs) are a set of supervised learning methods used for classification, regression and outliers detection.\n",
    "\n",
    "The advantages of support vector machines are:\n",
    "\n",
    "    + Effective in high dimensional spaces.\n",
    "\n",
    "    + Still effective in cases where number of dimensions is greater than the number of samples.\n",
    "\n",
    "    + Uses a subset of training points in the decision function (called support vectors), so it is also memory efficient.\n",
    "\n",
    "    + Versatile: different Kernel functions can be specified for the decision function. Common kernels are provided, but it is also possible to specify custom kernels.\n",
    "\n",
    "The disadvantages of support vector machines include:\n",
    "\n",
    "    - If the number of features is much greater than the number of samples, avoid over-fitting in choosing Kernel functions and regularization term is crucial.\n",
    "\n",
    "    - SVMs do not directly provide probability estimates, these are calculated using an expensive five-fold cross-validation (see Scores and probabilities, below)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy Score: 75.05%\n"
     ]
    }
   ],
   "source": [
    "from sklearn import svm\n",
    "\n",
    "SVM = svm.SVC(C=1.0, kernel='linear', degree=3, gamma='auto', probability=True)\n",
    "SVM.fit(x_train, y_train)\n",
    "\n",
    "print(\"Accuracy Score:\", str(round(SVM.score(x_test, y_test), 4) * 100) + '%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Classification SVM:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.75      0.69      0.72      2499\n",
      "           1       0.77      0.82      0.80      3242\n",
      "\n",
      "    accuracy                           0.76      5741\n",
      "   macro avg       0.76      0.75      0.76      5741\n",
      "weighted avg       0.76      0.76      0.76      5741\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print('\\nClassification SVM:\\n', classification_report(y_test, SVM.predict(x_test)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 708.661x255.118 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_classification_report(classification_report(y_test, SVM.predict(x_test)), title='SVM Classification Report')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 align=\"center\">Comparison of Models</h2> \n",
    "\n",
    "A useful tool when predicting the probability of a binary outcome is the Receiver Operating Characteristic curve, or ROC curve.\n",
    "\n",
    "It is a plot of the false positive rate (x-axis) versus the true positive rate (y-axis) for a number of different candidate threshold values between 0.0 and 1.0. Put another way, it plots the false alarm rate versus the hit rate.\n",
    "\n",
    "The true positive rate is calculated as the number of true positives divided by the sum of the number of true positives and the number of false negatives. It describes how good the model is at predicting the positive class when the actual outcome is positive.\n",
    "\n",
    "The false positive rate is calculated as the number of false positives divided by the sum of the number of false positives and the number of true negatives.\n",
    "\n",
    "It is also called the false alarm rate as it summarizes how often a positive class is predicted when the actual outcome is negative.\n",
    "\n",
    "To make this clear:\n",
    "* Smaller values on the x-axis of the plot indicate lower false positives and higher true negatives.\n",
    "* Larger values on the y-axis of the plot indicate higher true positives and lower false negatives."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import metrics\n",
    "from sklearn.metrics import roc_curve, auc\n",
    "\n",
    "fprKNN, tprKNN, thresholdsKNN = metrics.roc_curve(y_test, knn.predict_proba(x_test)[:, 1])\n",
    "fprLR, tprLR, thresholdsLR = metrics.roc_curve(y_test, logit.predict_proba(x_test)[:, 1])\n",
    "fprCLF, tprCLF, thresholdCLF = metrics.roc_curve(y_test, clf.predict_proba(x_test)[:, 1])\n",
    "fprSVM, trpSVM, thresholdSVM = metrics.roc_curve(y_test, SVM.predict_proba(x_test)[:, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "linewidth = 2\n",
    "plt.figure(figsize=(8, 5))\n",
    "\n",
    "plt.plot(fprKNN, tprKNN, color='#db6114', lw=linewidth, label='ROC Curve KNN (AUC = %0.3f)' % auc(fprKNN, tprKNN))\n",
    "plt.plot(fprLR, tprLR, color='#1565c0', lw=linewidth, label='ROC Curve Logistic Regression (AUC = %0.3f)' % auc(fprLR, tprLR))\n",
    "plt.plot(fprCLF, tprCLF, color='#2e7d32',lw=linewidth, label='ROC Curve Random Forest (AUC = %0.3f)' % auc(fprCLF, tprCLF))\n",
    "plt.plot(fprSVM, trpSVM, color='#6557d2',lw=linewidth, label='ROC Curve SVM (AUC = %0.3f)' % auc(fprSVM, trpSVM))\n",
    "plt.plot([0, 1], [0, 1], color='#616161', lw=linewidth, linestyle='--')\n",
    "\n",
    "plt.xlim([0.0, 1.0])\n",
    "plt.ylim([0.0, 1.05])\n",
    "\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.title('ROC Curve Plots')\n",
    "plt.legend(loc=\"lower right\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Based on these data, we can conclude that the best model so far is a **Logistic Regression Model** with `AUC = 83.6%` and `Accuracy Score = 75.67%`.\n",
    "\n",
    "Let's save this model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('LogitModel.pickle', 'wb') as m:\n",
    "    pickle.dump(logit, m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's check if everything is loaded correctly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Logistic Regression Accuracy Score: 77.7%\n"
     ]
    }
   ],
   "source": [
    "with open('LogitModel.pickle', 'rb') as m:\n",
    "     logit = pickle.load(m)\n",
    "\n",
    "print(\"Logistic Regression Accuracy Score:\", str(round(logit.score(x_test, y_test), 4) * 100) + '%')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the next part we will finally try the **LSTM** neural network, which takes a sequence of words and remembers the order of words in a sentence, this approach should give us the best results."
   ]
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}