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 needed to create vector words. For simplicity, we used a pre-trained model.\n",
    "\n",
    "Google was able to teach the Word2Vec model on a massive Google News dataset that contained over 100 billion different words! Google has created [3 million vector words](https://code.google.com/archive/p/word2vec/#Pre-trained_word_and_phrase_vectors) from this model, each with a dimension of 300. We would use these vectors.\n",
    "\n",
    "#### How word2vec works:\n",
    "\n",
    "The idea behind word2vec is that:\n",
    "\n",
    "    Take a 3 layer neural network. (1 input layer + 1 hidden layer + 1 output layer)\n",
    "    Feed it a word and train it to predict its neighbouring word.\n",
    "    Remove the last (output layer) and keep the input and hidden layer.\n",
    "    Now, input a word from within the vocabulary. The output given at the hidden layer is the ‘word embedding’ of the input word.\n",
    "    \n",
    "Two popular examples of methods of learning word embeddings from text include:\n",
    "\n",
    "    Word2Vec\n",
    "    GloVe\n",
    "\n",
    "To get started, let's download the necessary libraries:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "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: 38544\n"
     ]
    }
   ],
   "source": [
    "print(\"Number of documents:\", len(docs))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next operation may take some time, as the model contains 3 000 000 words, so we will get a 3 000 000 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('model/GoogleNews-vectors-negative300.bin', binary=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's get a list of all the words from our dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['</s>', 'in', 'for', 'that', 'is', 'on', '##', 'The', 'with', 'said', 'was', 'the', 'at', 'not', 'as', 'it', 'be', 'from', 'by', 'are', 'I', 'have', 'he', 'will', 'has', '####', 'his', 'an', 'this', 'or', 'their', 'who', 'they', 'but', '$', 'had', 'year', 'were', 'we', 'more', '###', 'up', 'been', 'you', 'its', 'one', 'about', 'would', 'which', 'out'] \n",
      "\n",
      "Total words: 3000000 \n",
      "\n",
      "Word-Vectors shape: (3000000, 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 \"football\" in our word list and then access the corresponding vector through the embedding matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-9.76562500e-02  3.19824219e-02  2.57812500e-01 -4.15039062e-02\n",
      "  1.01562500e-01 -1.00585938e-01  1.46484375e-01 -1.99218750e-01\n",
      "  1.53320312e-01  6.34765625e-02  8.39843750e-02 -3.00781250e-01\n",
      "  6.34765625e-02  2.08984375e-01 -2.11914062e-01  1.88476562e-01\n",
      " -8.34960938e-02  3.28125000e-01  2.79296875e-01 -1.40625000e-01\n",
      " -1.68945312e-01  2.04101562e-01  4.90722656e-02 -6.98852539e-03\n",
      "  9.42382812e-02  9.84191895e-04  3.12500000e-02  2.48046875e-01\n",
      "  3.35937500e-01  2.63671875e-01  5.68847656e-02  3.04687500e-01\n",
      "  1.21582031e-01 -1.97265625e-01  1.72119141e-02  9.96093750e-02\n",
      "  2.27539062e-01 -1.20605469e-01  1.23535156e-01  3.78906250e-01\n",
      "  2.36816406e-02 -1.86523438e-01  6.29882812e-02  1.52343750e-01\n",
      "  3.73535156e-02 -1.69921875e-01  1.06445312e-01 -4.98046875e-02\n",
      " -6.20117188e-02  1.68945312e-01  4.41894531e-02  2.78320312e-02\n",
      " -1.10839844e-01  4.49218750e-02  2.78320312e-02 -4.45312500e-01\n",
      "  3.49121094e-02 -6.22558594e-02 -3.93066406e-02 -2.01171875e-01\n",
      " -3.04687500e-01 -1.00585938e-01 -1.64062500e-01  1.52343750e-01\n",
      "  1.10351562e-01 -1.53320312e-01 -7.12890625e-02  7.95898438e-02\n",
      "  1.87500000e-01  6.88476562e-02  2.44140625e-01 -6.56127930e-04\n",
      " -1.91406250e-01  3.49121094e-02  1.97753906e-02 -5.41992188e-02\n",
      "  3.32031250e-02 -2.08007812e-01  9.86328125e-02 -1.90429688e-01\n",
      " -6.07910156e-02 -2.07031250e-01 -2.18505859e-02  8.78906250e-02\n",
      "  2.08984375e-01 -2.36328125e-01 -9.17968750e-02  2.26562500e-01\n",
      " -3.93066406e-02  9.13085938e-02  1.13525391e-02 -1.55273438e-01\n",
      "  6.78710938e-02 -4.90722656e-02  2.51770020e-03 -4.66308594e-02\n",
      "  9.17968750e-02  1.05957031e-01  2.10937500e-01  4.24804688e-02\n",
      " -4.95605469e-02  1.76757812e-01  3.32031250e-01 -4.22363281e-02\n",
      "  2.03125000e-01  2.98828125e-01  1.21093750e-01 -4.85839844e-02\n",
      " -1.41601562e-01 -2.51953125e-01 -2.20703125e-01  2.23632812e-01\n",
      "  2.22167969e-02  1.09375000e-01  3.14453125e-01  3.71093750e-01\n",
      " -4.83398438e-02  2.77343750e-01  1.27563477e-02 -9.61914062e-02\n",
      " -2.03125000e-01 -1.55273438e-01  1.10351562e-01 -6.54296875e-02\n",
      " -2.75390625e-01 -2.34375000e-01 -3.78906250e-01 -8.30078125e-02\n",
      " -1.25000000e-01 -1.40625000e-01 -9.27734375e-03 -4.21875000e-01\n",
      " -1.17187500e-01 -2.41210938e-01  3.44238281e-02  5.34057617e-03\n",
      " -2.98828125e-01  3.45703125e-01 -6.54296875e-02  5.54199219e-02\n",
      " -5.17578125e-02 -1.12792969e-01  2.01171875e-01  2.97851562e-02\n",
      "  1.05468750e-01  2.75390625e-01  1.02050781e-01 -1.66992188e-01\n",
      " -7.08007812e-02 -2.96875000e-01  1.50390625e-01  2.94921875e-01\n",
      " -1.97265625e-01  4.85839844e-02 -4.27734375e-01  1.55639648e-02\n",
      "  1.20605469e-01 -1.70898438e-01  6.68945312e-02 -1.50390625e-01\n",
      " -5.27343750e-02  6.49414062e-02  3.78417969e-02  1.74560547e-02\n",
      "  1.44531250e-01 -1.47460938e-01  1.07421875e-01 -1.96289062e-01\n",
      " -5.20019531e-02 -6.29882812e-02 -1.71875000e-01  2.25830078e-02\n",
      " -5.27954102e-03 -1.22558594e-01 -6.25000000e-02  8.85009766e-04\n",
      "  1.84326172e-02  1.12792969e-01 -1.11328125e-01  1.00731850e-05\n",
      "  2.41210938e-01  6.64062500e-02 -2.45361328e-02  1.89208984e-02\n",
      " -1.83105469e-02  3.06640625e-01  1.83105469e-02 -3.85742188e-02\n",
      "  1.81640625e-01  2.27355957e-03  1.45507812e-01  6.73828125e-02\n",
      " -1.68457031e-02  1.87500000e-01 -1.21093750e-01  2.17285156e-02\n",
      "  1.29882812e-01  1.55273438e-01 -7.81250000e-02  5.05371094e-02\n",
      " -7.66601562e-02 -1.18164062e-01  4.51660156e-02 -3.71093750e-02\n",
      "  2.48046875e-01 -3.10546875e-01  1.98242188e-01 -2.37304688e-01\n",
      " -2.18505859e-02 -9.76562500e-02 -1.08032227e-02  1.69921875e-01\n",
      "  1.13769531e-01 -5.17578125e-02 -1.94335938e-01  9.47265625e-02\n",
      "  1.28906250e-01  2.05078125e-02 -2.77343750e-01 -8.69140625e-02\n",
      "  1.26342773e-02 -4.57031250e-01 -1.33789062e-01 -8.15429688e-02\n",
      "  2.89062500e-01  1.89453125e-01  1.62109375e-01 -1.64794922e-02\n",
      "  3.75366211e-03 -1.38671875e-01 -1.04980469e-01 -1.20117188e-01\n",
      " -1.13525391e-02  5.15136719e-02  4.68750000e-02 -8.93554688e-02\n",
      "  2.56347656e-02 -2.77343750e-01  1.05468750e-01 -1.03027344e-01\n",
      "  2.07031250e-01 -1.67968750e-01  1.99218750e-01  1.67236328e-02\n",
      " -1.80664062e-01  1.06445312e-01 -3.39843750e-01 -5.81054688e-02\n",
      " -3.35937500e-01  4.39453125e-02  8.59375000e-02  4.44335938e-02\n",
      "  2.74658203e-03  1.70898438e-01  7.42187500e-02 -3.06396484e-02\n",
      " -7.86132812e-02  5.03540039e-03 -1.16699219e-01  3.18359375e-01\n",
      "  2.63671875e-01 -9.47265625e-02  1.21582031e-01  1.52343750e-01\n",
      " -2.33398438e-01  3.84765625e-01 -1.13281250e-01  4.15039062e-02\n",
      " -2.20703125e-01  1.05590820e-02 -3.41796875e-02  7.56835938e-02\n",
      " -2.36328125e-01 -6.98242188e-02  3.03955078e-02 -2.00195312e-01\n",
      "  1.74804688e-01 -1.57226562e-01 -3.95507812e-02 -2.69531250e-01\n",
      " -1.11816406e-01  1.04980469e-01  1.14746094e-01 -2.47955322e-04\n",
      " -1.42578125e-01 -1.63085938e-01 -2.63671875e-01  1.44531250e-01\n",
      "  1.63085938e-01  2.19726562e-02 -2.06054688e-01 -3.17382812e-02\n",
      " -1.56250000e-01 -1.09375000e-01  4.57031250e-01  2.71484375e-01\n",
      "  6.12792969e-02  2.01416016e-03 -1.21582031e-01  1.58203125e-01]\n"
     ]
    }
   ],
   "source": [
    "print(model['football'])"
   ]
  },
  {
   "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 words left after the processing that needed to be searched for and removed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "48251 out of 1802696 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": 13,
   "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": 21,
   "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.2, random_state=42)\n",
    "\n",
    "# train dev\n",
    "x_train, x_val, y_train, y_val = train_test_split(x_train, y_train, test_size=0.2, random_state=42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length of x_train: 24668 | Length of y_train: 24668\n",
      "Length of x_test:   7709 | Length of y_test:  7709\n",
      "Length of x_val:    6167 | Length of y_val:   6167\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": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of x_train set: (24668, 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.\n",
    "\n",
    "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": 24,
   "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": 25,
   "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": 26,
   "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": 27,
   "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": [
    "**Note:** To better understand the following classifiers, I advise you to read [this article](https://towardsdatascience.com/comparative-study-on-classic-machine-learning-algorithms-24f9ff6ab222) or other similar ones that you will find on the Internet."
   ]
  },
  {
   "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": 28,
   "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": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Mean Error')"
      ]
     },
     "execution_count": 29,
     "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=19, but still mean error a little higher than normal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nearest Neighbors Result (k=19):\n",
      "-----------------------------------\n",
      "Accuracy Score (k=19): 75.41%\n",
      "Accuracy (x_train, y_train): 100.0%\n"
     ]
    }
   ],
   "source": [
    "# create KNN Classifier\n",
    "knn = KNeighborsClassifier(n_neighbors=19, 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=19):\\n\" + '-' * 35)\n",
    "print(\"Accuracy Score (k=19):\", str(round(knn.score(x_test, y_test) * 100, 2)) + '%')\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": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Classification KNN:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.75      0.64      0.69      3331\n",
      "           1       0.75      0.84      0.80      4378\n",
      "\n",
      "    accuracy                           0.75      7709\n",
      "   macro avg       0.75      0.74      0.74      7709\n",
      "weighted avg       0.75      0.75      0.75      7709\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": 32,
   "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": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LogisticRegression(multi_class='ovr', n_jobs=1, solver='liblinear')"
      ]
     },
     "execution_count": 33,
     "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": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy Score: 80.58%\n"
     ]
    }
   ],
   "source": [
    "print(\"Accuracy Score:\", str(round(logit.score(x_test, y_test) * 100, 2)) + '%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Classification Logistic Regression:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.79      0.76      0.77      3331\n",
      "           1       0.82      0.84      0.83      4378\n",
      "\n",
      "    accuracy                           0.81      7709\n",
      "   macro avg       0.80      0.80      0.80      7709\n",
      "weighted avg       0.81      0.81      0.81      7709\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": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkcAAAD+CAYAAAAwGaFjAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAA610lEQVR4nO3de5xd0/3/8dd7JlcJSQhBIhIkdQlCIy5tv26lQYveSBSlVPmhLVqlVVWtfktbqqX6jRaVtuJWbbQhtO73BBGSFJEgF7nJTeQ+8/n9sfeMPZOZOWcy58zMmXk/H4/N2WuvvdfaZ3bO+Zy11t5LEYGZmZmZJcpaugJmZmZmrYmDIzMzM7MMB0dmZmZmGQ6OzMzMzDIcHJmZmZllODgyMzMzy3BwZO2WpN9L+uEm7Ndf0kpJ5cWoV2sl6QFJX22Bcg+RNKeIx69xHUg6R9KC9G+8Vfr/nYpQ7lRJhxT6uGbWdPJzjqwUSHobODMi/l2qZUs6DfgjsBqoBGYBP4iIfza1jqVO0nDgCuAgkvdmBnBTRNyaBhB/joh+zVCPjsAK4ICIeKWAx70NmBMRlxXqmA2U9RhwALABWAM8AZwbEe8Vu+x66vLniPhDc5dt1hRuOTJrXs9GRHegJ/A7YKyknoUupJRatSQdCDwCPA7sAmwFnAMc1QLV6QN0Aaa2QNmFdF56ne0CdAd+2ZyFK+HvFytZvnitpEnqLOnXkualy68ldc5sv1jSe+m2MyWFpF3SbbdJ+mn6urekf0paJmmJpCcllUkaA/QH7k+7Vy6WNCA9Tod03y0l3ZqWsVTS33PVOyIqgTFAN2BQ5lx+KendtFvn95K6NuJcbpI0XtKHwKGStpd0r6RFkmZJ+mbmWMMlTZK0Ii3r2jS9i6Q/S3o/fS8mSuqTbntM0pnp6zJJl0l6R9JCSbdL6pFuq3p/vpqey2JJP2jg7fgF8KeIuDoiFkfixYg4oZ6/+SWS3pL0gaRpkj6f2baLpMclLU/LvTNNl6Tr0rqukPSqpCHZ60DSYOD19FDLJD2Sbs++z10l/So97+WSnqr6G0m6W9L8NP0JSXuk6WcBXwEuTq+h+9P0tyV9OvO3r/M6VtqtKOmitP7vSTq9gfezWkQsA/4ODM28R7tKeji9zl+XdEJm223pdfdw+v4+LmnHzPaD0mtiefr/gzLbHpN0laSngVUk1/engBvS874hnzqbtQYOjqzU/YCkC2EosDcwHLgMQNII4ELg0yS/oA9p4DgXAXOArUlaD74PREScArwLfC4iukfENXXsOwbYDNgD2Aa4LlellbTsnA6sB95Jk38ODE7PZRegL3B5I87lJOAqYHPgGeB+4JX0OIcD35b0mTTv9cD1EbEFsDNwV5r+VaAHsANJC87ZJN2AtZ2WLocCO5G0TtT+8vsk8LG07Msl7VbH+7AZcCBwTx1l1Octki/dHsCPgT9L2i7d9hPgIaAX0A/4bZp+JPA/JO9vD+AE4P3sQSPiDZK/IUDPiDisjrJ/CXycpPtvS+Bikm5AgAdIAt1tgJeAv6THHZ2+via9hj5Xx3HrvY5T26b17gucAdwoqVddb06WpK2AL5B0UyKpG/Aw8Ne0niOB30naPbPbV0jex97A5KrzkLQl8C/gNyTXxrXAv9IyqpwCnEVyDZ4GPEnaihUR5+Wqr1lr4eDISt1XgCsjYmFELCL5sjwl3XYCcGtETI2IVSRjWuqzHtgO2DEi1kfEk5HHgLz0S/ko4OyIWJru+3gDuxwgaRnJWJBfAidHxEJJIvlSuSAilkTEB8DPSL688j2Xf0TE02mr1J7A1hFxZUSsi4iZwM2Z460HdpHUOyJWRsRzmfStgF0ioiJtwVlRR1lfAa6NiJkRsRK4FBiptDUt9eOIWJ2O3XmF5Eu/tl4kn0N5j4eJiLsjYl5EVEbEncCbJMFEVf13BLaPiDUR8VQmfXNgV5KxltMbOwZHSTfR14BvRcTc9P15JiLWpvW6JSI+SNevAPauak3LQ0PXcVX9r0yvr/HASpLAsz6/kbQcWEwS5Jyfpn8WeDsibo2IDRHxMnAv8OXMvv+KiCfS8/gBcKCkHYBjgDcjYky67x3Af4FssHdbeo1uiIj1eZ67Wavj4MhK3fZ81PJC+nr7zLbZmW3Z17X9guTX9UOSZkq6JM/ydwCWRMTSPPM/FxE9SYKCcSQtIJC0WG0GvJh2Zy0DHkzTIb9zyabtCGxfdaz0eN8naRWDpPVhMPDftHvks2n6GGACyVioeZKuUTJIuba63vcOmeMDzM+8XkXSulTbUpKWl+3q2FYnSadKmpw5ryEkAQAkLTkCXlByN9jXACLiEZKWrRuBhZJGS9oi3zJTvUnGI71VR53KJf087e5bAbyd2ScfDV3HAO9HxIbMen3vZ5VvRkQPYC8+akWD5LrYv9Z18RWSlqkq1ddRGvguSetSu45V9exb175mpczBkZW6eSQf+FX6p2mQtEZk73Daob6DpL/4L4qInYBjgQslHV61uYHyZwNbqpGDqtMvnXOAUyTtQ/ILfzWwR0T0TJce6aDafM8lW8/ZwKzMsXpGxOYRcXRa/psRMYqka+Vq4B5J3dKWiR9HxO4kXUefBU6to6y63vcNwIJGvg+rgGeBL+aTPx3/cjNwHrBVGmi+RhIQERHzI+LrEbE98A2SLqNd0m2/iYiPA7uTBIbfbUxdSf5Ga0i6IWs7CTiOpNuzBzCgqsrp/3O1QjZ0HW+yiHgV+ClJN5xIrovHa10X3SPinMxu1deWpO4k3Yfz6qhjVT3nZousXYWmnoNZS3BwZKWko5IBw1VLB+AO4DJJW0vqTTJG589p/ruA0yXtlo5tqfeZRpI+q2Qwr4DlQAUfjSVZQDKuZiNp18wDJF/CvSR1lPQ/+ZxMRCwB/gBcnnaF3QxcJ2mbtE59M2OE8j6X1AvAB5K+p2QQcbmkIZL2S499sqSt03KXpftUSjpU0p7pmKgVJN05lXUc/w7gAkkD0y/QnwF31mrdyNfFwGmSvls1fkXS3pLG1pG3G8kX7qI03+kkLUek61+WVBVELk3zVkraT9L+aSvYhyRBTl3nVa/0vboFuFbJYPdySQcqGTi9ObCWZBzTZiTvR1a911Cqoeu4qf5E0qJ3LPBPYLCkU9JrtWP63mTHgx0t6ZOSOpGMPXouImYD49N9T5LUQdKJJIFmQ4+iyHXeZq2SgyMrJeNJWleqlitIfhVPAqYAr5IMhP0pQEQ8QDJ49FGSLrOqcTVr6zj2IODfJGM5ngV+FxGPptv+l+SLa5mk79Sx7ykkQcR/gYXAtxtxTr8m+TLaC/heVT3Trpl/k44raeS5EBEVJK0+Q0mep7SYJBCrGgMzApgqaSXJ4OyREbGapHvlHpLAaDrJ7fVj6ijiljT9ifT4a/hoXEujRMQzwGHpMlPSEmA0yd+7dt5pwK9I/kYLSMZWPZ3Jsh/wfHpe40jGB80EtiAJPpeSdAW9T9KV2ljfIbnOJpJ0N11N8jl6e3rcucA0Pvr7VPkjsHt6Df29juPWex03VUSsI/kb/zAdy3YkydizeSRdn1cDnTO7/BX4Ecn5fRw4OT3O+yTX1EUk79/FwGcjYnEDxV8PfEnJXZy/KcT5mDUHPwTS2o301/FrQOdNbOFoNdrSuVjroWZ8WKVZa+aWI2vTJH1eyTNkepH8Qr6/VIOJtnQuZmatmYMja+u+QdLV9RbJOKJzGs7eqrWlczEzaxRJI5Q8uHRGXXcUK5n38lFJL0uaIunoOravrGd4RM1juVvNzMzMWrP0JpE3gCNIHtg7ERiVjkOsyjMaeDkiblLyYNPxETEgs/0ekps0no+IBqfUccuRmZmZtXbDgRnpg2fXAWNJHp+RFSQ3X0By80n14zAkHU9y80he8yY6ODIzM7PWri81HzI6h5oPIIXkDuaTJc0hudv1fKh+Xtf3SJ48n5cOubO0X1037xE9evfJndGsHhUVFXywbDmeoNyaqlOnjkSHznVvrGt0hOpIy6UQx6lvpEYhjuNzavpxKjfwwcLZiyNi69yZm65si37BhjU588Xq96eSPBKkyuhI5iVsjFEkU9j8StKBwBglE0xfAVwXESuTR9nl5uCoAZtv048vXXNHS1fDStiHSxdx5423soFOLV0VK3H77r8HCzcb3NLVsBLXYc0Sptx0Wu1pYIqnYi0dd/t8zmzrXvrDmogY1kCWudScGaAfNZ/ODsm0SCMAIuJZSV1IpvDZn+R5W9cAPUkeDLsmImpPll3NwZGZWQnYlAYGs43k2XJS0CLLygtxmInAIEkDSYKikSTT9mS9CxwO3JY+C64LsCgiquawRNIVwMqGAiNwcGRWZP5Ks0LxtWRNp2a/jlSQ4CgiNkg6j2Ri7HLgloiYKulKYFJEjCN5evvNki4g6Xw8LTbxlnwHR2ZmZlYUkijrWJhhBRExnlrTCkXE5ZnX04BP5DjGFfmU5eDIzMzMikOirDDdas3KwZGZmZkVTYHGHDUrB0dmZmZWFJIo69CxpavRaA6OzMzMrEgKMyC7uTk4MjMzs+KQgyMzMzOzjxTwbrXm5ODIzMzMikJ4QLaZ1RIREOHn91mTRVS2dBXMGs/damZmZmYZEuUd3K1mZmZmBiTTlbjlyMxq2aRpfcw2solTRJnV0BLdsw6OzMzMzKqojDJ3q5lZliSQR2Nb06msrKWrYNZ4ApW75cjMzMwM8JgjMzMzs5qkkuxWczutWVG5S80Kw1eSFYLU/F/7ZWXKueRD0ghJr0uaIemSOrb3l/SopJclTZF0dJo+XNLkdHlF0udzleWWIzOzkuDwyEqPJJRn8JPjOOXAjcARwBxgoqRxETEtk+0y4K6IuEnS7sB4YADwGjAsIjZI2g54RdL9EbGhvvLccmRmZmZFIynnkofhwIyImBkR64CxwHG18gSwRfq6BzAPICJWZQKhLuTxjBW3HJmZmVlxCMo7FKQdpi8wO7M+B9i/Vp4rgIcknQ90Az5dXQ1pf+AWYEfglIZajcAtR2ZmZlYkycSzyrkAvSVNyixnbUJxo4DbIqIfcDQwRukgq4h4PiL2APYDLpXUpaEDueXIzMzMikSU5ddttjgihjWwfS6wQ2a9X5qWdQYwAiAink0DoN7AwqoMETFd0kpgCDCpvsLccmRmZmbFISjrUJZzycNEYJCkgZI6ASOBcbXyvAscDiBpN5LxRYvSfTqk6TsCuwJvN1SYW47MzMysKCTyvlW/IemdZucBE4By4JaImCrpSmBSRIwDLgJulnQByaDr0yIiJH0SuETSeqAS+H8Rsbih8hwcmZmZWdEU6tFKETGe5Pb8bNrlmdfTgE/Usd8YYExjynJwZFZEEZH8fvEjaqyJInLefWzW6kiivLz0RvA4ODIrOn+pWSH4OrLSVIiHQDY3B0dmZmZWNA6OzMysSNxyZE0XzXwdSbhbzcxq8xeaFYaHHFlBNPuFVJi51ZqbgyOzoiu9DwZrhXwZWSkq0K38zc3BkVkRSfKXmhWECnU/tFkzElBWXnofgg6OzMzMrDjccmRmZmZWk8ccmVktpfehYK2TfC1ZATR396wfAmlmZmZWi1uOzMzMzFISlDs4MjMzM0sI0amDu9XMzMzMEm45srZktz7d+dLefSkTPDNrCQ+/sajG9l5dO3LKsB3o2qmcMsE/XpvPtPkfsOs23Tl2yLZ0KBMbKoO/v/oebyz6sIXOwlqDIw8awrXfPYmyMnHr35/kF7eOr7F9h2235I9XnkHPzTejvKyMH/z2Hh586tUa21+596f85Pf/4LoxE5q7+tZKfHLXrbnk+CGUl4l7n3uXPzwyo8b27Xp25WcnDWXzLh0pKxPX/Ws6T05fyJ79e3LFl/cCki6eGye8wX9end8Sp9AuCQdH1kYIOGFoX254ahbLVq3nu4ftwqvvrWD+B2ur84zYbRtemruMp2YuYdvNO3POJwbyowf/y8q1G/i/Z95m+ZoNbLdFZ8795E5cNn56y52MtaiyMnH9JSdz9Dm/Ys6CJTz7l8v55+OTmT5zXnWeS8/8HPc8PJHRdz/Gbjttzz9++20GH3Nx9fZfXDSSCU+/WtfhrZ0oE/zgC3vy9d8/x4Llq7nzgk/x6NT5vLVgZXWebxwxiAcnz+POZ95h5z7duenr+3PkT//Dm+99wAnXPUlFZdB788787TsH89jUBVRUej6W5lAm6FygbjVJI4DrgXLgDxHx81rb+wN/AnqmeS6JiPGSjgB+DnQC1gHfjYhHGqx3QWpcB0m3SFoo6bUc+b4t6dRaaRdJCkm90/XjJE2RNFnSJEmfTNMPTdOqljWSjk+3HS7ppTT9KUm7pOnnSfpaUU66jRiw5WYs/nAd73+4jooIXpqzjL2236JGngjo0qEcgK4dy1m+Zj0Ac5avYfmaDQC8t2ItHctFhxL81WCFsd+QnXhr9kJmzV3E+g0V3DXheT53yNAaeSKCLbp1BWCL7l15b9Gy6m3HHrIPs+YuYtpb87D2a8/+vZi9+EPmLFnF+opg/MvzOHTItjXyBNC9S/J7v3uXjixcvgaANesrqgOhzh3LPNthc5MoL8u95D6MyoEbgaOA3YFRknavle0y4K6I2AcYCfwuTV8MfC4i9gS+CozJVV4xW45uA24Abq8vg6QOwNeAfTNpOwBHAu9msv4HGBcRIWkv4C5g14h4FBia7rclMAN4KN3nJuC4iJgu6f+RvGmnAbcAT6f/tzr06NqRpavWV68vXb2eAVtuViPP+OkLOO+TAzl4563o3KGM3z45a6PjDO3bg9nLVrPBv9Darb7b9GTOgiXV63MXLGW/ITvVyPOT//sH4393Ef9v5OF069qZEWf/EoBuXTvzndOP4qizf8WFp45o1npb69KnRxfeW7a6en3BsjXstWPPGnlufPB1bj77AE765EC6dirnzN8/V71tz/49+enIoWzfqyuX/PVltxo1o6RbrSDtMMOBGRExE0DSWOA4YFomTwBVv+R7APMAIuLlTJ6pQFdJnSNiLfUoWstRRDwBLMmR7TDgpYjYkEm7DriYzHTmEbEyonoq4W7UPdX5l4AHImJV1W7U/SatAt6WNLwRp2O1DNuhJ8+9s5QfPvBfbnr6bU7db4caj6jbdvPOHDdkW8a+NLfF6tgaRETdV6tVO3HE/tx+/9PsNOI7HHv+r7ntp19HEj88+zh+8+eH+XB1vZ9f7UpEZUtXoVU7Zt++/P2F2Rx+5b855+YX+PlJ+6D0Q+nVd5dx3DWPceJ1T/L1w3cpybunSpUEnTqU5Vzy0BeYnVmfk6ZlXQGcLGkOMB44v47jfJEk7mjwg6Wlxxx9AnixakXSccDciHhFqtnMJunzwP8C2wDH1HGskcC1mfUzgfGSVgMrgAMy2yYBnwJeqH0QSWcBZwF0771d48+oDVi+ej29NutYvd6ra0eWr15fI8+BA7bkxqeS1qJZS1bRsVx061zOyrUV9OzakbMOHMCYSbNZ/OG6Zq1769R+o6O5C5fRr8+W1et9+/Ri3qKlNfKcfvyn+Oy5yT/d56e8RedOHendszvDh+zEFz49jJ99+8v03HwzKisrWbNuPTfd2eBQAWuDFixfw3Y9u1av9+nZhQVpt1mVL+zfn2+MTlqLXnlnKZ06ltGrWyeWrPzoM2jmwpWsWlvBoG03Z+qc5c1T+XZO5NdtBvSWNCmzPjoiRjeyuFHAbRHxK0kHAmMkDYn0l4WkPYCrSXqnGtTS4fN2wCIASZsB3wcurytjRNwXEbsCxwM/yW6TtB2wJ5C9leUC4OiI6AfcSs3AaSGwfT3ljI6IYRExrOsWvTblnEreO0tXsXX3Tmy1WUfKJfbt15Mp81bUyLNk1To+tk13APps3pmOZWWsXFtB145lnH3QAP7x2nvMfH9VXYe3dmTS1Fns0r8PA7bvTccO5Zzwmf3552OTa+R5d/4SDh2eDB3YdeB2dOnckUVLP+CwM37O4GMuZvAxF/PbvzzM1X/8lwOjduq12cvov3U3+m7ZlY7l4uh9tufR12recfbe0tUcMKg3ADtt053OHcpZsnIdfbfsWv3lvF2vrgzcpjtzl67eqAwrnnIp5wIsrvruTZfagdFcYIfMer80LesMkmE3RMSzQBegauxyP+A+4NSIeCtXnVu65Wg1SeUBdgYGAlWtRv2AlyQNj4jqfwUR8YSknST1jojFafIJwH0RsR5A0tbA3hHxfLr9TuDBTLld0rKtDpUBd02ex7mf3AkJnnt7KfM/WMsxu/fh3aWrefW9Fdw35T1G7duPQ3dJPozGTEpaO/9n595s3b0zR+3Wh6N26wPADU/NZOXaihY7n5bVfluNACoqKvn21X/mX7+7kLKyMv70j6eYNnMePzrneF6c9jb/fHwy37v2Tm764Vf51slHEhGcefkfW7rarVT7vZYqKoOr/vYao886gLIycd8Ls3lrwUrOG/Exps5exqNTF/CLcVP58Ql7c+rBOxEBP7hjMgD7DtyKMw/fhQ0VlVQG/OTeV1nWjlu0o5mvo6putQKYCAySNJAkKBoJnFQrz7vA4cBtknYj+a5fJKkn8C+Su9eezqveHw3lKTxJA4B/RsSQerafDfSLiMvq2PY2MCwiFqd3mr2VDsjeF7g/3S/SvM8Bl6YDtKsGes8HDoqINySdQdKK9MV0+2+BpyNibEP132bnPeKEa+7YpHM3A1i5ZCF33XgrG9S5patiJe6g/XZjUfddW7oaVuI6rFnClJtOezEihjVHedsO2iNOvfaunPl+ceyQnHWSdDTwa5Lb9G+JiKskXQlMiohx6d1rNwPdSX5NXBwRD0m6DLgUeDNzuCMjYmF9ZRWt5UjSHcAhJP2Ic4AfRUTtn4QPkMctdSQDqE6VtJ6kxefETGA0gKSp7fGqzBGxQdLXgXslVQJLSe6Kq/IJkoFbZs3AjzKwpqs9DtOsFDRizFFOETGeZKB1Nu3yzOtpJN/vtff7KfDTxpRVtOAoIkblkecdSe9LGhQRb9baNiDz+mqSQVR1HeNtNh6xTkTcR9K/WIOkfYCpEfF+rvqZNZUkx0ZWGA6OrAQVsFutWbX0mCOAS0gGZr+ZK2OB9AZ+2ExlmZmZtVuePmQTRcTrwOvNWN7DzVWWmVmhlN7Xi7VKzd0C6YlnzWxjpfehYK2VryVrOjXzdSTkbjUzMzOzKnLLkZmZmdlHPObIzMzMLEMSncrdrWZmZmZWrawEH0Ph4MjMzMyKQkB56cVGDo7MzMysOCTo6G41MzMzs4+4W83MzMws5W41M9tIRECEn99nTRZR2dJVMGs0SXRwt5qZmZnZR9xyZGZmZpYSpTnmqPTausxKSrR0BayNiPC1ZE3X3N2zVXer5VryO5ZGSHpd0gxJl9Sxvb+kRyW9LGmKpKPT9K3S9JWSbsinLLccmZmZWdEUoltNUjlwI3AEMAeYKGlcREzLZLsMuCsibpK0OzAeGACsAX4IDEmXnNxyZFZEkpKfTmZNpDJ/XFvpEaJMuZc8DAdmRMTMiFgHjAWOq5UngC3S1z2AeQAR8WFEPEUSJOXFLUdmZmZWFEm3WkF+IPYFZmfW5wD718pzBfCQpPOBbsCnN7Uw/xQxMzOzoimXci5Ab0mTMstZm1DUKOC2iOgHHA2MkbRJcY5bjsyKyl1qVhi+kqwQNjFW2PTyyPtutcURMayB7XOBHTLr/dK0rDOAEQAR8aykLkBvYGHeFU655cjMrCQ4PLLSU9WtlmvJw0RgkKSBkjoBI4FxtfK8CxyelKvdgC7Aok2pt1uOzMzMrEiqu82aJCI2SDoPmACUA7dExFRJVwKTImIccBFws6QLSAZnnxbpMzAkvU0yWLuTpOOBI2vd6VaDgyMzMzMrikI+BDIixpPcnp9NuzzzehrwiXr2HdCYshwcmZmZWVEU8G61ZuXgyMzMzIqmFB/11ugB2ZJ6SdqrGJUxMzOztqUM5Vxam7xajiQ9Bhyb5n8RWCjp6Yi4sIh1MzMzsxImIM+p01qVfKvcIyJWAF8Abo+I/WnCkyfNzMysHUhnUMq1tDb5BkcdJG0HnAD8s4j1MWtTIiK5odSsidI7ks1KivLoUivZbjXgSpJnCzwdERMl7QS8WbxqmbUl/lKzQvB1ZKWpFLvV8gqOIuJu4O7M+kzgi8WqlJmZmbUNra9dKLe84jlJgyX9R9Jr6fpeki4rbtXMzOwjbjmypotmvo6qHgKZa2lt8m3suhm4FFgPEBFTSOY1MbMG+QvNCsNDjqwgWuBCKlfupbXJd8zRZhHxgmpGdxuKUB+zNqgV/su30uPLyEpQcjda6V28+QZHiyXtTPozWNKXgPeKViuzNkKSv9SsIKQSHNVqBpSV4GdgvsHRucBoYFdJc4FZwMlFq5WZmZmVPNE6u81yyfdutZnApyV1A8oi4oPiVsvMzMzaglLsVsv3brVvSdoCWAVcJ+klSUcWt2pmbUHpfShY6yRfS1YAzd49q6RbLdfS2uT7Ln0tnT7kSGAr4BTg50WrlZmZmZW8qm61UrtbLd/gqKrqR5PMrTYV/yQ2MzOzHCTlXPI8zghJr0uaIemSOrb3l/SopJclTZF0dGbbpel+r0v6TK6y8h2Q/aKkh4CBwKWSNgcq89zXzMzM2qHkIZAFOI5UDtwIHAHMASZKGhcR0zLZLgPuioibJO0OjAcGpK9HAnsA2wP/ljQ4IirqKy/f4OgMYCgwMyJWSdoSOL2R52ZmZmbtiigvzIDs4cCM9AYxJI0FjgOywVEAW6SvewDz0tfHAWMjYi0wS9KM9HjP1ldYvsHRgcDkiPhQ0snAvsD1ee5bsjpXrqH/8ukfJURABCorI9urqFxhcUBlZBraKivT/co/SsvjQVkR8dHM3GldkGoMsJOq/lO/yspMXXxOmf0Kf04rPljGnp1Xsnm3LfIaUBtRs0E2SN+P7HnkOE4QNZ6CWzVdQO2BmDmPE0H2Cd/JcWo2gfucMscp8jl1njedg7ZbXV1+9jnHEYFq76vcZ5K93iM5UNLNkT2PXNc7mX/DVJ1SUFbjPJTrn7DPqQGFPKc1az/klRzlFZRyfnxX6S1pUmZ9dESMzqz3BWZn1ucA+9c6xhXAQ5LOB7oBn87s+1ytffs2VJl8g6ObgL0l7Q1cBPwBuB04OM/9S9I2Xcu5cJ8eLV0NK2HzF1cw95IpdF7nXmhrmj0O2YPd3prc0tWwErekYwf+2ozlKQLlN2XJ4ogY1sTiRgG3RcSvJB0IjJE0ZFMOlO+A7A2RhNHHATdExI3A5ptSoJmZmbUfqtyQc8nDXGCHzHq/NC3rDOAugIh4FugC9M5z3xryDY4+kHQpyVOx/6WkTbBjnvuamZlZuxQQlbmX3CYCgyQNlNSJZID1uFp53gUOB5C0G0lwtCjNN1JSZ0kDgUHACw0Vlm9wdCKwFjgjIuaTRF2/yHNfMzMza6+qxpM2tOQ8RGwAzgMmANNJ7kqbKulKScem2S4Cvi7pFeAO4LRITCVpUZoGPAic29CdapD/9CHzgWsz6++SjDkyMzMzq1tEvi1DeRwqxpPcnp9NuzzzehrwiXr2vQq4Kt+y8p0+5ABJEyWtlLROUoWk5fkWYmZmTZPXkFazVqhAY46aVb53q91A0r93NzAMOBUYXKxKmbUVNW8cN9t0kd8dP2atTOFajppT3jPQRcQMoDwiKiLiVmBE8aplZmZmJS8o1IDsZpVvy9GqdHT4ZEnXAO/RiMDKzMzM2qNAFa2v2yyXfAOcU4BykpHiH5I8L+CLxaqUWVvhrhArlHAHrRVAZUt8JrXVlqOIeCd9uRr4cfGqY2ZmZm1GnrfqtzYNBkeSXqWB8aQRsVfBa2TWhgjymKnLLLeywkzeadbsWuPdaLnkajn6AtCHmpO9QdKtNr8oNTIzM7M2om3erXYdsDwi3skuwPJ0m5mZmVn92uCYoz4R8WrtxIh4VdKA4lTJrO2Qu0KsQOQOWiuA5u6eVUSb7Fbr2cC2rgWsh5mZmbVFla2vZSiXXN1qkyR9vXaipDOBF4tTJTMzM2sb8ph0thXezZar5ejbwH2SvsJHwdAwoBPw+SLWy8zMzEpdtMG71SJiAXCQpEOBIWnyvyLikaLXzMzMzEpcad6tlu9DIB8FHi1yXczMzKytKcHgyPOjmZmZWXFEEBvW51zyIWmEpNclzZB0SR3br5M0OV3ekLQss+1qSa+ly4m5ysp34lkzMzOzRgqorGjyUSSVAzcCRwBzgImSxkXEtOqSIi7I5D8f2Cd9fQywLzAU6Aw8JumBiFhRX3luOTIzM7PiCJLgKNeS23BgRkTMjIh1wFjguAbyjwLuSF/vDjwRERsi4kNgCjCiocIcHJkVUdDA5IRmjVDpC8lKUEQQ69fnXPLQl5pTmc1J0zYiaUdgIFB189grwAhJm0nqDRxKMg1avdytZmZWEhwdWSnKu1utt6RJmfXRETF6EwsdCdwTERUAEfGQpP2AZ4BFwLNAg5VycGRmZmbFEUHkFxwtjohhDWyfS83Wnn5pWl1GAufWrEZcBVwFIOmvwBsNVcbBkVkRRSt88quVKl9L1nTN/5kUed+NlsNEYJCkgSRB0UjgpNqZJO0K9CJpHapKKwd6RsT7kvYC9gIeaqgwB0dmZiXAoZEVQrNfR1UDspt6mIgNks4DJgDlwC0RMVXSlcCkiBiXZh0JjI2aUWBH4Ml0IvAVwMkR0eBjux0cmZmVhOadTd2sMKJgE89GxHhgfK20y2utX1HHfmtI7ljLm4MjsyIS/kqzwijzhWSlKIJYv66la9FoDo7MzMysOKIwD4Fsbg6OzMxKgBuOrFRFgbrVmpODI7MiSgcAmhWAryVrurLm/kyKgA3uVjMzMzMDIAi3HJmZmZlVK9Ct/M3NwZGZmZkVh+9WMzMzM8sq3HOOmpODIzMzMysed6uZmZmZpSKoLMzcas3KwZGZmZkVRwRR4W41MzMzMyB5zJGDIzOrIfBs6lYYleEryUpQBJXrN7R0LRrNwZGZmZkVjVuOrM2Y8PQkLvzl76moqORrnx/BxaefUGP7Rb/8Px6bNAWA1WvWsnDJMhY/cQ8Al17/Rx54aiIA3z9zFCd85uDmrby1Krt/5mBOuP5yysrLefoPdzLh6ptqbP/ytT9k8KEHAtBpsy5svk1vLuy1FwC9dtieU/7wc3rtsD1EcMPRp/P+O3Oa/Rys5W31yQMZfMlFqLyMuff+g3f+8Kca2wd/7wJ6DR8GQFmXznTackseP/Aweg3/OIO/d2F1vs0G7shr3/kBix55vFnr315FBJUVvlutmqQRwPVAOfCHiPh5Pfl+DfwtIp6Q9EdgGMkkQm8Ap0XESklnA+cCFcBK4KyImCZpODC66lDAFRFxX3rcW4DPAgsjYkimvF8C4yPikYKfdBtRUVHBN6++kQd+9zP69enNASd/i88evD+777RjdZ5ffecb1a9vGPsPJv/3LQDGP/kCL//3LSbdcSNr16/n8K9fzIhPDGOL7t2a/Txag2jnXSEqK2PUjVdy/REns3TOfC6dOI4p4x7mvekzqvPcfeFPql8fct5X2WGfParXT7/9Wh646gam//spOnfbjMoSfF5K4bTja6msjI/94GJe/vp5rFmwgOF3/onFjz7Bh2/Nqs7yxtXXVb/e4aQT2Hy3jwGw9IUXef6LXwGgQ48t+MQDf+P9Z55r3vq3Is3ePVvAbrVccYWk64BD09XNgG0iome67RrgGKAMeBj4VjTwAV1WkBrXIqkcuBE4CtgdGCVp9zrybQUcEBFPpEkXRMTeEbEX8C5wXpr+14jYMyKGAtcA16bprwHD0vQRwP9Jqgr4bkvTavstcEnTzrBte+G1N9i53/bs1G87OnXsyImfOZj7H6v/w+TOBx9n5IhDAJg+810+te8QOnQop1vXLuw5aCATnnmxmWpurc2A4UNZOOMdFs+aTcX69Uwcez97HXdkvfn3G3Usk+4YB8B2u+1CWYdypv/7KQDWfriK9avXNEu9W6N2HBrRY889WD17NqvnzCXWb2DB+IfZ+tD6W6T7HP0Z5o+fsHH6kYez+MlnqVyztpjVtVqiojLnkks+cUVEXBARQ9OY4LfA39J9DwI+AewFDAH2Axrs0ihKcAQMB2ZExMyIWAeMBY6rI98XgQerViJiBYCSqcy7kn4eVKWnumXSV0VEVUjahcznRxpwLaldYES8A2wladtNPrs2bt6ixfTbduvq9b7b9GbuwvfrzPvOvAW8PW8+h+63NwB7DU6CoVWr17B46XIenzSFOQsWNUu9WyPRvudS79W3D0tnz6teXzbnPXr17VNn3i3796X3wB347yPPALDN4J1YtWwF37j393z/pX/xhWsuRWXF+shq/dTcs6m3Ip37bM2a9xZUr69ZsIDOfbauM2+X7bala7/tWfL8pI229TnqCBbUETRZ8UQkE8/mWvKQb1xRZRRwR1U1SGKETkBnoCOwoJ79gOJ1q/UFZmfW5wD715HvE8A92QRJtwJHA9OAizLp5wIXkpzcYZn0/YFbgB2BUzLBUkNeSsu+N4+81oC7HnqcLxz+ScrLywE44sCPM2nqG3zq9IvYulcP9t9rV8ra8Rea5W/YyM/x0j3jqz8oyzuUM+hT+3HVPsew5N15nHnnDRx42pd45pa7WrimLaP9hkaN0+foI1n40H82mrKiU++t6D5oF95/+tkWqlk7FVCxriDdavnGFUjaERgIPAIQEc9KehR4j+Sf0g0RMb2hwlr6W2s7oEazQkScDmwPTAdOzKTfGBE7A98DLsukPx8Re5A0k10qqUse5S5My9iIpLMkTZI0afHS5Y09nzZh+617M2f+R3+WuQsX03ebrerMe+eExzkx7VKrcumZo3hx7I08eNPPIGDwjn2LWV1rxZbOXZAMpk717LcdS+fW/YNt2MjPMTHtUgNYOmc+sydPZ/Gs2VRWVPDK3x+i/75D6tzX2ra1CxbRZbuPWhy79OnD2npapLc96kjmj39oo/Q+I45g4X8eIzaU3uDgkpY+BDKPbrXeVd+96XJWE0odCdwTERUAknYBdgP6kQRZh0n6VEMHKFZwNBfYIbPeL02rbTVJU1cN6QmNJel2q20scHwd+0wnGaydz6dnl7TsjUTE6IgYFhHDevfqkceh2p799hjMjNnzmDV3PuvWr+fOCY/z2YMP2Cjff2fNZtmKlRy4127VaRUVFby/LOkFnfLGLF59cxZHHPDxZqu7tS7vTHyFbQYNYKsB/Sjv2JH9Rn6OKeMe3ihfn4/tTLdePZj57EvVaW9PfIXNem5B995bAvCxww7ivWlvNlvdW5v23HK04rVpdO3fny59t0cdO9Dn6CNY9OgTG+XbbOCOdNhic5ZPnrLRtm2PPtJdajT/dRSQb7fa4qrv3nQZXetQ+cYVkARHd2TWPw88FxErI2Il8ABwYEP1Lla32kRgkKSBJJUfCZxUR77pwC7AY+k4o50jYkb6+ljgvwCSBkVE1afiMcCbafpAYHZEbEib0XYF3s6jfoOBuzf15Nq6Dh3Kuf5753DMuZdRUVnBacceyR4778gVN93Ox3cfzOfSQOmuCY9zwmcOrjEWYv2GCg494zsAbN5tM2776Xfp0KG8Rc6jNWjP40QAKisquPO8y/nmhNspKy/nmVvu4r1pb/K5H1/AO5NeZcr9/wZgv5GfY+LY+2vsG5WV3Pudq/j2f/6CJN598TWeunlsS5xGK9F+r6WoqOD1q65hn9G/QWXlzLtvHB++NZOdzvsGK6ZOZ3EaKG171JEseGDj4LvL9tvReds+LJ340kbb2ptm/0yKoLIw3Wp5xRWSdgV6Adn+03eBr0v6X5J/SAcDv26oMBXrVmNJR6eFlwO3RMRVdeT5FPCNiDhZUhnwJLAFSeVfAc6JiBWSrgc+DawHlgLnRcRUSaeQ3Hm2HqgEroyIv6fHvgM4BOhNMvDqRxHxR0kdgSnAnrnGJ31898Hx/F9+07Q3wtq1+YuX8MPPXkbnde35FnQrhD0O2YPdFi5s6WpYiVvSsQMnvvLcixExrDnK22vb3jHuq8fkzDfwmttz1qmuuELSlcCkiBiX5rkC6BIRl2T2Kwd+B/wPSWPWgxFxIQ0o2nOOImI8MD5Hnicl/a+knhGxjGSQdF35vlVP+hhgTD3bRtVT7GdJ+iJL73nmZmZmJSQo3MSzdcUVEXF5rfUr6tivAvhG7fSGtIYnZF8E9AeWNVN5HYBfNVNZZmZm7VcElevXt3QtGq3Fg6OIeL6Zy/NYIzMzs+YQnlvNzMzMLKNw3WrNycGRmZmZFUVEUFGgudWak4MjMzMzKw53q5mZWbG054lnrYQFREXpXb0OjsyKKPCXmhVGsZ5JZ1ZMSbda6U3Z4uDIzMzMiqbSLUdmZmZmifCYIzOrzV0hVijhDlorgMrm/kyKoKIEp09ycGRmZmbF4ZYjM6tNtOe51K2Qypp7NnWzAgigsrL0Wj0dHJmZmVlxRFCxznermZmZmQFVA7LdcmRmGXJXiBWI3EFrBdDs3bMlGhyVtXQFzMzMrI1KHwKZa8mHpBGSXpc0Q9IldWy/TtLkdHlD0rI0/dBM+mRJayQd31BZbjkyMzOzoggK8xBISeXAjcARwBxgoqRxETGtuqyICzL5zwf2SdMfBYam6VsCM4CHGirPLUdmZmZWHBFERWXOJQ/DgRkRMTMi1gFjgeMayD8KuKOO9C8BD0TEqoYKc8uRmZmZFUUEhXoIZF9gdmZ9DrB/XRkl7QgMBB6pY/NI4NpchTk4MjMzs6KJyryCo96SJmXWR0fE6E0sciRwT0TUGMwkaTtgT2BCrgM4ODIzM7PiiMh3zNHiiBjWwPa5wA6Z9X5pWl1GAufWkX4CcF9ErM9VGQdHZmZmVhQRUFmYh0BOBAZJGkgSFI0ETqqdSdKuQC/g2TqOMQq4NJ/CHByZmZlZcURh7laLiA2SziPpEisHbomIqZKuBCZFxLg060hgbNSa9VvSAJKWp8fzKc/BkVkRRbqYNVUJTk9lBkTBHgIZEeOB8bXSLq+1fkU9+75NMqg7Lw6OzMxKgqMjKz0RsD6/AdmtioMjMzMzK4oASnD2EAdHZsVUq9vbrAl8LVnTtcRnUkUJfg46ODIzKwGl9/VirVFzX0eVAetKcMCcgyMzs5LQzLOpmxWIu9XMrAbhrzQrjDJfSFaCgnC3mpmZmVkVD8g2M7OiccORlaLwmCMzq03yV5oViq8la7qyFvhMcsuRmZmZWSrpViu96MjBkZmZmRVF4G41MzMzs2oR7lYzMzMzq8HdamZmZmapIFjv4MjMzMwsUarPOSpr6QqYmZlZ21R1t1quJR+SRkh6XdIMSZfUsf06SZPT5Q1JyzLb+kt6SNJ0SdMkDWioLLccmZmZWVEU6iGQksqBG4EjgDnAREnjImLaR2XFBZn85wP7ZA5xO3BVRDwsqTtQ2VB5bjkyK6LAs6lbYVSW4LgNM0i61XIteRgOzIiImRGxDhgLHNdA/lHAHQCSdgc6RMTDABGxMiJWNVSYW44asHZDBW/MX7ZRellZGY15yGgEVFZuHKSWlzcuNq2sDKLWB6Qkyho5I2VFxcZ18TkV55wWLllOx4Hb0q1D5zzrsPGnhFDjHo4cySDIjY7TyCfjJlWpfRw16j1NjuNzqvsgjTun1V06sbx/X6D+QKmxTz+u6ziSGnsadb4fhahLoY7jc/ronJZGgw0mBVfAh0D2BWZn1ucA+9eVUdKOwEDgkTRpMLBM0t/S9H8Dl0RERX2FOThqwNQ3Zy7e4+hR77R0PVq53sDilq6ElTxfR7lMbekKlAxfS7nt2FwFLWLdhN/FO73zyNpF0qTM+uiIGL2JxY4E7skEPx2AT5F0s70L3AmcBvyxvgM4OGpARGzd0nVo7SRNiohhLV0PK22+jqxQfC21LhExokCHmgvskFnvl6bVZSRwbmZ9DjA5ImYCSPo7cAANBEcec2RmZmat3URgkKSBkjqRBEDjameStCvQC3i21r49JVU1eBwGTKu9b5aDIzMzM2vVImIDcB4wAZgO3BURUyVdKenYTNaRwNjIDBpLu9e+A/xH0qskowNvbqg81TXozCxfks5qQr+wGeDryArH15IVgoMjMzMzswx3q5mZmZllODhqJyRVpI9Uf03S3ZI2K8Axr5T06Qa2ny3p1KaWY6Wj1nV2v6SeBT7+25J6p69XFvLY1vwy10vVMkDSVpIelbRS0g0tXUdrn9yt1k5IWhkR3dPXfwFejIhrM9s7pAPezDZZrevsT8AbEXFVAY//NjAsIhZny7LSVNffUFI3kufRDAGGRMR5zVQXfwZaNbcctU9PArtIOkTSk5LGAdMklUv6haSJkqZI+kbVDpK+J+lVSa9I+nmadpukL6Wvf55O5jdF0i/TtCskfSd9PVTSc+n2+yT1StMfk3S1pBfSiQI/1dxvhhXNsyRPtUXSzpIelPRies3tmqb3Sa+HV9LloDT972neqZLOasFzsGYWER9GxFPAmobySdoj/dyYnH6uDErTT03XX5E0Jk0bIOmRNP0/kvqn6bdJ+r2k54Fr6rtOrf3xQyDbGUkdgKOAB9OkfUl+nc1Kv4SWR8R+kjoDT0t6CNiVZA6b/SNilaQtax1zK+DzwK4REfV0pdwOnB8Rj0u6EvgR8O10W4eIGC7p6DS93q46Kw1KJok8nI8esjYaODsi3pS0P/A7kmeN/AZ4PCI+n+5T1YrwtYhYIqkryQST90bE+818GlZ8XSVNTl/PiojPN2Lfs4HrI+IvSp57Uy5pD+Ay4KC0dbHqs+q3wJ8i4k+SvkZy3R2fbuuX5q+Q9B/qvk6tnXFw1H5kP4SeJPnSOgh4ISJmpelHAntVtQYBPYBBJMHKrVUT9UXEklrHXk7yK++Pkv4J/DO7UVIPoGdEPJ4m/Qm4O5Plb+n/XwQGbOoJWqtQdZ31JXkWSdUM2AcBd+ujOaWqJps7DDgVqp9FsjxN/6akqi/KHUiuQwdHbc/qiBi6ifs+C/xAUj/gb2lAcxhwd0QshhqfVQcCX0hfjwGuyRzn7jQwaug6tXbGwVH7sdGHUPoB8GE2iaR1Z0KtfJ9p6MARsUHScJKWgi+RPKirMb+21qb/r8DXZKlbHRFDlQz4n0DyCP/bgGX5fglKOoQkID8wbal8DOhSjMpa6UiD5R+lq2dGxF/T7rBjgPHZYQCNVPUZWEYjrlNr2zzmyLImAOdI6gggaXA6OPJh4PT0C486utW6Az0iYjxwAbB3dntELAeWZsYTnQI8jrVZaSvjN4GLgFXALElfBlCi6hr5D3BOml6etjL2AJamgdGuJHMgWTsXEfdFxNB0mSRpJ2BmRPwG+AewF8ks7F9Ou/qzn1XPkDw5GeArJK3ntY+/gvqvU2tn/Cvdsv5A0q31kpJmpUXA8RHxoKShwCRJ64DxwPcz+20O/ENSF5LWpwvrOPZXgd+nAdZM4PSinYW1ChHxsqQpwCiSL6SbJF0GdATGAq8A3wJGSzqDpOXwHJLxcGdLmg68DjzXEvW3lqPkrsQtgE6SjgeOjIjac2GdAJwiaT0wH/hZOk7tKuBxSRXAyySzr58P3CrpuySfa/V9/tR3nVo741v5zczMzDLcrWZmZmaW4eDIzMzMLMPBkZmZmVmGgyMzMzOzDAdHZmZmZhkOjsysSSSFpD9n1jtIWpQ+Lb2h/YamU8bUt32YpN8Usq5mZvlwcGRmTfUhMCSdBw3gCGBuHvsNBeoMjpTMkD4pIr5ZmCqameXPwZGZFcJ4kmkcIHno4x1VGyR1k3RLOoP6y5KOSycKvRI4MZ1V/URJV0gaI+lpYIykQ6panyR1l3SrpFfTmdW/mD5R+zZJr6XpFzT3SZtZ2+TgyMwKYSwwMn1K+l7A85ltPwAeiYjhwKHAL0iePnw5cGc6HcSdad7dgU9HxKhax/8hsDwi9oyIqmkihgJ9I2JIROwJ3FqkczOzdsbBkZk1WURMIZl6ZhRJK1LWkcAlkiYDj5FMItu/nkONi4jVdaR/GrgxU95SkmlodpL0W0kjgBVNOAUzs2oOjsysUMYBvyTTpZYS8MXMpKH9I2J6Pcf4sJ70jaQB0t4kAdfZJHMDmpk1mYMjMyuUW4AfR8SrtdInAOenkxkjaZ80/QOSSYvz8TBwbtWKpF6SegNlEXEvcBmwb1Mqb2ZWxcGRmRVERMyJiLpuvf8JyRijKZKmpusAjwK7Vw3IznH4nwK90sHXr5CMXeoLPJZ21/0ZuLQQ52Fmpoho6TqYmZmZtRpuOTIzMzPLcHBkZmZmluHgyMzMzCzDwZGZmZlZhoMjMzMzswwHR2ZmZmYZDo7MzMzMMhwcmZmZmWX8f2vSpXf3rC7TAAAAAElFTkSuQmCC\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": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy Score: 79.54%\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": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Classification Random Forest:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.81      0.69      0.74      3331\n",
      "           1       0.79      0.88      0.83      4378\n",
      "\n",
      "    accuracy                           0.80      7709\n",
      "   macro avg       0.80      0.78      0.79      7709\n",
      "weighted avg       0.80      0.80      0.79      7709\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": 39,
   "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).\n",
    "    \n",
    "You can read more about it [here](https://en.wikipedia.org/wiki/Support-vector_machine)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy Score: 79.36%\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[int(len(x_train)*0.75):], y_train[int(len(y_train)*0.75):])\n",
    "\n",
    "print(\"Accuracy Score:\", str(round(SVM.score(x_test[int(len(x_test)*0.75):], y_test[int(len(y_test)*0.75):]), 4) * 100) + '%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Classification SVM:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.78      0.76      0.77      3331\n",
      "           1       0.82      0.84      0.83      4378\n",
      "\n",
      "    accuracy                           0.80      7709\n",
      "   macro avg       0.80      0.80      0.80      7709\n",
      "weighted avg       0.80      0.80      0.80      7709\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print('\\nClassification SVM:\\n', classification_report(y_test, SVM.predict(x_test)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "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": 44,
   "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": 45,
   "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 = 88.3%` and `Accuracy Score = 80.58%`.\n",
    "\n",
    "Let's save this model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('LRModel.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": 47,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Logistic Regression Accuracy Score: 79.54%\n"
     ]
    }
   ],
   "source": [
    "with open('LRModel.pickle', 'rb') as m:\n",
    "     rf = pickle.load(m)\n",
    "\n",
    "print(\"Logistic Regression Accuracy Score:\", str(round(clf.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
}