Classifications_Models-Rolling Windows.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Predicting the Popularity of Online News"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"justify\">The purpose of the notebook is to reproduce the work carried out by Fernandes et al. [1] to classify a news article as popular or not popular. For that, we will use a Python language with the NumPy, Pandas, and sci-kit learn libraries. The authors propose an article optimization system that we will not cover in the code below. The code uses the public data set that was made available at <a> https://archive.ics.uci.edu/ml/datasets/online+news+popularity</a>. We will follow the same steps as the authors, using five machine learning algorithms for classification.</div>\n",
    "\n",
    "This Notebook will follow the steps below:\n",
    "    <ul>\n",
    "    <li>Data Preparation</li>\n",
    "    <li>Classes Definition</li>\n",
    "    <li>GridSearch</li>\n",
    "    <li>Rolling Windows</li>\n",
    "    <li>Machine Learning Classification</li>\n",
    "    <li>Conclusion</li>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Import from Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#libraries for data manipulation\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "#Models for Machine Learning\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn import svm\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "\n",
    "\n",
    "#libraries for selecting features and parameters\n",
    "from sklearn.feature_selection import RFE\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "#libraries for validation\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn import metrics\n",
    "from sklearn.metrics import confusion_matrix, classification_report,accuracy_score, make_scorer\n",
    "from sklearn.metrics import balanced_accuracy_score\n",
    "\n",
    "#libraries for graphics\n",
    "import seaborn as sn\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Preparation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv('online_popularity.csv', sep=',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# recent articles to be discarded\n",
    "df_remove = df.loc[(df[' timedelta']<=21)]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Discart recent articles\n",
    "df = df.drop(df_remove.index)\n",
    "\n",
    "#Discart articles until match with 39.000\n",
    "for x in range(16):\n",
    "  df = df.drop(39000 + x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['url', ' timedelta', ' n_tokens_title', ' n_tokens_content',\n",
       "       ' n_unique_tokens', ' n_non_stop_words', ' n_non_stop_unique_tokens',\n",
       "       ' num_hrefs', ' num_self_hrefs', ' num_imgs', ' num_videos',\n",
       "       ' average_token_length', ' num_keywords', ' data_channel_is_lifestyle',\n",
       "       ' data_channel_is_entertainment', ' data_channel_is_bus',\n",
       "       ' data_channel_is_socmed', ' data_channel_is_tech',\n",
       "       ' data_channel_is_world', ' kw_min_min', ' kw_max_min', ' kw_avg_min',\n",
       "       ' kw_min_max', ' kw_max_max', ' kw_avg_max', ' kw_min_avg',\n",
       "       ' kw_max_avg', ' kw_avg_avg', ' self_reference_min_shares',\n",
       "       ' self_reference_max_shares', ' self_reference_avg_sharess',\n",
       "       ' weekday_is_monday', ' weekday_is_tuesday', ' weekday_is_wednesday',\n",
       "       ' weekday_is_thursday', ' weekday_is_friday', ' weekday_is_saturday',\n",
       "       ' weekday_is_sunday', ' is_weekend', ' LDA_00', ' LDA_01', ' LDA_02',\n",
       "       ' LDA_03', ' LDA_04', ' global_subjectivity',\n",
       "       ' global_sentiment_polarity', ' global_rate_positive_words',\n",
       "       ' global_rate_negative_words', ' rate_positive_words',\n",
       "       ' rate_negative_words', ' avg_positive_polarity',\n",
       "       ' min_positive_polarity', ' max_positive_polarity',\n",
       "       ' avg_negative_polarity', ' min_negative_polarity',\n",
       "       ' max_negative_polarity', ' title_subjectivity',\n",
       "       ' title_sentiment_polarity', ' abs_title_subjectivity',\n",
       "       ' abs_title_sentiment_polarity', ' shares'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#view of columns \n",
    "df.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "39000\n",
      "39000\n"
     ]
    }
   ],
   "source": [
    "#create Target Feature\n",
    "y = df[' shares']\n",
    "\n",
    "#remove columns url,timedelta and shares\n",
    "x = df.iloc[:,2:60]\n",
    "print(len(y))\n",
    "print(len(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index([' n_tokens_title', ' n_tokens_content', ' n_unique_tokens',\n",
       "       ' n_non_stop_words', ' n_non_stop_unique_tokens', ' num_hrefs',\n",
       "       ' num_self_hrefs', ' num_imgs', ' num_videos', ' average_token_length',\n",
       "       ' num_keywords', ' data_channel_is_lifestyle',\n",
       "       ' data_channel_is_entertainment', ' data_channel_is_bus',\n",
       "       ' data_channel_is_socmed', ' data_channel_is_tech',\n",
       "       ' data_channel_is_world', ' kw_min_min', ' kw_max_min', ' kw_avg_min',\n",
       "       ' kw_min_max', ' kw_max_max', ' kw_avg_max', ' kw_min_avg',\n",
       "       ' kw_max_avg', ' kw_avg_avg', ' self_reference_min_shares',\n",
       "       ' self_reference_max_shares', ' self_reference_avg_sharess',\n",
       "       ' weekday_is_monday', ' weekday_is_tuesday', ' weekday_is_wednesday',\n",
       "       ' weekday_is_thursday', ' weekday_is_friday', ' weekday_is_saturday',\n",
       "       ' weekday_is_sunday', ' is_weekend', ' LDA_00', ' LDA_01', ' LDA_02',\n",
       "       ' LDA_03', ' LDA_04', ' global_subjectivity',\n",
       "       ' global_sentiment_polarity', ' global_rate_positive_words',\n",
       "       ' global_rate_negative_words', ' rate_positive_words',\n",
       "       ' rate_negative_words', ' avg_positive_polarity',\n",
       "       ' min_positive_polarity', ' max_positive_polarity',\n",
       "       ' avg_negative_polarity', ' min_negative_polarity',\n",
       "       ' max_negative_polarity', ' title_subjectivity',\n",
       "       ' title_sentiment_polarity', ' abs_title_subjectivity',\n",
       "       ' abs_title_sentiment_polarity'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#new viem of columns\n",
    "x.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0     593\n",
       "1     711\n",
       "2    1500\n",
       "3    1200\n",
       "4     505\n",
       "Name:  shares, dtype: int64"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#view of shares\n",
    "y.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classes Definition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The median of shares defined the Classes. This metric will generate two balanced sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "saida_lista= []\n",
    "for i in y:\n",
    "    if i > 1400:\n",
    "        #popular class\n",
    "        saida_lista.append(1)\n",
    "    else:\n",
    "        #unpopular class\n",
    "        saida_lista.append(0)\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "pandas.core.series.Series"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "saida = pd.Series(saida_lista)\n",
    "type(saida)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    0\n",
       "1    0\n",
       "2    1\n",
       "3    0\n",
       "4    0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "saida.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Grid Search Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'n_neighbors': [1, 3, 5, 10, 20]}\n",
      "{'n_estimators': [10, 20, 50, 100, 200, 400]}\n",
      "{'C': [1, 2, 4, 8, 16, 32, 64]}\n"
     ]
    }
   ],
   "source": [
    "#parameters for KNN - number of neighbors\n",
    "lista_k = [1,3,5,10,20]\n",
    "parametros_knn = dict(n_neighbors=lista_k)\n",
    "\n",
    "#parameteres for RF and AdaBoost - number of trees\n",
    "lista_t = [10,20,50,100,200,400]\n",
    "parametros_rf = dict(n_estimators=lista_t)\n",
    "\n",
    "#parameters for SVM\n",
    "lista_c = [1,2,4,8,16,32,64]\n",
    "parametros_rbf = dict(C=lista_c)\n",
    "\n",
    "print(parametros_knn)\n",
    "print(parametros_rf)\n",
    "print(parametros_rbf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# KNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "knn = KNeighborsClassifier()\n",
    "grid = GridSearchCV(knn,parametros_knn,cv=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_treino, x_teste, y_treino, y_teste = train_test_split(x, saida, test_size=0.3)\n",
    "x_treino = x_treino.dropna()\n",
    "y_treino = y_treino.dropna()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GridSearchCV(cv=10, estimator=KNeighborsClassifier(),\n",
       "             param_grid={'n_neighbors': [1, 3, 5, 10, 20]})"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid.fit(x_treino,y_treino)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'n_neighbors': 20}"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid.best_params_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5738827838827838"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid.best_score_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# KNN - Prediction Rolling Windows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "knn = KNeighborsClassifier(n_neighbors=20,p=2)\n",
    "W = 10000\n",
    "L = 1000\n",
    "idxW = 0\n",
    "idxL = idxW + W + 1\n",
    "\n",
    "x_treino = x.iloc[idxW:W,:]\n",
    "y_treino = saida.iloc[idxW:W]\n",
    "x_teste =   x.iloc[idxL:(idxL+L),:]\n",
    "y_teste =  saida.iloc[idxL:(idxL+L)]  \n",
    "knn.fit(x_treino,y_treino)\n",
    "prev_knn = knn.predict(x_teste)\n",
    "\n",
    "idxW = idxW + L\n",
    "W = idxW + 10000\n",
    "idxL = idxW + 10000 + 1\n",
    "\n",
    "for cont in range(28):\n",
    "  x_treino = x.iloc[idxW:W,:]\n",
    "  y_treino = saida.iloc[idxW:W]\n",
    "  x_teste =   x.iloc[idxL:(idxL+L),:]\n",
    "  y_teste_1 =  saida.iloc[idxL:(idxL+L)]  \n",
    "  knn.fit(x_treino,y_treino)\n",
    "  prev_knn_1 = knn.predict(x_teste)\n",
    "  y_teste = pd.concat([y_teste,y_teste_1])  \n",
    "  prev_knn = pd.concat([pd.DataFrame(prev_knn),pd.DataFrame(prev_knn_1)])\n",
    "  idxW = idxW + L\n",
    "  W = idxW + 10000\n",
    "  idxL = idxW + 10000 + 1    \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# KNN Performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.58\n",
      "Precision: 0.58\n",
      "Recall:    0.42\n",
      "F-1 Score: 0.49\n",
      "AUC:       0.57\n"
     ]
    }
   ],
   "source": [
    "#fpr,tpr,thresholds = metrics.roc_curve(y_teste,prev_knn,pos_label=1)\n",
    "print(f'Accuracy:  {metrics.accuracy_score(y_teste,prev_knn):.2f}')\n",
    "print(f'Precision: {metrics.precision_score(y_teste,prev_knn):.2f}')\n",
    "print(f'Recall:    {metrics.recall_score(y_teste,prev_knn):.2f}')\n",
    "print(f'F-1 Score: {metrics.f1_score(y_teste,prev_knn):.2f}')\n",
    "print(f'AUC:       {metrics.roc_auc_score(y_teste,prev_knn):.2f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZQAAAEkCAYAAAAID8fVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdeVhU5dvA8e+wiTiCIpuGuwa5oYKihqGYtmglaZaK+4LmSiqaplIuaS4obmFomhquZWmi5a+s1BRxyQXM3MgFwZ2IgWGZ9w9fJicGmHEAWe5P17muznOec59noObmWc45Co1Go0EIIYQwkdnTboAQQoiyQRKKEEKIQiEJRQghRKGQhCKEEKJQSEIRQghRKCShCAHIYkchTCcJpRidO3eOKVOm4OfnR7NmzfDz82PKlClcvny5yK4ZHR1N165dadKkCa+++mqhxV22bBlubm5kZmYWWsy8fPXVV7i5ueHm5sb58+f11rlw4YK2zvXr142Kv23bNubOnVtgPT8/PyZOnGhU7P8qqt9Hjn79+tG7d+9c5WlpaQwaNIjnnnuOHTt2ADBlyhTc3NzYs2eP3lgTJ07Ez89Pu5/zO4+IiNBbPzQ0FDc3t0L4FKK0snjaDSgvNm/ezKxZs2jZsiVjxozB2dmZa9eusX79enr06EFERASenp6Fft158+ahUqlYsWIFVapUKbS4PXr0oG3btlhYFN9/QmZmZkRFReHu7p7r2O7du5847qpVq2jZsmWB9ZYuXYpSqXzi60DR/T7yk5aWxsiRI4mOjmbBggV069ZN5/hHH32Et7c31apVMyje0qVL6dChAw0aNCiK5opSTHooxeDUqVN89NFHvP3222zYsAF/f3/atWvH22+/zebNm3F0dCQ4OJisrKxCv/aDBw9o0aIFvr6+eHh4FFrcGjVq4OXlVWjxDOHp6cnevXv1Hvvuu+9o1KhRkV6/adOm1K1b16QYRfX7yEtaWhojRozg2LFjLFmyJFcysba2JiUlhRkzZhgc09ramsmTJxdL71SULpJQikFERASVK1dm0qRJuY7Z2toyZcoUunXrRnJysrZ8z5499OjRgxYtWtCuXTumT5/O/fv3tceXLVtG586dOXjwIP7+/jRt2hQ/Pz/WrVsHwPXr13Fzc+PGjRvs3r0bNzc3vvrqK+3wUXx8vE47evfuTb9+/bT7cXFxDB48mFatWtG8eXP69OnDoUOHdK7/3yEvU9tckFdeeYWrV68SGxurU37q1Clu3brFyy+/nOuc/fv307dvX1q0aEGTJk14+eWX2bBhg/Z4zs9o165d2uGanHauXr0ab29v2rVrx61bt3SGvObNm4ebm5vOz2T//v24ubnp/Tx5/T4Arl69ytixY/Hx8cHDw4OAgACOHTuW69wvvviC1157DQ8PD7744osCf145yeTEiROsWLGCzp0756pjZ2fHqFGj2L9/P998802BMQGmTp3K2bNnWb16tUH1RfkhCaWIaTQafv31V9q2bUvFihX11vHz8yMoKIiqVasCsHLlSoKCgmjUqBGhoaGMHDmSffv20b9/f1Qqlfa8O3fuMG3aNHr27MmqVato3LgxH3/8MYcOHcLJyYlNmzbh6OiIj48PmzZtwtfX16A2p6SkMGjQICpUqMCCBQtYsmQJlpaWBAYGcu3aNb3nFEabC9K2bVvs7e2JiorSKd+9e7f22OMOHDjAqFGjaNiwIcuWLWPJkiU888wzzJ49m5iYGIBcP6McCQkJ7Ny5k08++YSJEyfi4uKiEzsoKIj69eszY8YMVCoVd+/eZfr06fj4+DBgwIBcbc/r93Hx4kXefPNNrl69yuTJk/nkk08AGDhwIL/99ptOjAULFvDOO+8wf/78An+XaWlpBAYGEhMTQ3h4eL71hw8fTtOmTZkzZw6JiYn5xgV47bXX6NKlCytXrsxzTkuUTzKHUsTu379PWloarq6uBtV/+PAhq1at4s0332TWrFnacjc3N/r168e2bdvo378/AKmpqSxZskT7ZeHp6clPP/3Ejz/+yPPPP4+XlxdWVlZUrVrVqOGpS5cucf/+fYYNG6adW2jWrBnh4eGkpaUVaZvzY25uzksvvcTevXuZMGECAFlZWezdu5eJEyeSkZGhU//ChQt07dqVkJAQbZmnpydt2rQhOjoaLy+vPH9GGRkZTJ48Oc8v4goVKjB//nzeeecdVq5cyZUrV9BoNMybNw+FQpGrvpWVld5rzZo1CwsLCzZu3IitrS3w6A+Mbt268cknn/D1119rY3Tq1Im+ffvm+zMCSE9PJzAwkKNHj6LRaEhJScm3vrm5OfPnz6d79+5Mnz7doJ5HSEgIx44dY/LkyWzfvh1LS8sCzxFln/RQipi5uTmAwfMjp06dQq1W89prr+mUt27dmmeeeYbo6Gid8scn8itWrEiVKlVITU01qc0NGzbE0dGRkSNH8uGHH/K///0PKysr3n//fRo2bPhU2/zqq6/y119/cfbsWQCOHj3K33//zYsvvpir7vDhw1m8eDFpaWmcP3+evXv3alcoqdXqAq9V0Iqlpk2bEhgYSEREBD/88ANz5szB0dHRoM+RIzo6mhdeeEGbTAAsLS3p1q0bsbGx/P3339ryZ5991qCY586dIy4ujo0bN/Lss88ybdo0bt68me859evXZ9y4cfz8889s3769wGtUq1aNmTNncv78eVauXGlQu0TZJwmliNnZ2VGpUiVu3LiRZ5309HRu374NPPprH8DBwSFXPQcHB515Fng0Qfo4MzMzk++psLGxITIyks6dO7Nv3z7effdd2rZty4QJE3S+4HIUZ5u9vLxwdnbWDnvt3r2bDh066F19df/+fcaPH4+npydvvvkmS5cu1bbFkOvp+zz/5e/vj0ajwc7OjlatWhn0GR738OFDvUko59qP/7wNTVa2trasW7cOLy8vFixYgEql4r333itwEn3w4MG0aNGCjz/+uMAEBI/mtF555RVWr16tTfCifJOEUgx8fHw4evSo3uEigKioKHx8fPj555+xs7MDHs01/FdSUpJ2nuVJ5QzH/LfH9N9hkZo1azJ79mwOHTrEzp07GThwIFFRUYSGhuaKWdRtfpyZmRkvv/wye/fuRa1W88MPP+RauZRjwoQJnDx5ks8//5xTp04RFRXF1KlTC60tGo2GGTNmUL16deDR8ltj2dnZaf+YeFxSUhLAEy0tbtCggXbFm7u7O0FBQZw8eZKwsLB8zzMzM+Pjjz8mMzOTadOmGZR0Z86cSZUqVZgyZYpBvT5RtklCKQaDBw/m4cOHLFy4MNexBw8esGLFClxcXHj++efx8PDAysqKXbt26dQ7duwYCQkJJt+rkvOXfEJCgrbs9u3bXLlyRbu/d+9e2rRpQ1JSEgqFgueee44JEyZQr149vT2tom7zf7366qtcv36d1atXo9Fo8pznOH78OC+++CKtW7fGysoKgJ9//hnQ7aGYmT3Z/wabNm3i8OHDzJo1i0mTJrFr1y727dtnVIxWrVrxyy+/6PTiMjMz2bNnD40aNcLGxuaJ2va4QYMG0aZNG1avXl3g4oe6desSFBTE4cOHtT+r/FStWpUPP/yQP//8k23btpncVlG6yaR8MWjevDnjx48nNDSUy5cv88Ybb+Dg4MDFixdZv3499+/f54svvsDCwoIqVaowfPhwli9fjqWlJZ06deL69euEhYVRt25devToYVJb2rZti42NDfPmzWPcuHGo1WrCw8OpXLmytk7Lli3RaDSMGDGCoUOHYmdnx6+//sqff/7J0KFDc8Us6jb/V/PmzXnmmWf49NNPee2117TJ4r+aNWvG7t27ady4MS4uLpw4cYKIiAgUCoXOnI2trS1//PEHv/32G97e3ga1IT4+noULF+Lv74+Pjw8Au3btYubMmXh5eRl8k+Do0aP55ZdfCAgIYPjw4VSoUIENGzZw7do1wsPDDYpREIVCwfz583n99dcJDg7mm2++yXc4b8CAAezfv59jx47pzO3k5cUXX+T111/n22+/LZT2itJLeijFZMSIEURERGBlZcWiRYsYMWIEGzdupE2bNnz77bc0bdpUW3fMmDGEhIRw/PhxRo0axapVq3j55ZfZvHkzlSpVMqkdSqWSFStWYGlpyfjx41m8eDFvv/22ziM2nJycWLt2LdWqVeOjjz5ixIgRHD58mLlz59K9e3e9cYuyzfq8+uqrZGRk5FoI8Lh58+bRokUL5s6dy9ixYzlw4AAhISG88MILHD9+XFsvMDCQ27dv8+677xo0d5Cdnc3kyZOpVKkSU6ZM0ZbPnj0blUrF9OnTDf4cDRs25Msvv8TZ2Znp06cTHByMQqFg/fr1tG/f3uA4BXFxcSEkJIQ7d+4wadIksrOz86yrUCj4+OOPjeodffDBBzg5ORVGU0UpppBXAAshhCgM0kMRQghRKCShCCGEKBSSUIQQQhQKSShCCCEKhSQUIYQQhaLM3IeScafo3nooSqeKNQpv2a0oWzLVeT8KyRDGfN9YOtQz6VqlSZlJKEIIUWyyC/9leGWBJBQhhDCWJu8bQ8szSShCCGGsfJ40UJ5JQhFCCCNppIeilyQUIYQwVlb+75YpryShCCGEsWRSXi9JKEIIYSwZ8tJLEooQQhhLJuX1koQihBBGkkl5/SShCCGEsaSHopckFCGEMFZWxtNuQYkkCUUIIYwlQ156SUIRQghjyZCXXpJQhBDCWNJD0UsSihBCGEt6KHpJQhFCCCNpsmVSXh9JKEIIYSzpoeglCUUIIYwlcyh6SUIRQghjycMh9ZKEIoQQxpIeil5mT7sBQghR6mRnG749ofDwcHr37q1TFhcXR79+/WjevDkdOnRgzZo1/2lWNmFhYbRv3x4PDw8GDx5MfHx8ocfIiyQUIYQwVlam4dsT2LRpE6GhoTpl9+7dY+DAgdSuXZsdO3Ywbtw4wsLC2Lp1q7bOihUriIyMZPbs2WzZsgVzc3OGDBlCenp6ocXIjyQUIYQwVhH1UBITExkxYgQLFy6kbt26Ose2bt2KpaUlISEh1K9fH39/fwYNGsTq1asBUKvVrF27ltGjR+Pr64u7uzuhoaHcuXOHqKioQouRH0koQghhJI0my+DNGOfOnaNSpUp8++23eHh46ByLiYnBy8sLC4t/p769vb25du0aiYmJxMXFkZqaSps2bbTHlUoljRo1IiYmptBi5Ecm5YUQwlhG9DySk5NJTk7OVW5ra4utra1OmZ+fH35+fnrjJCYm0qBBA50yJycnABISEkhKSgLA2dk5V52EhIRCi5EfSShCCGEsI1Z5rV+/nuXLl+cqHz16NGPGjDE4TlpaGlZWVjplOfvp6emoVCqdssfrqNXqQouRH0koQghhLCN6KAMGDMDf3z9X+X97JwWxtrbO9aWes29jY4O1tbW27PGEoFarsbGxKbQY+ZGEIoQQxjJi9Za+oa0n4eLioh2SypGz7+Ligkaj0ZYplUqdOjnDXIURIz8yKS+EEMbSZBu+FZJWrVpx/PhxMjP/TWZHjhyhTp06ODo64u7ujlKpJDo6Wns8JSWF2NhYWrduXWgx8iMJRQghjFUMNzb+V48ePVCpVEydOpWLFy+yc+dO1q1bR2BgIPBoniMgIIDQ0FD279/P+fPnCQoKwtnZmS5duhRajPzIkJcQQhjrKTxtuFq1aqxZs4Y5c+bg7++Po6MjEyZM4M0339TWGTt2LFlZWcyYMQOVSoWnpycRERHa+ZDCiJEfhSZn0KyUy7hz+Wk3QZQwFWu0f9pNECVUpvqGSeerdi82uG7Fbu+ZdK3SRHooQghhrCd8pEpZJwlFCCGMJS/Y0ksSihBCGEseX6+XJBQhhDCW9FD0koQihBDGkoSilyQUIYQwVtlYHFvoJKEIIYSxMmWVlz6SUIQQwlgyKa+XJBQhhDCWzKHoJQlFCCGMJXMoeklCEUIIY0kPRS9JKEIIYSxJKHpJQhFCCCNpsrKedhNKJEkoQghhLOmh6CUJRQghjCXLhvWSNzaWQGq1mu4BI/jt2Elt2c1biQwbP5VWnbrzWp/h/PrbMe2xLj0G0OT5V3JtH8x99M4GjUbDyrWb6NQ9gHYvv8V7H8zhzr37OtcLmb+Udi+/he9rfVi7aVvxfVjxxMI/XcD/fvj3d+XX0YffDn/Hg3sXOHf2FwYNfEenfhtvT347/B1/P7xIzLHveaF9mzzjfvRhcJG2vdTL1hi+lSOSUEqY9HQ1k2bO5+KVeG2ZRqNhzOSPqGJny+aIpbzxyosETZvD9Zu3ANgcsZQD327Sbh/PmISlpQW933wNgG3fRLH9myg+nhHM+pULuHP3PtPnhmrjL1yxhlNn4vhsyVxmBo8hfF0ke/YfKNbPLYzj19GHIYP7aPcbNKjLNzvX8c03e/Fs1YXZc0JZFjaHbl07A+DqWoOoPV9y4MAhmrd8kX37fmTH9jU4ONjrxJ04YaROXJGHp/AK4NJAEkoJculKPH2GB3HtZoJOefSJ37n613VCgsdSv25thvbrRfOmz/HV7n0A2FetgkM1exyq2VOpkg1Lw9cxYmAfGrs3BODX347RpaMPrVs2o2G9Ogzu25Po478DkKpKY8e3e5k8LpDG7g3xa9+WwX3fInLHruL98MJgNjYVWbVyPocORWvLer31Or//Hsu8+cu4dOkqkZFfs2Hjdnr39gdg9KhBnD4dy/tT53Lp0lWmfTCPK1ev0bJFUwAqV1ayZfNqgieN4q+/THubYbmQlWX4Vo4U6xyKWq1m7969xMTEkJCQQHp6OjY2Nri4uNC6dWu6dOmChUX5ndY5/vs52rVuybtD+tKqk7+2/Pez53F/tj6VKtloy1o0a8yJ38/mirFx6zcoUDCwdw9tmZ1dZQ4eieFW0m2q2NmyZ//PNHJvAMAfFy+jzsigZbPGOrE/XfclmZlZWFiYF8VHFSaY9dEUfv7lN27dSuL5dq0A2LZ9F3v3/qhTT6MBa+sKAHTo8DyRkV/rHG/t/bL23+vWrYWZmYJW3i+zNiIUUYBy1vMwVLH1UP766y+6du3KzJkzuXTpEkqlkurVq1OxYkX+/PNPpk2bxmuvvcb169eLq0klTq/urzJh1BAqWlvrlN+5ew+n/wxNVLOvQmLSHZ0ytVrN+s1fMaTfW1SoYKUtHzmoL5ZWlrzo3x/vzm9y/NQZPpk5+VHsO/ews62sU7+afRUyMjK5/+BhYX9EYaI23p707NGV4MmzdMr//PMyJ06e0e47OTnwdq/X+fXXowDUr1eblJR/2PDFcm5cO8UvB3bi3bqltv7p07G81WsY8fHl9/8/o8gcil7F1h348MMPqVu3Ll9//TVKpTLX8ZSUFIKCgpg1axbh4eHF1axSQZWejpWlpU6ZlaUl6owMnbJ9Px1Eo9Hwxisv6pTfSrxNBSsrln48Hcdq9iyP2MB70+fyxcoFecYGcsUXT5eVlRWrVy/kvYkhPMgn2dvYVGT71ghuJiQSvvoL4NGQ1tw5U5n78VIWLV5FQJ+e7I2KpEmzDty4kZBnLJEHWeWlV7H1UI4fP87EiRP1JhMApVLJhAkTOHbsmN7j5VkFK6tcX+7qjAztcEaOvf/7mS4dfXR6OBqNhvdnLSDgrTfo9EI7mjV2Z9GsqVy++hc/HTySZ2wgV3zxdE3/IIiLF6+wY8fuPOvY2lZmz+5N1K1bize6D0ClSgMgMzOTqL0/sjTsM06dOsfE4A+5Gn+NgL498owl8lFEPZR//vmHWbNm4evri6enJ++++y5//fWX9nhcXBz9+vWjefPmdOjQgTVr1ug2KzubsLAw2rdvj4eHB4MHDyY+Pl6nTkExTFFsCcXW1pbExMR869y4cQMbG5t865RHTg7VdJb5Aty5ex/Hav8Og6nVaqKP/86Lvs/r1Lv34CE3byXRoF4dbVllZSVqudbg+s1bODlWI/nvFDIeSyp3797HysoSu8qVi+YDiSfyztvd6dLZlwf3LvDg3gUmThiJj483D+5dAKBatars/2EbdevWolPnt7h8+d8vkps3E/njj4s68f788zI1az5TrJ+hrNBkZxu8GWP8+PHs27ePGTNmsHXrVuzt7enduzf379/n3r17DBw4kNq1a7Njxw7GjRtHWFgYW7du1Z6/YsUKIiMjmT17Nlu2bMHc3JwhQ4aQnp4OYFAMUxTbkFfPnj2ZMmUKY8aMoXXr1ri4uGBlZYVarSYpKYno6GgWL15Mr169iqtJpYZHE3c+27CFVFUaNhUf9T5Onj5Hs8bu2joXLl0lXZ1Bi8cm1wGq2FbGysqSC5eu4N6wHgBp6encSEikZo3quDesh6WFBSfPxNG6ZTMATpw+RyO3hjIhX8J06twTy8eGJ8eNHYaXZzP6DRiDpaUl3+78Aodq9nTs1EMnmQAcOXqcFi2a6JS5uTXg2LFTxdL2MqcIVm+dP3+eX375hVWrVuHn5wc8mio4duwYX375Jebm5lhaWhISEoKFhQX169cnPj6e1atX06tXL9RqNWvXrmXixIn4+voCEBoaio+PD1FRUXTv3p2tW7fmG8NUxZZQxowZg0Kh4JNPPkGlUuU6XqlSJfr27cu4ceOKq0mlhlfzptRwduKDOYt4d3AAPx8+yulz5/no/SBtnYuX46nh4qRNODnMzc3p0e1llq3+AmfHajhUs+fTz7+kahU7fJ9vjZWVFa+/8iKzFy1nzrQJ3Ll7n3WRO5gZPLa4P6YowH+X8z548BCVKo1Ll64yaeK7tGzZlK7dAvjnn1ScnR0BUKszuH//AWFhEfzy807GjhnKd3v2M3RIH2q61mDTl189jY9S+hXBZPvVq1cBaNWqlbbM3Nwcd3d3oqOjsbS0xMvLS2clrLe3N6tWrSIxMZFbt26RmppKmzb/3rCqVCpp1KgRMTExdO/enZiYmHxjODs7m/QZii2hKBQKxowZQ2BgIOfPnycxMRGVSoW1tTUuLi64u7tjZWVVcKByyNzcnGXzZzLj41B6DRlDzRrVWTJ3Os9U//eXf/f+fexs9Q9RTRw9FBsbaz6YE8o/qam0bNaYiCVztT/v4LHDmLVgOYPHTkFpY8OIQX145UXfYvlsonD06NENS0tLvt+3Raf80KFofDv6E3P8d3q+NZS5c6cyd877nDl7nq7dArj5/zfHCiMZMZSVnJxMcnJyrnJbW1tsbW21+46Oj/4IuHnzJm5ubtry69evo1arAWjQoIFODCcnJwASEhJISkoCyJUUnJycSEh4tPAiMTEx3xilJqHksLKyolmzZsV92VLn7KEonf1arjVYt2JBnvWHBPRiSID+LmuFClYEjRxM0MjBeo9XtLZm7vSJzJ0+8ckbLIrdjJmfaP+9TdtXC6y/J+p/7In6X4H1OnV+y6R2lQtG9FDWr1/P8uXLc5WPHj2aMWPGaPebNWtGgwYNCAkJYdGiRTg4OLBx40bOnz+Pq6sr2dnZuf7oztlPT0/Xjvzoq5OTkNLS0vKNYaryexehEEI8KSOWDQ8YMAB/f/9c5Y/3TgAsLS1Zvnw5U6ZMoWPHjlhYWNChQwd69uzJ2bNnUavV2sSQI2ffxsYG6/9f3alWq3WShlqt1i52sra2zjeGqSShCCGEsYzoofx3aCs/devWZcuWLTx8+BCFQoGtrS3jxo2jTp06JCcna4e1cuTsu7i4oPn/1xInJSXp3J6RlJSkHeZycXHJN4ap5FleQghhJE1mlsGboVJSUggICODMmTPY2dlha2tLSkoKhw8fpn379rRq1Yrjx4+TmZmpPefIkSPUqVMHR0dH3N3dUSqVREdH68SMjY2ldevWAAXGMJUkFCGEMFYR3NioVCpRKBTMnTuXP/74g/PnzzNixAhq1KhBt27d6NGjByqViqlTp3Lx4kV27tzJunXrCAwMBB7NhQQEBBAaGsr+/fs5f/48QUFBODs706VLF4ACY5hKocnpJ5VyGXcuP+0miBKmYo32T7sJooTKVJv2ROWUiW8YXFe58BuD6yYlJTF79mx+++03zMzM6NixI8HBwdjbP7qJ+cyZM8yZM4dz587h6OjIwIED6d+/v/b8rKwsQkND+eqrr1CpVHh6ejJz5kxq1qyprVNQDFNIQhFlliQUkReTE8p7rxtcV7n4W5OuVZrIpLwQQhhJU86eImwoSShCCGEsIybby5MnnpQ/d+4c33//PX///XdhtkcIIUo+eR+KXgYllLt37zJkyBDt3Z6bN2+mZ8+ejB07lpdffplLly4VaSOFEKJEkYSil0EJZeHChZw9e5bGjR89yXbVqlV4e3uzfft2XF1dWbx4cZE2UgghShKNRmPwVp4YlFB+/fVXJk2aRMeOHTl37hyJiYkMGjSIJk2aMGTIEHkplhCifJEeil4GTcr//fffuLq6AnDw4EGsrKy0j0i2sbHReTmTEEKUeeUsURjKoB6Kq6srsbGxAOzbtw8vLy8qVHj0etgDBw7o3DQjhBBlnSYz2+CtPDEoofTp04fFixfz6quvEhsbS58+fQAYNWoUmzZtonfv3kXaSCGEKFGyjdjKEYOGvPr27YutrS3Hjx8nKCiIF198EXj07JiQkBDefvvtIm2kEEKUJHJjo37y6BVRZsmjV0ReTH30yoPeHQ2uWyXyJ5OuVZrk2UPZvn27UYF69uxpcmOEEKJUKGdDWYbKM6F88MEHBgdRKBSSUIQQ5YYMeemXZ0L53/8Kfve0EEKUR5pMSSj65JlQnnnmmeJshxBClB4y5KWXwU8bTkxMZOXKlRw6dIikpCQiIyPZvXs3jRs3plu3bkXZRiGEKFE0klD0Mug+lCtXrvDGG2/w/fff4+Hhob0z/u7du0yaNInvv/++SBsphBAlityHopdBPZT58+dTvXp1NmzYgLW1Nd999x0An3zyCWlpaURERGjfWSyEEGWd9FD0M6iHcvToUYYNG4ZSqUShUOgc69mzJxcvXiySxgkhREmkyTR8K08M6qGYmZnlSiQ5VCoVZmZP/J4uIYQodaSHop9BmaBVq1aEh4frvJ1RoVCQlZXFpk2b8PLyKrIGCiFESaPJNnwrTwxKKJMmTeLGjRt06dKF9957D4VCwWeffUb37t05e/Ys48ePL+p2CiFEyaFRGL4ZQa1Ws2jRIjp06ECLFi3o0+CbfSsAACAASURBVKcPJ06c0B6Pi4ujX79+NG/enA4dOrBmzRqd87OzswkLC6N9+/Z4eHgwePBg4uPjdeoUFMMUBiWU+vXrs2PHDp5//nmOHz+Oubk5R44coV69emzZsgV3d/dCa5AQQpR0RdVDWbFiBTt27GDWrFl8/fXX1KtXj6FDh5KYmMi9e/cYOHAgtWvXZseOHYwbN46wsDC2bt2qc35kZCSzZ89my5YtmJubM2TIENLT0wEMimEKeTikKLPk4ZAiL6Y+HDLBx/CHQ1Y/aPjDIbt164aPjw9TpkwBICUlBU9PT0JDQ/nrr7/YuHEjBw4cwMLi0fT3kiVL2L17N/v370etVuPt7c3EiRPp27ev9nwfHx9CQkLo3r07n376ab4xTGXUbPovv/zC/PnzmTp1KosXL+bQoUMmN0AIIUqb7CyFwZsx7O3t+emnn7h+/TpZWVls27YNKysrGjVqRExMDF5eXtpEAODt7c21a9dITEwkLi6O1NRU7dt0AZRKpfZcoMAYpjJoldfdu3cZNWoUp06dwsLCgipVqvDgwQM+++wz2rZty4oVK6hYsaLJjRFCiNKgqCbbp0+fzvjx4+nUqRPm5uaYmZmxZMkS6tSpQ2JiIg0aNNCp7+TkBEBCQgJJSUkAODs756qTkJAAUGCM/55rLINvbLxy5QrLly+nU6dO2hVee/fuZcaMGSxYsIAZM2aY1BAhhCgtNNmG9zySk5NJTk7OVW5ra4utra1O2Z9//olSqWTFihU4Ozuzbds2goOD2bBhA2lpaVhZWenUz9lPT09HpVLplD1eR61WAxQYw1QGJZSffvqJSZMmad/UCGBubk7Xrl25d+8eK1askIQihCg3jJl5Xr9+PcuXL89VPnr0aMaMGaPdv3nzJsHBwURERGiHrZo2bcrFixcJCwvD2tpamxhy5Ozb2NhgbW2tLXs8aajVamxsbAAKjGEqg29stLe313usdu3a2md7CSFEeWBMD2XAgAH4+/vnKv9v7+T06dNkZGTQtGlTnXIPDw9+/PFHatWqpR3WypGz7+LiQs76qqSkJJRKpU6dnGEuFxeXfGOYyqBJeX9/f1avXk1qaqpOeUZGBhs2bOD11183uSFCCFFaGDMpb2tri6ura67tvwkl5wv9jz/+0Cm/cOECdevWpVWrVhw/fpzMzH+f53LkyBHq1KmDo6Mj7u7uKJVKoqOjtcdTUlKIjY2ldevWAAXGMFWePZTg4GDtv2dlZREbG0unTp3o0KEDDg4OPHz4kIMHD3L//v1ckzxCCFGWGdNDMVSzZs3w9PRk6tSphISE4OLiws6dOzl8+DCbNm2idu3aREREMHXqVIYPH87Zs2dZt24dM2fOBB7NhQQEBBAaGoqDgwOurq4sWrQIZ2dn7cN7e/TokW8MU+V5H4qfn5/hQRSKp/6GR7kPRfyX3Ici8mLqfSiXmrxkcN36Z/cZXPfhw4csWbKEAwcO8ODBA9zc3Bg/frx2TuXMmTPMmTOHc+fO4ejoyMCBA+nfv7/2/KysLEJDQ/nqq69QqVR4enoyc+ZMatasqa1TUAxTyI2NosyShCLyYmpCudjI8ITSINbwhFLaFcpjgh8+fFgYYYQQolTI1igM3soTg1Z5paen8/nnnxMdHY1ardauJsjOzkalUnHp0iXOnDlTpA0VQoiSQlPOEoWhDEooCxYsYOPGjTRs2JD79+9ToUIF7O3tuXDhAhkZGYwdO7ao2ymEECWGsY9UKS8MGvL6/vvv6d+/P7t27aJfv340bdqUbdu2sW/fPqpXr66zBE0IIco6TbbC4K08MSih3Lt3D19fXwDc3d05ffo08Gjd9LBhw9izZ0/RtVAIIUoYmUPRz6CEUrlyZdLS0oBHd8YnJCSQkpKisy+EEOWFRqMweCtPDEooXl5ebNiwgZSUFGrVqkWlSpW0952cOnVK5zZ/IYQo6zQaw7fyxKCEMnr0aM6ePcuwYcMwMzOjb9++TJs2jddff51ly5bx0kuGr8kWQojSToa89DNolZebmxtRUVHaZ8yMHz+eihUrcuLECbp06cLw4cOLtJFCCFGSZJezyXZDGZRQABwdHbUPD1MoFIwYMaLIGvUkErsOfdpNECVM/xptn3YTRBlV3noehsozoWzfvt2oQD179jS5MUIIURqUt8l2Q+WZUD744AODgygUCkkoQohyQ3oo+uWZUJ7204OFEKKkKmeLtwyWZ0J55plnirMdQghRamRlF8pzdcscgyflhRBCPJL9tBtQQklCEUIII2mQORR9JKEIIYSRsmUSRS9JKEIIYaRs6aHoZVRCUavVnD59msTERHx8fFCpVLi4uBRV24QQokSSIS/9DE4okZGRLFmyhIcPH6JQKNi+fTuLFy8GYPny5VSsWLHIGimEECVJliQUvQxa+7Zz504+/PBDXnrpJcLDw7WvAPb39+fEiRMsX768SBsphBAlSbYRW3liUA8lIiKC3r17M3PmTLKysrTl3bp149atW0RGRjJp0qQia6QQQpQk5S1RGMqgHkp8fDwdO3bUe6xx48bcvn27UBslhBAlmQaFwZuhjh49ipubm96tU6dOAMTFxdGvXz+aN29Ohw4dWLNmjU6M7OxswsLCaN++PR4eHgwePJj4+HidOgXFMIVBCcXBwUH76Pr/+vPPP3FwcCi0BgkhREmXrTB8M1SLFi04ePCgzrZ27VosLCwIDAzk3r17DBw4kNq1a7Njxw7GjRtHWFgYW7du1cZYsWIFkZGRzJ49my1btmBubs6QIUNIT08HMCiGKQwa8uratSsrV67E2dkZPz8/4NEDIU+dOkV4eDjdu3cvlMYIIURpUBTLhq2srLSvCAHIyMhg7ty5dO7cmV69evHpp59iaWlJSEgIFhYW1K9fn/j4eFavXk2vXr1Qq9WsXbuWiRMn4uvrC0BoaCg+Pj5ERUXRvXt3tm7dmm8MUxnUQxk7diytW7cmODiYVq1aAdC3b1969+5N/fr1GTt2rMkNEUKI0iLLiO1JbdiwgYSEBN5//30AYmJi8PLywsLi336At7c3165dIzExkbi4OFJTU2nTpo32uFKppFGjRsTExBgUw1QG9VCsrKwIDw/n8OHD/Pbbbzx48IDKlSvj7e3NCy+8gEIhS+iEEOVHthHfecnJySQnJ+cqt7W1xdbWVu85KpWK8PBw+vfvj7OzMwCJiYk0aNBAp56TkxMACQkJJCUlAWjrP14nISHBoBj/PddYRt3Y2K5dO9q1a2fSBYUQorQz5skr69ev13trxejRoxkzZozec7755hvS09Pp37+/tiwtLQ0rKyudejn76enpqFQqnbLH66jVaoNimMqghGLIfSajR482uTFCCFEaGLNseMCAAfj7++cqz6t3Ao8SSufOnbG3t9eWWVtbaxNDjpx9GxsbrK2ttWWPJw21Wo2NjY1BMUxlckKpVKkSDg4OklCEEOWGMau38hva0ufevXucOnWKESNG6JS7uLhoh7Vy5Oy7uLhobzhPSkpCqVTq1MkZ5ioohqkMSijnzp3LVZaSksLRo0eZM2cOc+bMMbkhQghRWhTlo1dOnDiBQqHQLoDK0apVKzZt2kRmZqZ2Uv3IkSPUqVMHR0dH7OzsUCqVREdHU69ePeDR93RsbCx9+vQxKIapDFrlZW5unmuzs7OjS5cuBAYGMn/+fJMbIoQQpUVR3IeSIzY2lpo1a+YagurRowcqlYqpU6dy8eJFdu7cybp16wgMDAQezYUEBAQQGhrK/v37OX/+PEFBQTg7O9OlSxeDYpjK5MfX16lThwsXLhRGW4QQolQoykev3L59Gzs7u1zl1apVY82aNcyZMwd/f38cHR2ZMGECb775prbO2LFjycrKYsaMGahUKjw9PYmIiNDOqRgSwxQKTc7A2xNIT09n0qRJxMbGsn///kJp0JO67u33VK8vSp4ZifYFVxLl0tqr2006//NnAgyuO+jGRpOuVZoY1EPx9fXNda9JVlYWDx48ICMjg2nTphVJ44QQoiR6kqGs8sCghJLXvSdKpRI/Pz/atm1bqI0SQoiSTJ42rJ9BCaVTp060atVK77ieEEKUN1nSQ9HLoFVekydP5sCBA0XcFCGEKB3kBVv6GdRDsbe3x9zcvKjbIoQQpUJ5SxSGMiihBAYGMmvWLC5cuEDDhg31vv9E5lGEEOXFEy+NLeMMSigffPABAKtXr9YpVygUaDQaFAoFcXFxhd86IYQogWSVl34GJZQvvviiqNshhBClhgx56ZdnQunUqRNhYWE0btyY1q1bF2ebhBCiRDPlxVllWZ4J5caNG4XyfHwhhChrZMhLP5Of5SWEEOWNDHnpl29CkVf7CiFEbrLKS798E8ro0aOxtLQsMIhCoeCnn34qtEYJIURJli0pRa98E0rjxo2pVq1acbVFCCFKBZmU1y/fhDJixAhatmxZXG0RQohSQeZQ9JNJeSGEMJKs8tJPEooQQhhJ5lD0yzOh+Pv7631mlxBClHeSTvTLM6F8/PHHxdkOIYQoNWQORT8Z8hJCCCNlSR9FL0koQghhJOmh6GfQGxuFEEL8KxuNwZuxdu7cyauvvkrTpk3p2rUrUVFR2mNxcXH069eP5s2b06FDB9asWaPbruxswsLCaN++PR4eHgwePJj4+HidOgXFMIUkFCGEMJLGiM0Y33zzDVOnTuXtt99m9+7ddOvWjffee4/jx49z7949Bg4cSO3atdmxYwfjxo0jLCyMrVu3as9fsWIFkZGRzJ49my1btmBubs6QIUO0D/o1JIYpZMirBFNUVlJlwhgqtvNGk67mn6gfSP50DWRnY+7iTNWpE7Bq1pisW0k8XLqKtN+ic8Uwd62B86YI7ga9T/qJ3x/FrWRDlfdGY92+LQoUpP70Cw+XrESjSivujyiegPfrPgSGjdcpO/F9NMuHf0LNRnXoGzKEWo3rkHj1Ftvnb+TcL7/nitGme3s69u3Cx29N15ZVcarK4ujPdOqlJv/D6GYDiuaDlGJFMeSl0WhYunQpAQEBDBjw6Gc+cuRIYmJiOHLkCMeOHcPS0pKQkBAsLCyoX78+8fHxrF69ml69eqFWq1m7di0TJ07E19cXgNDQUHx8fIiKiqJ79+5s3bo13ximkoRSglUNHo95NXuSRozHvGoV7D+aRnZyMikbt1BtwSwyr/5F0qB3qdi+HfbzQkh8ZzBZCbd0YthPnYiZtbVOWZVJ47CsVZM7oyeBmRlVP5iE3fhRPPh4UXF+PPGEajR05fjeo2yY/u+Xf0a6msr2tgRHhnBqfwzr3/+U+i2fZfSnk5j/9kyunrmkrevetjED5gby17krueI+vH2fma9O0pZpsmW2QJ+imJS/fPkyN27coFu3bjrlOUNSQ4cOxcvLCwuLf7+2vb29WbVqFYmJidy6dYvU1FTatGmjPa5UKmnUqBExMTF0796dmJiYfGM4Ozub9BkkoZRg1u1ac+/D+WRevkomkLrvf1h7Nicj7gKWtWpyO3AcmlQVf1+Jp0KrllR6/VWSw9dqz6/05utgrmdUU63m/oKlZFy4CEDqt3uo9Fb3YvpUwlQ1Gtbk+vl4km8/0Cl/aehrpKWoWDd5FVmZWSRcukHd5g15adhrhI9dAsDr496i67v+JF5J0Bs34dLNXHFFbsbMjSQnJ5OcnJyr3NbWFltbW+3+1atXAVCr1QwfPpwzZ87g6urKyJEj8fPzIzExkQYNGujEcHJyAiAhIYGkpCSAXEnBycmJhIRHv++CYpiaUGQOpQTLfpiMzcsvoqhQATOHali3bY36/J9YNXkO9YWLaFJV2rrq389i1bSRdt/cyRHbYf25//HiXHHvz11ERtwfj+q5OFPxpU6kHztZ9B9IFIoaDV25dflGrnLHWs5cPXOZrMx/H114Le4q9Vs+q913827Eon6zOL73aK7zq+cRV+RmzBzK+vXr6dSpU65t/fr1OjFTUlIACA4O5qWXXmLt2rX4+Pjw7rvvcujQIdLS0rCystI5J2c/PT0dlUqlU/Z4HbVaDVBgDFNJD6UEu//JUuxD3qfGT7tRmJuTduwEyRHrqDJ+FFl37ujUzbp3H3MnR+1+lfffI2XzDjKvXc8zvv2HU7F5+UUybyZwN2J9nvVEyWFuaYFjLWea+XnRPegdFGYKYvb8xs7QLTy884A6zerr1Hd4xhFl1cra/QV9PgTguXZNc8Wu0cCVjHQ1M76dj51TFS4cO8+WWet4kHS/aD9UKWRMD2XAgAH4+/vnKn+8dwJoXxUyaNAgevToAcBzzz3H2bNnWbt2LdbW1trEkCNn38bGBuv/H9pWq9U6SUOtVmNjYwNQYAxTSQ+lBLNwfYaMCxe5PWI8d8ZPwaK6C3ZjR6KwrgDqDJ26mgw1iv//D9Lmlc6YO1Tj741b8o2fvO5LkoaMJivpNg5L5oG8UK3Ec67jgoWlBerUNFa+u5CtczfQ5o32vPPBQI7vOULtJvXw6/8y5hbm1GvREJ+3/LCwNOzvxhoNnqFCxQpsClnLp2OWUNXZnqD10zDTN2xazmUbsdna2uLq6ppr+29CcXFxAeDZZ5/VKW/YsCHXr1/HxcVFO6yVI2ffxcWF6tWr65Q9XidnKKugGKYq1h5Knz59DH4L5KZNm4q4NSWb+TM1qBI0ilv+vclKetQbuT93IQ5hC/jnm+9QKCvp1FdYWqFJT8PMvip2Y0dwJ+h9yMrWP4fy/zKvXAXg7rRZVN+1hQotmmlXgomS6eaf1xnTfCD/PHg0PHItLh6FAgLDxvPlh2tZM3E5AR8Npc/MQSTFJ7L/8+/oPKRbAVEfCW4/iqzMTDLVmQCsGLmA0OjPaODpxoXouCL7TKWRpggm5Rs1akSlSpU4c+YM3t7e2vILFy5Qq1YtWrVqxaZNm8jMzNROqh85coQ6derg6OiInZ0dSqWS6Oho6tWrBzwaRouNjaVPnz4ABcYwVbEmFF9fX5YsWUK9evVo1qxZcV661LFyb4gmNVWbTADU5y+gsDAn6+5dLBvU1alvXq0qWXfuYd2mFWZV7HBcFapz3CF0HslrN/D35u1UfL4NaYej0aQ9Wiacfecumr9TMKtiV/QfTJgsJ5nkSLh4AwsrSyrb23Jk568c/eYgtg52PLz9gI4BL3H3+m2D4qan6i4b//tuMin3U6jqYl9obS8rimKVl7W1NUOHDmXlypU4OTnRvHlzvvvuOw4ePMjnn3/Os88+S0REBFOnTmX48OGcPXuWdevWMXPmTODRXEhAQAChoaE4ODjg6urKokWLcHZ2pkuXLgD06NEj3ximKtaEEhgYiFKpZNGiRYSHh+Pq6lqcly9Vsu7cxcy2MuZOjmQlPfpCsKxTC4DMq39hGfAOCmtrbVKw8miK+mwsqgO/kn76rDaOwswcl23ruTd3ofY+FfuPpnH3g9mkHfgVAPMa1TGzsyXjyl/F+RHFE2j5kjf9Zg9jYrsRZGU86knUalyXfx6mUL3BM/T9cAgr313Ew/9fqdW8sxdxv53NLyQAtg52zP0xjMUDZnP55J8AVHWxR2lfmYRLN4vuA5VSRbWY+t1338XGxoawsDBu3bpFvXr1WLZsGW3btgUeLSGeM2cO/v7+ODo6MmHCBN58803t+WPHjiUrK4sZM2agUqnw9PQkIiJCO6dSrVq1AmOYotgn5fv27cuvv/7KkiVLWLhwYXFfvtRQn41F/cefVJ0ezMOlq1BYV6DKlPf4Z8/3qH76FduhA6g6YzLJn62nok8brJo8x/05C9Ckqsh6bPVXzpBX9u07aJL/BuCfb6OoMiaQe/fuoVFnUHXSOFQHDmqHwETJ9cfRcygUCgZ8HMh3K77CuU51ek3tx97wb0m4eIMmvs15cdCrnPohBp+3OlK/xbOsm7yqwLjJdx4Sf/YyfUOGsH5qOGZmZvQJGUzswTO57lcRkK0puodDDhw4kIEDB+o91rRpUzZv3pznuebm5kycOJGJEyfmWaegGKZQaDRF+JPJQ1JSEufOnaNjx46FFvO6t1+hxSopzByqUSVoFBW8WkBGBqk//sLDFashXY25aw3sp03CqvFzZN64yYMlK0k/GpM7iLkZrof3c3tk0L/zIxWssBs1DJsXO6KoYIXqwEEeLF6O5p/U4v2ARWxGYtkcqqnVuC5vfzCAus3qo/o7lQNf/sCusO0ANPFtztvTBuDg6shf564Q+dE6nZsac7wxvheNnm+qc6d8ZXtb3pk+kCa+zTG3MOfUDzF8+eFaUpP/KbbPVlzWXt1u0vkBtQ3/i35j/FcmXas0eSoJpSiUxYQiTFNWE4ownakJpU/t3MuA8/Jl/NcmXas0kftQhBDCSEWxyqsskIQihBBGypSEopckFCGEMJL0UPSThCKEEEaSZzDrJwlFCCGMVEbWMhU6SShCCGGkJ3m1b3kgCUUIIYxUFI9eKQskoQghhJGkh6KfJBQhhDCSzKHoJwlFCCGMJKu89JOEIoQQRpL7UPSThCKEEEaSORT9JKEIIYSRsjQy6KWPJBQhhDCSDHnpJwlFCCGMVJQv2CrNJKEIIYSRJJ3oJwlFCCGMJJPy+klCEUIII0lC0U8SihBCGElWeeln9rQbIIQQpY3GiH+McfnyZdzc3HJt27ZtAyAuLo5+/frRvHlzOnTowJo1a3TOz87OJiwsjPbt2+Ph4cHgwYOJj4/XqVNQDFNID0UIIYxUVM/y+uOPP1Aqlezdu1envHLlyty7d4+BAwfSuXNnQkJCOH36NCEhIVSuXJlevXoBsGLFCiIjI5k3bx7Ozs4sWrSIIUOG8N1331GhQgWDYphCEooQQhipqOZQLly4QP369XF0dMx1bN26dVhaWhISEoKFhQX169cnPj6e1atX06tXL9RqNWvXrmXixIn4+voCEBoaio+PD1FRUXTv3p2tW7fmG8NUMuQlhBBG0mg0Bm/G+OOPP6hfv77eYzExMXh5eWFh8W8/wNvbm2vXrpGYmEhcXBypqam0adNGe1ypVNKoUSNiYmIMimEqSShCCGGkLLIN3oxx4cIFkpKSeOedd2jXrh19+vTh4MGDACQmJuLi4qJT38nJCYCEhARtQnB2ds5VJyEhwaAYppIhLyGEMJIxd8onJyeTnJycq9zW1hZbW1vtfmpqKtevX8fe3p4JEyZQqVIlvv32W4YOHcratWtJS0vDyspKJ0bOfnp6OiqVSqfs8TpqtRqgwBimkoQihBBGMmb11vr161m+fHmu8tGjRzNmzBjtvo2NDcePH8fS0lL7Jd+kSRMuXbpEREQE1tbW2sSQI2ffxsYGa2trbdnjSUOtVmNjYwNQYAxTSUIRQggjGdNDGTBgAP7+/rnKH++d5KhUqVKusmeffZaffvqJmjVrkpSUpHMsZ9/FxUU7X5OUlIRSqdSp06BBA229/GKYSuZQhBDCSMbch2Jra4urq2uu7b8J5eTJk7Ro0YLTp0/rlJ89e5aGDRvSqlUrjh8/TmZmpvbYkSNHqFOnDo6Ojri7u6NUKomOjtYeT0lJITY2ltatWwMUGMNUklCEEMJI2RqNwZuhmjRpgqurK9OnT+f48eNcunSJ2bNnc/LkSUaOHEmPHj1QqVRMnTqVixcvsnPnTtatW0dgYCDwaC4kICCA0NBQ9u/fz/nz5wkKCsLZ2ZkuXboAFBjDVApNUd2hU8yue/s97SaIEmZGov3TboIoodZe3W7S+fUdWhpc99KdEwbXTUxMZNGiRRw6dIjk5GQaN27Me++9p+1hnDlzhjlz5nDu3DkcHR0ZOHAg/fv3156flZVFaGgoX331FSqVCk9PT2bOnEnNmjW1dQqKYQpJKKLMkoQi8mJqQqnn0MLgupfvnDTpWqWJTMoLIYSRNPJwSL0koQghhJHk8fX6SUIRQggjlZGZgkInCUUIIYwkPRT9JKEIIYSRsrJlDkUfSShCCGEkY1+cVV5IQhFCCCPJHIp+klCEEMJIMoeinyQUIYQwkvRQ9JOEIoQQRpJJef0koQghhJFkyEs/SShCCGEkGfLSTxKKEEIYyZjH0pcnklCEEMJIch+KfpJQhBDCSNJD0U8SihBCGClbHl+vlyQUIYQwkkzK6ycJRQghjCQJRb8y8wpgIYQQT5fZ026AEEKIskESihBCiEIhCUUIIUShkIQihBCiUEhCEUIIUSgkoQghhCgUklCEEEIUCkkoQgghCoUkFCGEEIVCEkoZkZ2dTVhYGO3bt8fDw4PBgwcTHx//tJslSpDw8HB69+79tJshyjBJKGXEihUriIyMZPbs2WzZsgVzc3OGDBlCenr6026aKAE2bdpEaGjo026GKOMkoZQBarWatWvXMnr0aHx9fXF3dyc0NJQ7d+4QFRX1tJsnnqLExERGjBjBwoULqVu37tNujijjJKGUAXFxcaSmptKmTRttmVKppFGjRsTExDzFlomn7dy5c1SqVIlvv/0WDw+Pp90cUcbJ4+vLgMTERACcnZ11yp2cnEhISHgaTRIlhJ+fH35+fk+7GaKckB5KGaBSqQCwsrLSKbeyskKtVj+NJgkhyiFJKGWAtbU1QK7koVarsbGxeRpNEkKUQ5JQyoDq1asDkJSUpFOelJSUaxhMCCGKiiSUMsDd3R2lUkl0dLS2LCUlhdjYWFq3bv0UWyaEKE9kUr4MsLKyIiAggNDQUBwcHHB1dWXRokU4OzvTpUuXp908IUQ5IQmljBg7dixZWVnMmDEDlUqFp6cnERERuSbqhRCiqCg0Go3maTdCCCFE6SdzKEIIIQqFJBQhhBCFQhKKEEKIQiEJRQghRKGQhCKEEKJQSEIRpZIsThSi5JGEUg7169cPNzc3na1Jkyb4+fkREhLCgwcPiuza169fx83NjW3btgFw9OhR3NzcOHz4sMExtm3bxty5cwulPcuWLcPNzY3MzMw867i5uRn9cqp+/foV2tsRn+T6QjwNcmNjOfXss88yc+ZM7X5GRgaxsbEsWbKE8+fPExkZiUKhKPJ2YTizigAACTxJREFUNGrUiE2bNuHm5mbwOatWraJly5ZF2CohxJOQhFJOKZVKvLy8dMratm1LWloaYWFh/P777zRv3rzI21G5cuVc7RBClE4y5CV0NGnSBICbN28Cj4ZugoODmTBhAi1atODtt98GHj0af+HChXTo0IEmTZrQtWtXvv7661zxtm/fziuvvEKzZs146623uHjxos5xfUNeZ86cYejQoXh6euLt7c2YMWO4du0a8Gj458aNG+zatUunV3Px4kVGjBhBy5YtadGiBYGBgVy+fFnnWn///TfTp0+nTZs2tGzZkpCQkCd6X8z169cJDg7Gx8eHxo0b07ZtW4KDg7l3716uuuHh4Tz//PM0b96cESNGEB8fr3P81q1bTJgwAW9vbzw8PAgICODUqVP5Xj8qKgp/f388PDy0P5//xhXiaZAeitBx5coVAGrVqqUt27NnDx06dGDZsmXaL+AxY8Zw9OhRRo4cibu7Oz/++CNTpkwhNTWVvn37ArB582ZmzpxJr169mDJlCqdPnyYoKCjf658/f54+ffrg5ubGrFmzMDc3Z+nSpQwaNIhdu3axadMmxo8fj5ubGyNHjgQgPj6ed955hxo1ajBr1iwAPvvsM3r37s3OnTupXr06Go2GYcOGcfnyZcaNG4ezszORkZEcPXrUqJ9PWloa/fv3x9bWlqlTp2JnZ8fJkydZuXIllpaWzJkzR1v39OnT3L17l/fff5+srCyWLFnCwIED2bt3LxUqVOD+/fu88847mJmZERwcjK2tLRs3bqR///58+eWX2uT+uJiYGN577z2GDh3KpEmTuHv3LqGhoQwfPpy9e/cWyzClEHmRhFKOPT4R/fDhQ44dO8aqVato0aIFjRs31h7TaDTMmzcPpVIJwOHDhzlw4ADz58+ne/fuAPj6+pKdnc2SJUvo0aMHFSpUYPny5fj5+Wm/5H19fbUJIi+ffvopSqWS9evXU6lSJQDq1avHsGHDOH36NN7e3lhZWVG1alXtUNmyZcswNzfniy++oEqVKgC88MILdO7cmVWrVvHRRx9x8OBBTp48yfLly+ncuTMAHTt2pGvXrtokaogrV67g5OTE3LlzqVevHgDPP/88Z8+e1Xl9AIBCoWDt2rW4urryf+3db0hTbx/H8XfzV00pKRUjs5rMZEmaULlcZS6C2gNB61GKQaJENo2KFYowHwwhgjmUisraJCmRhESxPyRpipNoFkFQ9I8hBqFhRqYobPcD8dByid7s5ndD3xf4YJ5zXed7beP6bNc57ABs2rSJ3Nxc7t69S35+Pi6Xi5GREdrb29FoNABkZWWRk5NDTU0NN27cmHP8gYEB1Go1paWlyg9/rl27lqdPnzI+Pq68RkL8GyRQ/lIDAwMBoQGgUqkwGAzYbLaAT7pxcXEBE5Xb7QZm7lf+ayjt37+f5uZmXr16RUxMDMPDw8rkPSs7O3veQHn+/Dl79uxRwgRmJuKurq4/tunv70ev17NixQqlnvDwcAwGA729vQA8e/aMsLAwjEaj0i4sLAyTycTly5f/2PfvNm/eTFNTE36/n8HBQbxeL+/evePjx49zls/S0tKUMIGZCxDWr1+P2+0mPz+f/v5+kpKSiI+PV+pesmQJRqMRl8vF1NTUnF+L3rlzJw6Hg+zsbEwmE7t37yYtLU3OQ4n/CxIofymdTofNZgNmJrHly5cTFxcXMJHPiomJCXg8OjoKwI4dO4L2/eXLF/75Z+atFRUVFbAtNjZ23rpGR0eJjo5e2CB+afPw4cM5AQmwdOlSAL59+0ZkZKRS10LrCaahoYGrV6/y9etXYmJi2LJlC+Hh4UxOTgbs9/vzBhAdHc3Y2JhSt9frDVr37Pbf77iZmpqK0+nE6XTicrm4cuUKq1atoqCggJMnT8qSl/hXSaD8pSIiIkhJSfmv2q5cuRK1Wk1jY2PQ7fHx8cqkOTw8HLBtNozm6zvYPj09PWi1WuLi4oK20ev1FBUV/bHfqKgoxsbGmJ6eVkJmIfX8rq2tjerqaiwWC4cOHVIC89SpU3P6mn0OfjU8PExqaqpS97Zt2ygvLw96rNWrVwf9v16vR6/XMzU1hcfj4c6dO9TV1ZGYmMjBgwcXNR4hQkmu8hKLptfrmZycZHp6mpSUFOXP6/XicDiYmJhAo9Gwbt06Ojo6Ato+fvx43r63b99OT09PwKd9r9dLUVGRcgJdpQp826anp/P+/Xt0Ol1APbdu3aK9vR0Ag8GAz+fj/v37AW07OzsXNXaPx0NERARFRUVKmPz48QOPx4PP5wvY98WLFwEh8/LlS4aGhtDr9Urdnz59YuPGjQF1d3R04HK5AoJv1oULFzh8+DB+v59ly5aRkZFBVVUVAENDQ4saixChJoEiFi0zM5P09HTMZjMNDQ309fVRX19PZWUlPp9P+RZhsVhwu92cPXuWrq4url+/Tl1d3bx9l5SU8P37dwoLC3n06BEdHR2UlJSQmJjIgQMHAIiMjOTt27e43W58Ph9ms5nPnz9TWFjIgwcP6O7upqysjNbWVpKTk4GZEMzKysJqteJ0Ounq6qKsrIwPHz4sauxbt27l58+f2Gw2+vr6uHfvHnl5eYyMjDAxMTFn/+LiYjo7O2lpacFsNpOYmEhubi4Ax44dQ6VScfToUVpbW+nt7aWqqoqbN2+i1WqDLl9lZGTw+vVrzpw5Q3d3N0+ePOH8+fOo1Wr27du3qLEIEWqy5CUWTaVSce3aNWpra3E6nYyMjBAbG8uRI0cwm83KfiaTCZVKxaVLlygtLUWj0XDx4kWKi4v/2HdycjKNjY3Y7XbOnTtHeHg4u3btwmKxEBERAcDx48exWq2UlJTQ1tZGUlISt2/fxuFwUFFRgd/vR6vV4nA4MJlMSt+1tbXY7Xbq6+sZHx8nKyuLEydOYLfbFzz2nJwcBgcHaWlpobm5mTVr1rB3714KCgqorKzkzZs36HQ6YOaKrYSEBCoqKpiensZoNFJeXo5arQZmzt80NTVht9uprq5mcnKSDRs2YLVaycvLC3r8zMxMampqqK+v5/Tp0/j9flJSUnA6nSQkJCx4HEL8L8gtgIUQQoSELHkJIYQICQkUIYQQISGBIoQQIiQkUIQQQoSEBIoQQoiQkEARQggREhIoQgghQkICRQghREhIoAghhAiJ/wAR/KLkhgMYvQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax= plt.subplot()\n",
    "array = confusion_matrix(y_teste, prev_knn)      \n",
    "df_cm = pd.DataFrame(array, range(2),\n",
    "                  range(2))\n",
    "#plt.figure(figsize = (10,7))\n",
    "sn.set(font_scale=1.4)#for label size\n",
    "sn.heatmap(df_cm, annot=True,annot_kws={\"size\": 14}, ax = ax,fmt=\"d\")# font size\n",
    "\n",
    "ax.set_xlabel('Predicted labels');ax.set_ylabel('True labels'); \n",
    "ax.set_title('Confusion Matrix for KNN'); \n",
    "#ax.xaxis.set_ticklabels(['Não Popular', 'Popular']); ax.yaxis.set_ticklabels(['Não Popular', 'Popular']);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SVM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "rbf_svc = svm.SVC(kernel='rbf', gamma=0.7)\n",
    "grid = GridSearchCV(rbf_svc,parametros_rbf,cv=10)\n",
    "\n",
    "x_treino, x_teste, y_treino, y_teste = train_test_split(x, saida, test_size=0.3)\n",
    "x_treino = x_treino.dropna()\n",
    "y_treino = y_treino.dropna()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GridSearchCV(cv=10, estimator=SVC(gamma=0.7),\n",
       "             param_grid={'C': [1, 2, 4, 8, 16, 32, 64]})"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid.fit(x_treino,y_treino)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'C': 1}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid.best_params_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5049084249084249"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid.best_score_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SVM - Predicition Rolling Windows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "rbf_svc = svm.SVC(C=1,kernel='rbf', gamma=0.7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "W = 10000\n",
    "L = 1000\n",
    "idxW = 0\n",
    "idxL = idxW + W + 1\n",
    "\n",
    "x_treino = x.iloc[idxW:W,:]\n",
    "y_treino = saida.iloc[idxW:W]\n",
    "x_teste =   x.iloc[idxL:(idxL+L),:]\n",
    "y_teste =  saida.iloc[idxL:(idxL+L)]  \n",
    "rbf_svc.fit(x_treino,y_treino)\n",
    "prev_svm = rbf_svc.predict(x_teste)\n",
    "\n",
    "idxW = idxW + L\n",
    "W = idxW + 10000\n",
    "idxL = idxW + 10000 + 1\n",
    "\n",
    "for cont in range(28):\n",
    "  x_treino = x.iloc[idxW:W,:]\n",
    "  y_treino = saida.iloc[idxW:W]\n",
    "  x_teste =   x.iloc[idxL:(idxL+L),:]\n",
    "  y_teste_1 =  saida.iloc[idxL:(idxL+L)]  \n",
    "  rbf_svc.fit(x_treino,y_treino)\n",
    "  prev_svm_1 = rbf_svc.predict(x_teste)\n",
    "  y_teste = pd.concat([y_teste,y_teste_1])  \n",
    "  prev_svm = pd.concat([pd.DataFrame(prev_svm),pd.DataFrame(prev_svm_1)])\n",
    "  idxW = idxW + L\n",
    "  W = idxW + 10000\n",
    "  idxL = idxW + 10000 + 1    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SVM - Performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.50\n",
      "Precision: 0.48\n",
      "Recall:    0.55\n",
      "F-1 Score: 0.52\n",
      "AUC:       0.50\n"
     ]
    }
   ],
   "source": [
    "print(f'Accuracy:  {metrics.accuracy_score(y_teste,prev_svm):.2f}')\n",
    "print(f'Precision: {metrics.precision_score(y_teste,prev_svm):.2f}')\n",
    "print(f'Recall:    {metrics.recall_score(y_teste,prev_svm):.2f}')\n",
    "print(f'F-1 Score: {metrics.f1_score(y_teste,prev_svm):.2f}')\n",
    "print(f'AUC:       {metrics.roc_auc_score(y_teste,prev_svm):.2f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax= plt.subplot()\n",
    "array = confusion_matrix(y_teste, prev_svm)      \n",
    "df_cm = pd.DataFrame(array, range(2),\n",
    "                  range(2))\n",
    "#plt.figure(figsize = (10,7))\n",
    "sn.set(font_scale=1.4)#for label size\n",
    "sn.heatmap(df_cm, annot=True,annot_kws={\"size\": 14}, ax = ax,fmt=\"d\")# font size\n",
    "\n",
    "ax.set_xlabel('Predicted labels');ax.set_ylabel('True labels'); \n",
    "ax.set_title('Confusion Matrix for SVM'); "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Random Forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "rf = RandomForestClassifier(random_state=1986,\n",
    "                           criterion='gini',\n",
    "                           max_depth=10,\n",
    "                           n_estimators=50,\n",
    "                           n_jobs=-1)\n",
    "\n",
    "grid = GridSearchCV(rf,parametros_rf,cv=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_treino, x_teste, y_treino, y_teste = train_test_split(x, saida, test_size=0.3)\n",
    "x_treino = x_treino.dropna()\n",
    "y_treino = y_treino.dropna()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GridSearchCV(cv=10,\n",
       "             estimator=RandomForestClassifier(max_depth=10, n_estimators=50,\n",
       "                                              n_jobs=-1, random_state=1986),\n",
       "             param_grid={'n_estimators': [10, 20, 50, 100, 200, 400]})"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid.fit(x_treino,y_treino)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'n_estimators': 200}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid.best_params_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6661172161172162"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid.best_score_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Random Forest - Prediction Rolling Windows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "rf = RandomForestClassifier(random_state=1986,\n",
    "                           criterion='gini',\n",
    "                           max_depth=10,\n",
    "                           n_estimators=200,\n",
    "                           n_jobs=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "W = 10000\n",
    "L = 1000\n",
    "idxW = 0\n",
    "idxL = idxW + W + 1\n",
    "\n",
    "x_treino = x.iloc[idxW:W,:]\n",
    "y_treino = saida.iloc[idxW:W]\n",
    "x_teste =   x.iloc[idxL:(idxL+L),:]\n",
    "y_teste =  saida.iloc[idxL:(idxL+L)]  \n",
    "rf.fit(x_treino,y_treino)\n",
    "prev_rf = rf.predict(x_teste)\n",
    "\n",
    "idxW = idxW + L\n",
    "W = idxW + 10000\n",
    "idxL = idxW + 10000 + 1\n",
    "\n",
    "for cont in range(28):\n",
    "  x_treino = x.iloc[idxW:W,:]\n",
    "  y_treino = saida.iloc[idxW:W]\n",
    "  x_teste =   x.iloc[idxL:(idxL+L),:]\n",
    "  y_teste_1 =  saida.iloc[idxL:(idxL+L)]  \n",
    "  rf.fit(x_treino,y_treino)\n",
    "  prev_rf_1 = rf.predict(x_teste)\n",
    "  y_teste = pd.concat([y_teste,y_teste_1])  \n",
    "  prev_rf = pd.concat([pd.DataFrame(prev_rf),pd.DataFrame(prev_rf_1)])\n",
    "  idxW = idxW + L\n",
    "  W = idxW + 10000\n",
    "  idxL = idxW + 10000 + 1  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Random Forest - Performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.67\n",
      "Precision: 0.66\n",
      "Recall:    0.65\n",
      "F-1 Score: 0.65\n",
      "AUC:       0.67\n"
     ]
    }
   ],
   "source": [
    "print(f'Accuracy:  {metrics.accuracy_score(y_teste,prev_rf):.2f}')\n",
    "print(f'Precision: {metrics.precision_score(y_teste,prev_rf):.2f}')\n",
    "print(f'Recall:    {metrics.recall_score(y_teste,prev_rf):.2f}')\n",
    "print(f'F-1 Score: {metrics.f1_score(y_teste,prev_rf):.2f}')\n",
    "print(f'AUC:       {metrics.roc_auc_score(y_teste,prev_rf):.2f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax= plt.subplot()\n",
    "array = confusion_matrix(y_teste, prev_rf)      \n",
    "df_cm = pd.DataFrame(array, range(2),\n",
    "                  range(2))\n",
    "#plt.figure(figsize = (10,7))\n",
    "sn.set(font_scale=1.4)#for label size\n",
    "sn.heatmap(df_cm, annot=True,annot_kws={\"size\": 14}, ax = ax,fmt=\"d\")# font size\n",
    "\n",
    "ax.set_xlabel('Predicted labels');ax.set_ylabel('True labels'); \n",
    "ax.set_title('Confusion Matrix for Random Forest'); "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# AdaBoost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "ada = AdaBoostClassifier(n_estimators=50, learning_rate=1, random_state=1986)\n",
    "\n",
    "grid = GridSearchCV(ada,parametros_rf,cv=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_treino, x_teste, y_treino, y_teste = train_test_split(x, saida, test_size=0.3)\n",
    "x_treino = x_treino.dropna()\n",
    "y_treino = y_treino.dropna()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GridSearchCV(cv=10,\n",
       "             estimator=AdaBoostClassifier(learning_rate=1, random_state=1986),\n",
       "             param_grid={'n_estimators': [10, 20, 50, 100, 200, 400]})"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid.fit(x_treino,y_treino)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'n_estimators': 400}"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid.best_params_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6607692307692309"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid.best_score_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# AdaBoost - Prediction Rolling Windows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "ada = AdaBoostClassifier(n_estimators=400, learning_rate=1, random_state=1986)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "W = 10000\n",
    "L = 1000\n",
    "idxW = 0\n",
    "idxL = idxW + W + 1\n",
    "\n",
    "x_treino = x.iloc[idxW:W,:]\n",
    "y_treino = saida.iloc[idxW:W]\n",
    "x_teste =   x.iloc[idxL:(idxL+L),:]\n",
    "y_teste =  saida.iloc[idxL:(idxL+L)]  \n",
    "ada.fit(x_treino,y_treino)\n",
    "prev_ada = ada.predict(x_teste)\n",
    "\n",
    "idxW = idxW + L\n",
    "W = idxW + 10000\n",
    "idxL = idxW + 10000 + 1\n",
    "\n",
    "for cont in range(28):\n",
    "  x_treino = x.iloc[idxW:W,:]\n",
    "  y_treino = saida.iloc[idxW:W]\n",
    "  x_teste =   x.iloc[idxL:(idxL+L),:]\n",
    "  y_teste_1 =  saida.iloc[idxL:(idxL+L)]  \n",
    "  ada.fit(x_treino,y_treino)\n",
    "  prev_ada_1 = ada.predict(x_teste)\n",
    "  y_teste = pd.concat([y_teste,y_teste_1])  \n",
    "  prev_ada = pd.concat([pd.DataFrame(prev_ada),pd.DataFrame(prev_ada_1)])\n",
    "  idxW = idxW + L\n",
    "  W = idxW + 10000\n",
    "  idxL = idxW + 10000 + 1 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# AdaBoost - Performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.66\n",
      "Precision: 0.65\n",
      "Recall:    0.62\n",
      "F-1 Score: 0.64\n",
      "AUC:       0.66\n"
     ]
    }
   ],
   "source": [
    "print(f'Accuracy:  {metrics.accuracy_score(y_teste,prev_ada):.2f}')\n",
    "print(f'Precision: {metrics.precision_score(y_teste,prev_ada):.2f}')\n",
    "print(f'Recall:    {metrics.recall_score(y_teste,prev_ada):.2f}')\n",
    "print(f'F-1 Score: {metrics.f1_score(y_teste,prev_ada):.2f}')\n",
    "print(f'AUC:       {metrics.roc_auc_score(y_teste,prev_ada):.2f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax= plt.subplot()\n",
    "array = confusion_matrix(y_teste, prev_ada)      \n",
    "df_cm = pd.DataFrame(array, range(2),\n",
    "                  range(2))\n",
    "#plt.figure(figsize = (10,7))\n",
    "sn.set(font_scale=1.4)#for label size\n",
    "sn.heatmap(df_cm, annot=True,annot_kws={\"size\": 14}, ax = ax,fmt=\"d\")# font size\n",
    "\n",
    "ax.set_xlabel('Predicted labels');ax.set_ylabel('True labels'); \n",
    "ax.set_title('Confusion Matrix for AdaBoost'); "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Naive Bayes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "gnb = GaussianNB()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Naive Bayes - Prediction Rolling Windows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "W = 10000\n",
    "L = 1000\n",
    "idxW = 0\n",
    "idxL = idxW + W + 1\n",
    "\n",
    "x_treino = x.iloc[idxW:W,:]\n",
    "y_treino = saida.iloc[idxW:W]\n",
    "x_teste =   x.iloc[idxL:(idxL+L),:]\n",
    "y_teste =  saida.iloc[idxL:(idxL+L)]  \n",
    "gnb.fit(x_treino,y_treino)\n",
    "prev_gnb = gnb.predict(x_teste)\n",
    "\n",
    "idxW = idxW + L\n",
    "W = idxW + 10000\n",
    "idxL = idxW + 10000 + 1\n",
    "\n",
    "for cont in range(28):\n",
    "  x_treino = x.iloc[idxW:W,:]\n",
    "  y_treino = saida.iloc[idxW:W]\n",
    "  x_teste =   x.iloc[idxL:(idxL+L),:]\n",
    "  y_teste_1 =  saida.iloc[idxL:(idxL+L)]  \n",
    "  gnb.fit(x_treino,y_treino)\n",
    "  prev_gnb_1 = gnb.predict(x_teste)\n",
    "  y_teste = pd.concat([y_teste,y_teste_1])  \n",
    "  prev_gnb = pd.concat([pd.DataFrame(prev_gnb),pd.DataFrame(prev_gnb_1)])\n",
    "  idxW = idxW + L\n",
    "  W = idxW + 10000\n",
    "  idxL = idxW + 10000 + 1 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Naive Bayes - Performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.56\n",
      "Precision: 0.65\n",
      "Recall:    0.17\n",
      "F-1 Score: 0.27\n",
      "AUC:       0.54\n"
     ]
    }
   ],
   "source": [
    "print(f'Accuracy:  {metrics.accuracy_score(y_teste,prev_gnb):.2f}')\n",
    "print(f'Precision: {metrics.precision_score(y_teste,prev_gnb):.2f}')\n",
    "print(f'Recall:    {metrics.recall_score(y_teste,prev_gnb):.2f}')\n",
    "print(f'F-1 Score: {metrics.f1_score(y_teste,prev_gnb):.2f}')\n",
    "print(f'AUC:       {metrics.roc_auc_score(y_teste,prev_gnb):.2f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax= plt.subplot()\n",
    "array = confusion_matrix(y_teste, prev_gnb)      \n",
    "df_cm = pd.DataFrame(array, range(2),\n",
    "                  range(2))\n",
    "#plt.figure(figsize = (10,7))\n",
    "sn.set(font_scale=1.4)#for label size\n",
    "sn.heatmap(df_cm, annot=True,annot_kws={\"size\": 14}, ax = ax,fmt=\"d\")# font size\n",
    "\n",
    "ax.set_xlabel('Predicted labels');ax.set_ylabel('True labels'); \n",
    "ax.set_title('Confusion Matrix for Naive Bayes'); "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Persistência\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [],
   "source": [
    " import joblib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['ada_model']"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "joblib.dump(knn,'knn_model')\n",
    "joblib.dump(gnb,'gnb_model')\n",
    "joblib.dump(rbf_svc,'svm_model')\n",
    "joblib.dump(rf,'rf_model')\n",
    "joblib.dump(ada,'ada_model')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = joblib.load('knn_model')\n",
    "resultados = model.predict(x_teste)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 0 0 ... 0 1 1]\n"
     ]
    }
   ],
   "source": [
    "print(resultados)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conclusions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"justify\">We reproduce the experiments carried out by Fernandes et al. [1] Using five Machine Learning models to Classify a News Article as Popular or Unpopular. We found that the best model is the Random Forest with an accuracy of 67%, precisely as in the article. However, the AUC metric was 0.67 instead of the 0.73  found in the article.<br>\n",
    "\n",
    "We also noticed the difference in the performance of the KNN and SVM models. A possible explanation is that the partitions performed were not the same, and some possible optimization of the code we stopped doing. However, the main result was marked; we hope that this code will be useful for those who wish to study the Data Set and go deeper into the models. </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# References"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div>[1] K. Fernandes, P. Vinagre and P. Cortez. A Proactive Intelligent Decision Support System for Predicting the Popularity of Online News. Proceedings of the 17th EPIA 2015 - Portuguese Conference on Artificial Intelligence, September, Coimbra, Portugal.</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.4rc1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}