modeling_notebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import itertools\n",
    "\n",
    "import gzip\n",
    "import pickle\n",
    "\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "from sklearn.naive_bayes import BernoulliNB\n",
    "from sklearn.naive_bayes import MultinomialNB\n",
    "\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.metrics import precision_score\n",
    "from sklearn.metrics import f1_score\n",
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import seaborn as sns\n",
    "sns.set_style('ticks')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/eric/opt/anaconda3/lib/python3.7/site-packages/IPython/core/interactiveshell.py:3063: DtypeWarning: Columns (15) have mixed types.Specify dtype option on import or set low_memory=False.\n",
      "  interactivity=interactivity, compiler=compiler, result=result)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(575949, 32)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_csv('5k_Datasets/5k_tweets_lda_10.csv', index_col=0)\n",
    "df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(575949, 3725)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "with gzip.open('Datasets/features_df.pkl', 'rb') as handle:\n",
    "    features_df = pickle.load(handle)  \n",
    "features_df.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train Test Split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((431961, 3725), (143988, 3725))"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Fucntion to split into train and test data\n",
    "def tt_split(X, y):\n",
    "    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, stratify=y, random_state=1)\n",
    "    return X_train, X_test, y_train, y_test\n",
    "\n",
    "# Split into train and test data\n",
    "X_train, X_test, y_train, y_test = tt_split(features_df, df['sentiment'])\n",
    "\n",
    "X_train.shape, X_test.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MinMax Scaler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# MinMax Scaler\n",
    "mm_scaler = MinMaxScaler()\n",
    "X_train_mm_scl = mm_scaler.fit_transform(X_train)\n",
    "X_test_mm_scl = mm_scaler.transform(X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Standard Scaler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Standard Scaler\n",
    "std_scaler = StandardScaler()\n",
    "X_train_std_scl = std_scaler.fit_transform(X_train)\n",
    "X_test_std_scl = std_scaler.transform(X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Bernoulli Naive Bayes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to fit bernoulli naive bayes model\n",
    "def bnb(X_train, y_train):\n",
    "    bnb = BernoulliNB()\n",
    "    bnb_fit = bnb.fit(X_train, y_train)\n",
    "    return bnb_fit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.6962663555296275, 0.6938904652543706)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Fit bernoulli naive bayes model on train data, predict on minmax scaler test data\n",
    "bnb_fit_mm_scl = bnb(X_train_mm_scl, y_train)\n",
    "bnb_preds_mm_scl = bnb_fit_mm_scl.predict(X_test_mm_scl)\n",
    "\n",
    "accuracy_score(bnb_preds_mm_scl, y_test), f1_score(bnb_preds_mm_scl, y_test, average='weighted')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.7007250604217018, 0.698552621939297)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Fit bernoulli naive bayes model on train data, predict on standard scaler test data\n",
    "bnb_fit_std_scl = bnb(X_train_std_scl, y_train)\n",
    "bnb_preds_std_scl = bnb_fit_std_scl.predict(X_test_std_scl)\n",
    "\n",
    "accuracy_score(bnb_preds_std_scl, y_test), f1_score(bnb_preds_std_scl, y_test, average='weighted')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 9643., 16881.,  9610., ...,   603.,   122.,   201.],\n",
       "       [ 4336.,  6795.,  4322., ...,   157.,    22.,    52.],\n",
       "       [11446., 17503., 10834., ...,   475.,    99.,   185.]])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Feature count\n",
    "bnb_fit_std_scl.feature_count_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['#wholesale', 'okhand', '#sale', 'smilingfacewith3',\n",
      "       'smilingfacewithheart', 'faceblowingakiss', '#love', '#safe',\n",
      "       'twohearts', 'blueheart'],\n",
      "      dtype='object')\n",
      "Index(['incompetence', 'smilingfacewithheart', 'smilingfacewith3', 'heartsuit',\n",
      "       'purpleheart', 'threatened', 'upset', 'discarded', 'noble', 'okhand'],\n",
      "      dtype='object')\n",
      "Index(['iniran', 'assault', 'suicide', 'thief', 'germany's', 'incompetence',\n",
      "       'violent', 'gross', '#fight', 'declares'],\n",
      "      dtype='object')\n"
     ]
    }
   ],
   "source": [
    "# Top 10 most important features per class\n",
    "pos_class_prob_sorted = bnb_fit_std_scl.feature_log_prob_[0, :].argsort()\n",
    "neu_class_prob_sorted = bnb_fit_std_scl.feature_log_prob_[1, :].argsort()\n",
    "neg_class_prob_sorted = bnb_fit_std_scl.feature_log_prob_[2, :].argsort()\n",
    "\n",
    "print(np.take(features_df.columns, pos_class_prob_sorted[:10]))\n",
    "print(np.take(features_df.columns, neu_class_prob_sorted[:10]))\n",
    "print(np.take(features_df.columns, neg_class_prob_sorted[:10]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multinomial Naive Bayes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to fit multinomial naive bayes model\n",
    "def mnb(X_train, y_train):\n",
    "    mnb = MultinomialNB()\n",
    "    mnb_fit = mnb.fit(X_train, y_train)\n",
    "    return mnb_fit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.648366530544212, 0.6560903029607621)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Fit multinomial naive bayes model on train data, predict on minmax scaler test data\n",
    "mnb_fit_mm_scl = mnb(X_train_mm_scl, y_train)\n",
    "mnb_preds_mm_scl = mnb_fit_mm_scl.predict(X_test_mm_scl)\n",
    "\n",
    "accuracy_score(mnb_preds_mm_scl, y_test), f1_score(mnb_preds_mm_scl, y_test, average='weighted')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Decision Tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to fit decision tree model\n",
    "def dt(X_train, y_train):\n",
    "    dt = DecisionTreeClassifier()\n",
    "    dt_fit = dt.fit(X_train, y_train)\n",
    "    return dt_fit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.723782537433675, 0.7237418687722337)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Fit decision tree model on train data, predict on minmax scaler test data\n",
    "dt_fit_mm_scl = dt(X_train_mm_scl, y_train)\n",
    "dt_preds_mm_scl = dt_fit_mm_scl.predict(X_test_mm_scl)\n",
    "\n",
    "accuracy_score(dt_preds_mm_scl, y_test), f1_score(dt_preds_mm_scl, y_test, average='weighted')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.7228171792093786, 0.7227790464378497)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Fit decision tree on train data, predict on standard scaler test data\n",
    "dt_fit_std_scl = dt(X_train_std_scl, y_train)\n",
    "dt_preds_std_scl = dt_fit_std_scl.predict(X_test_std_scl)\n",
    "\n",
    "accuracy_score(dt_preds_std_scl, y_test), f1_score(dt_preds_std_scl, y_test, average='weighted')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.37984427e-02, 7.07843347e-03, 6.19432068e-03, ...,\n",
       "       1.73897035e-04, 3.40212838e-05, 9.40662773e-05])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Feature importances\n",
    "dt_fit_std_scl.feature_importances_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('subjectivity_score', 0.06111831308232892),\n",
       " ('nlikes', 0.01402649295835318),\n",
       " ('protect', 0.013184184251441364),\n",
       " ('help', 0.012865803628373692),\n",
       " ('infected', 0.011508287105684818),\n",
       " ('safe', 0.009374088894935299),\n",
       " ('please', 0.00832027302188848),\n",
       " ('death', 0.008313647504325852),\n",
       " ('hand', 0.007588242417386953),\n",
       " ('nreplies', 0.007010932702317728)]"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "features_dict = dict(zip(features_df.columns, dt_fit_mm_scl.feature_importances_))\n",
    "features_dict = sorted(features_dict.items(), key=lambda x: x[1], reverse=True)[:10]\n",
    "features_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Feature: 0, Score: 0.00000\n",
      "Feature: 1, Score: 0.00000\n",
      "Feature: 2, Score: 0.00000\n",
      "Feature: 3, Score: 0.00000\n",
      "Feature: 4, Score: 0.00000\n",
      "Feature: 5, Score: 0.00000\n",
      "Feature: 6, Score: 0.00000\n",
      "Feature: 7, Score: 0.00000\n",
      "Feature: 8, Score: 0.00000\n",
      "Feature: 9, Score: 0.00000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Top 10 most important features\n",
    "dt_importance = sorted(dt_fit_mm_scl.feature_importances_, reverse=True)[-10:]\n",
    "\n",
    "for i,v in enumerate(dt_importance):\n",
    "    print('Feature: %0d, Score: %.5f' % (i,v))\n",
    "\n",
    "plt.bar([x for x in range(len(dt_importance))], dt_importance)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'subjectivity_score': 0.06111831308232892,\n",
       " 'nlikes': 0.01402649295835318,\n",
       " 'protect': 0.013184184251441364,\n",
       " 'help': 0.012865803628373692,\n",
       " 'infected': 0.011508287105684818,\n",
       " 'safe': 0.009374088894935299,\n",
       " 'please': 0.00832027302188848,\n",
       " 'death': 0.008313647504325852,\n",
       " 'hand': 0.007588242417386953,\n",
       " 'nreplies': 0.007010932702317728}"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dt_features = dict(zip(features_df.columns, dt_fit_mm_scl.feature_importances_))\n",
    "dt_features = dict(sorted(dt_features.items(), key=lambda x: x[1], reverse=True)[:10])\n",
    "dt_features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['subjectivity_score', 'nlikes', 'protect', 'help', 'infected', 'safe', 'please', 'death', 'hand', 'nreplies'])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dt_features.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<BarContainer object of 10 artists>"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXsAAAD5CAYAAADGMZVsAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nO3de1wU9f4/8BdyWy6GklcSCzpnpfIgKLCgiEqKlw3dvHIKFLWvhphoJ7PTxfKWt9K8BcjpopAnSTIIRSWtNAiPZHkss2/KEiCoISLX3QX28/vDH/N1RVhFSG1ez8fDx8OZee/M5zMz+9rZmdnBQgghQEREf2od7nQDiIio/THsiYhkgGFPRCQDDHsiIhmwutMNuJ7RaMSFCxfg4OAACwuLO90cIqJ7ghAC1dXV6N69Ozp0aHocf9eF/YULFzB06NA73QwionvSV199hZ49ezYZf9eFvYODA4CrDXZ0dLzDrSEiujdUVVVh6NChUoZe764L+8ZTN46OjujYseMdbg0R0b2ludPfvEBLRCQDDHsiIhlg2BMRyQDDnohIBhj2REQywLAnIpIBhj0RkQww7ImIZOCmflR14sQJvP7668jPz4eHhwdWrVqFhx56yKTGaDRi5cqVSEtLg4WFBSIjI/Hss89K07dv34733nsPVVVV8PX1xcqVK9G5c+c27Uyjiau+x5Wa+naZt5O9FXa95N0u8yYiai9mj+z1ej2io6MRGRmJY8eOITAwEDExMU3qEhMTcfz4cWRkZCA5ORnJycnIzMwEAOzfvx8ffvghtm3bhuzsbNjb22Pt2rVt35v/70pNPa5Ut9O/dvoQISJqT2bDPicnB46OjtBoNLC2tkZUVBSKi4tx+vRpk7r09HTMmDEDzs7O6N27N8LDw5GamgoA2LlzJ+bMmYOHHnoItra2eP311/E///M/7dMjIiJqwmzYa7VauLu7S8OWlpZwdXVFXl6eSV1eXp5JnZubm1Rz6tQp6HQ6aDQaDBw4EG+++Sa6du3aVn0gIiIzzIZ9TU0N7OzsTMbZ2dlBp9OZjKutrYVCoZCGFQqFVFNRUYFdu3Zh8+bN2L9/P65cuYIVK1a0RfuJiOgmmA375oLd3t7eZJxCoYBer5eGdTqdVGNjY4Pw8HD06tULHTt2RFRUFA4dOtQW7ScioptgNuzd3d2Rn58vDTc0NKCgoABubm5N6rRarTSs1WqlmoceeghVVVUm8yAioj+O2bBXqVQoLy9HSkoKDAYDYmNj4eLiAqVSaVKnVquRkJCA0tJSFBYWIikpCaGhoQAAjUaDf//73ygqKkJVVRW2bNmCUaNGtU+PiIioCbNhr1AoEB8fjx07dkClUiErKwsbN26EhYUF1Go10tLSAAARERFQqVTQaDSYPHkypkyZgpCQEADA1KlTMWHCBEydOhVDhgyBs7MzFi5c2L49IyIiiYUQQtzpRlyrsrISPj4+yM3NbfVfqhqx+BiuVLfTj6ocrJC51Ldd5k1E1FrmspOPSyAikgGGPRGRDDDsiYhkgGFPRCQDDHsiIhlg2BMRyQDDnohIBhj2REQywLAnIpIBhj0RkQww7ImIZIBhT0QkAwx7IiIZYNgTEckAw56ISAYY9kREMsCwJyKSAYY9EZEMMOyJiGSAYU9EJAMMeyIiGWDYExHJAMOeiEgGGPZERDJwU2F/4sQJaDQaeHl5ISwsDPn5+U1qjEYjVqxYAZVKBX9/f8TFxUnThBDo378/vL29pX9Lly5ts04QEVHLrMwV6PV6REdH44UXXoBarUZ8fDxiYmKQmppqUpeYmIjjx48jIyMDVVVViIyMxMMPP4wRI0agoKAACoUC2dnZ7dYRIiJqntkj+5ycHDg6OkKj0cDa2hpRUVEoLi7G6dOnTerS09MxY8YMODs7o3fv3ggPD5c+EH7++Wd4eHi0Tw+IiMgss2Gv1Wrh7u4uDVtaWsLV1RV5eXkmdXl5eSZ1bm5uUs3PP/+MS5cuITQ0FIMGDcI///lPVFVVtVUfiIjIDLNhX1NTAzs7O5NxdnZ20Ol0JuNqa2uhUCikYYVCIdXY2Nigf//+2LZtGz7//HNcunSJ5+yJiP5AZs/ZNxfs9vb2JuMUCgX0er00rNPppJro6GiT2nnz5mHatGmtbjQREd0as0f27u7uJnffNDQ0oKCgAG5ubk3qtFqtNKzVaqWahIQEk3P8BoMBNjY2t9t2IiK6SWbDXqVSoby8HCkpKTAYDIiNjYWLiwuUSqVJnVqtRkJCAkpLS1FYWIikpCSEhoYCuBr8q1evRkVFBcrKyrB+/XqMGzeufXpERERNmA17hUKB+Ph47NixAyqVCllZWdi4cSMsLCygVquRlpYGAIiIiIBKpYJGo8HkyZMxZcoUhISEAABefvlldO3aFSNGjMCoUaPw8MMP4/nnn2/fnhERkcRCCCHudCOuVVlZCR8fH+Tm5qJjx46tmseIxcdwpbq+jVt2lZODFTKX+rbLvImIWstcdvJxCUREMsCwJyKSAYY9EZEMMOyJiGSAYU9EJAMMeyIiGWDYExHJAMOeiEgGGPZERDLAsCcikgGGPRGRDDDsiYhkgGFPRCQDDHsiIhlg2BMRyQDDnohIBhj2REQywLAnIpIBhj0RkQww7ImIZIBhT0QkAwx7IiIZYNgTEckAw56ISAZuKuxPnDgBjUYDLy8vhIWFIT8/v0mN0WjEihUroFKp4O/vj7i4uBvOa+HChXjhhRduq9FERHRrzIa9Xq9HdHQ0IiMjcezYMQQGBiImJqZJXWJiIo4fP46MjAwkJycjOTkZmZmZJjVffPEF0tPT2671RER0U8yGfU5ODhwdHaHRaGBtbY2oqCgUFxfj9OnTJnXp6emYMWMGnJ2d0bt3b4SHhyM1NVWaXlZWhrVr12L8+PFt3wsiImqR2bDXarVwd3eXhi0tLeHq6oq8vDyTury8PJM6Nzc3k5olS5bgmWeeQY8ePdqi3UREdAvMhn1NTQ3s7OxMxtnZ2UGn05mMq62thUKhkIYVCoVUs3fvXlRXV2PSpElt0WYiIrpFVuYKmgt2e3t7k3EKhQJ6vV4a1ul0sLe3R2lpKdatW4fExMQ2ajIREd0qs2Hv7u6OXbt2ScMNDQ0oKCiAm5tbkzqtVgsPDw8AV0//uLm5ISsrC6WlpQgNDQVw9YKvEAK//PILPv/887bsCxERNcPsaRyVSoXy8nKkpKTAYDAgNjYWLi4uUCqVJnVqtRoJCQkoLS1FYWEhkpKSEBoainHjxuGHH35Abm4ucnNzMWvWLIwaNYpBT0T0BzIb9gqFAvHx8dixYwdUKhWysrKwceNGWFhYQK1WIy0tDQAQEREBlUoFjUaDyZMnY8qUKQgJCWn3DhARkXkWQghxpxtxrcrKSvj4+CA3NxcdO3Zs1TxGLD6GK9X1bdyyq5wcrJC51Ldd5k1E1FrmspOPSyAikgGGPRGRDDDsiYhkgGFPRCQDDHsiIhlg2BMRyQDDnohIBhj2REQywLAnIpIBhj0RkQww7ImIZIBhT0QkAwx7IiIZYNgTEckAw56ISAYY9kREMsCwJyKSAYY9EZEMMOyJiGSAYU9EJAMMeyIiGWDYExHJAMOeiEgGbirsT5w4AY1GAy8vL4SFhSE/P79JjdFoxIoVK6BSqeDv74+4uDhpWnl5OebNmwc/Pz8EBARgxYoVqKura7NOEBFRy8yGvV6vR3R0NCIjI3Hs2DEEBgYiJiamSV1iYiKOHz+OjIwMJCcnIzk5GZmZmQCA5cuXw8HBAUeOHMHevXtx9OhRpKSktH1viIjohsyGfU5ODhwdHaHRaGBtbY2oqCgUFxfj9OnTJnXp6emYMWMGnJ2d0bt3b4SHhyM1NRUAsHLlSixZsgS2traoqqqCwWCAk5NT+/SIiIiaMBv2Wq0W7u7u0rClpSVcXV2Rl5dnUpeXl2dS5+bmJtVYW1vDxsYG0dHRGD58OHr27Inhw4e3VR+IiMgMs2FfU1MDOzs7k3F2dnbQ6XQm42pra6FQKKRhhULRpGbdunU4cuQIKioqsG7duttpNxER3QKzYd9csNvb25uMUygU0Ov10rBOp2tSY2tri27dumHWrFn46quvbqPZRER0K8yGvbu7u8ndNw0NDSgoKICbm1uTOq1WKw1rtVqpZvr06cjOzpamGQwG3HfffbfbdiIiuklmw16lUqG8vBwpKSkwGAyIjY2Fi4sLlEqlSZ1arUZCQgJKS0tRWFiIpKQkhIaGAgAeeeQRxMbGorKyEiUlJdi6dSs0Gk379IiIiJowG/YKhQLx8fHYsWMHVCoVsrKysHHjRlhYWECtViMtLQ0AEBERAZVKBY1Gg8mTJ2PKlCkICQkBAMybNw9ubm4YMWIEnnrqKYSGhiIsLKx9e0ZERBILIYS40424VmVlJXx8fJCbm4uOHTu2ah4jFh/Dler6Nm7ZVU4OVshc6tsu8yYiai1z2cnHJRARyQDDnohIBhj2REQywLAnIpIBhj0RkQww7ImIZIBhT0QkAwx7IiIZYNgTEckAw56ISAYY9kREMsCwJyKSAYY9EZEMMOyJiGSAYU9EJAMMeyIiGWDYExHJAMOeiEgGGPZERDLAsCcikgGGPRGRDDDsiYhkgGFPRCQDDHsiIhm4qbA/ceIENBoNvLy8EBYWhvz8/CY1RqMRK1asgEqlgr+/P+Li4qRpOp0OixcvxqBBg6BSqfDiiy+ioqKizTpBREQtMxv2er0e0dHRiIyMxLFjxxAYGIiYmJgmdYmJiTh+/DgyMjKQnJyM5ORkZGZmAgA2bdqEc+fOYe/evTh48CAqKyuxatWqtu8NERHdkNmwz8nJgaOjIzQaDaytrREVFYXi4mKcPn3apC49PR0zZsyAs7MzevfujfDwcKSmpgK4+oERFRUFJycnODo6YtKkSfj+++/bp0dERNSE2bDXarVwd3eXhi0tLeHq6oq8vDyTury8PJM6Nzc3qebVV1+Fj4+PNO3QoUNQKpW33XgiIro5VuYKampqYGdnZzLOzs4OOp3OZFxtbS0UCoU0rFAomtQAwLZt23DgwAHs3LmztW0mIqJbZDbsmwt2e3t7k3EKhQJ6vV4a1ul0JjVCCKxduxapqan44IMP4ObmdrttJyKim2T2NI67u7vJ3TcNDQ0oKChoEtbu7u7QarXSsFarlWrq6+vx/PPP4+uvv8bOnTvx2GOPtVHziYjoZpgNe5VKhfLycqSkpMBgMCA2NhYuLi5Nzrmr1WokJCSgtLQUhYWFSEpKQmhoKADg7bffxpkzZ/Dvf/8bvXr1ap+eEBFRs8yexlEoFIiPj8frr7+O5cuXw8PDAxs3boSFhQXUajVmz56NsWPHIiIiAhcvXoRGo0FDQwMiIyMREhICg8GAxMREAMCQIUOk+Xbr1g379+9vv54REZHEQggh7nQjrlVZWQkfHx/k5uaiY8eOrZrHiMXHcKW6vo1bdpWTgxUyl/q2y7yJiFrLXHbycQlERDLAsCcikgGGPRGRDDDsiYhkgGFPRCQDDHsiIhlg2BMRyQDDnohIBhj2REQywLAnIpIBhj0RkQww7ImIZIBhT0QkAwx7IiIZMPs8e7o1E1d9jys17fN4ZQBwsrfCrpe8223+RPTnxLBvY1dq6tvtWfpERK3F0zhERDLAI/s/EZ5CIqLmMOz/RO7kKSR+0BDd3Rj21CZ4rYLo7sZz9kREMsCwJyKSAYY9EZEM8Jw93fN4cZjIvJs6sj9x4gQ0Gg28vLwQFhaG/Pz8JjVGoxErVqyASqWCv78/4uLimtTo9XpMnDgR2dnZt91wokaNF4fb7V87fpAQ/VHMhr1er0d0dDQiIyNx7NgxBAYGIiYmpkldYmIijh8/joyMDCQnJyM5ORmZmZnS9PPnz2PmzJk4efJk2/aAiIjMMhv2OTk5cHR0hEajgbW1NaKiolBcXIzTp0+b1KWnp2PGjBlwdnZG7969ER4ejtTUVABAeXk5xo8fj2HDhsHFxaV9ekJERM0yG/ZarRbu7u7SsKWlJVxdXZGXl2dSl5eXZ1Ln5uYm1djb22Pv3r2YOXMmLCws2qrtRER0k8xeoK2pqYGdnZ3JODs7O+h0OpNxtbW1UCgU0rBCoZBqbGxsYGNj0xbtJSKiVjB7ZN9csNvb25uMUygU0Ov10rBOp2tSQ0REd4bZI3t3d3fs2rVLGm5oaEBBQQHc3Nya1Gm1Wnh4eAC4evrn+hqiPxve9kn3CrNhr1KpUF5ejpSUFISGhmLr1q1wcXGBUqk0qVOr1UhISICvry9qa2uRlJSEl156qd0aTnQ34DOB6F5h9jSOQqFAfHw8duzYAZVKhaysLGzcuBEWFhZQq9VIS0sDAEREREClUkGj0WDy5MmYMmUKQkJC2r0DRERk3k39grZv375ISUlpMn7Pnj3/NyMrKyxatAiLFi1qcV6HDh26xSYSEdHt4uMSiO5Rd/J6Aa9V3HsY9kT3qDt5vYDXKu49DHsiuqfwW0XrMOyJ6J7CbxWtw7AnIrpJ9/K3CoY9EdFNupe/VfAvVRERyQDDnohIBhj2REQywLAnIpIBhj0RkQww7ImIZIBhT0QkAwx7IiIZYNgTEckAw56ISAYY9kREMsCwJyKSAYY9EZEMMOyJiGSAYU9EJAMMeyIiGWDYExHJAMOeiEgGbirsT5w4AY1GAy8vL4SFhSE/P79JjdFoxIoVK6BSqeDv74+4uLibmkZERO3PbNjr9XpER0cjMjISx44dQ2BgIGJiYprUJSYm4vjx48jIyEBycjKSk5ORmZlpdhoREbU/s2Gfk5MDR0dHaDQaWFtbIyoqCsXFxTh9+rRJXXp6OmbMmAFnZ2f07t0b4eHhSE1NNTuNiIjan5W5Aq1WC3d3d2nY0tISrq6uyMvLg4eHhzQ+Ly/PpM7NzQ27du0yO+16QggAQFVV1S125f84WhlgtG6fvwDvaGVEZWXlHVm2ueVz2Vw2l/3nXbY5jZnZmKHXMxv2NTU1sLOzMxlnZ2cHnU5nMq62thYKhUIaVigUUk1L065XXV0NABg6dKi5pt0xPh/Jd/lcNpfNZd/dy66ursZ9993XZLzZsG8u2O3t7U3GKRQK6PV6aVin00k1LU27Xvfu3fHVV1/BwcEBFhYW5ppHRES4ekRfXV2N7t2733C62bB3d3c3OeXS0NCAgoICuLm5NanTarXSqR2tVivVtDTteh06dEDPnj1vomtERHStGx3RNzJ7gValUqG8vBwpKSkwGAyIjY2Fi4sLlEqlSZ1arUZCQgJKS0tRWFiIpKQkhIaGmp1GRETtz0I0dzb/Gj/++CNef/116aLsypUr8dBDD0GtVmP27NkYO3Ys6uvr8fbbb+Pzzz9HQ0MDIiMjMXv2bABocRoREbW/mwp7Ijm4fPkybGxs4ODgcKebIhvFxcXo2bMnr8/9Af50j0soKipq9Wvr6upw4cKFNm1Lnz59UF9fj9zcXIwcORIA8Omnn+Lvf/97my2ntdqivzU1NSgrKwNg2t+bZe41xcXF8Pb2RkNDQ4vz2bx5M/r374+QkJCbb/x1Ro0ahdLS0lt+3QsvvIBNmzbd0mt+/PFHBAcHo3///vjmm29ueZmNjh49iqCgoFa//nb89ttv6NOnT6tfX1paijFjxkjbNiIiAp988kmLr2nNPnargoKCcPTo0XaZd3BwMLKzswEA3t7eKCwsbJfl3MgfHvYtbdBnnnkGu3fvbvW8Dx48iEWLFknDN7Myr13m888/j8OHD7d6+S3x8fHB/v3722XerdUW/Q0PD2/yA7u25OLigu+//x6WlpYt1n322WdYunQpDhw40OpllZeXt/q1t+rrr7+Gm5sbjh8/jsDAwD9suXcTnU6H2traO92MO+b777+Hq6vrH7a8u+rI/l//+heefPLJVr/+ypUrMBqN0vDNrMxrl9naN3tRUREGDRqEzZs3w9/fH4GBgU2e/9PcEVheXh4GDRqEtLQ0AEBhYSFmzpwJX19fhIaG4siRI1Lt+++/j6CgIPj7+2PmzJm3fVTQFuF2o3ls3boVQ4cOhUqlwtatWwG03K9GR48ehUajwUsvvQRvb2+MHTsWBw4cQJ8+fZCdnY0JEybgjTfegI+PD4KDg5GSkgIAGDt2LIqKivDyyy9j/fr1AIAPP/wQjz/+OAICAvDyyy9Lv98wGo145513MGjQIKhUKrz88sswGAwICwsDAIwbNw5Hjx5FXV0d1q1bhyFDhiAwMBBr1qxBXV0dgKtHpM888wy8vb0RERGBsrIyfPPNNxg4cCAGDRqE5557DpcvX0Z+fj6eeeYZBAYGwsvLC1FRUaiqqkJCQgJiY2ORk5OD4OBgAMBPP/2EsLAw+Pj4YNKkSfjxxx9N1k1RURFUKhXefvtt9O/fHyNGjMCXX37ZZB1+/vnnGDVqFPz8/DB37lxcunQJwNW76FavXo2QkBB4eXlh9OjRyMnJAQBUVFTg2Wefha+vL4KDg7F69WrphznXb7c333xT2gevvUsvKysL48aNg4+PDyIjI1FQUCBNS0hIwJgxY+Dt7Y3g4GDs3bsXAKR17uvrK+3LJ0+exPjx4+Ht7Y2ZM2c2u4/eaB/7+uuvMXHiRPj5+UGlUmHt2rVSfZ8+fbB9+3YEBQVBpVJh2bJl0rQffvgBY8eORb9+/dCvXz9UVlYiOjra5H3cp08fvPHGG/D19UVKSgqqq6vx2muvYdCgQRg2bBj+9a9/SfOLiIjA2rVrERwcDB8fHyxfvvyG30T69OmD3377rcXtL4TA6tWrm+xbrSJug9FoFKtWrRIBAQFi4MCBYu7cuaKsrEwMGzZMZGVlSXWLFi0S69atE0IIER4eLl577TUxZswY0b9/f7FixQphMBikacnJyUIIIUpLS8W8efOEn5+fGDFihNi9e7c0v6KiIjFjxgzh7e0tgoODRXp6ujh9+rTo27ev8PDwECEhIUIIIZRKpcjPzxfz5s0TmzZtkl6fn58vvLy8RE1NjbTMNWvWCA8PD9G3b1+xefNmMWzYMLF//37pNfv27ROTJ0++4XooLCwUSqVSLF++XGzdulX4+fkJpVIpJkyYIJRKpairqxOHDx8W/fr1E76+vsLb21sMHjxYFBcXi2HDhol//vOfIiQkRAwYMED069dPvPnmm8JgMIgPP/xQeHh4iMmTJ4sBAwaI/v37i+PHj4u///3vQqlUir59+wpPT08xfPhwcejQIVFYWCj8/f3F/PnzhY+Pj/jmm2/EmTNnxPTp08WAAQNESEiI+Oyzz4QQokl/hRAiLS1NjBw5Uvj6+oro6GhRWloq9XHbtm1i6NChYsCAAWLOnDmivLxcLFiwQPTp00f87W9/E59++qm0HhYvXiwMBoM4evSo6NOnjygpKRGjR48W7777rjAYDOI///mP8PPzE+fOnZNeU1dXJ3JycoRSqRQbNmwQer1eJCUlCZVKJZRKpcjKyhJKpVK89957oq6uTnz88cfC29tb6HQ6IYQw2efS0tLE8OHDRX5+vqiurhYLFiwQixcvFkIIkZiYKEaPHi0KCwtFZWWlCA8PF1u2bDHZX4QQIjY2VkyaNEn8/vvvoqysTISHh4v4+HghhBDPPvuseOGFF4ROpxPZ2dnCw8ND+Pn5iYqKCqHT6cSsWbPE5s2bRXh4uNi0aZNoaGgQpaWlYvTo0SIpKUkIIcTGjRvFP/7xDyGEEBUVFcLf31/s3r1b1NXViX379olBgwaJysrKJvvYSy+9JHQ6nTh48KDo16+fSEtLE4MHDxZCCJGbmyv8/PzEyZMnhV6vF6tWrRIzZ84UQgiRkpIiNBqNuHz5sqivrxdr1qwR48ePF0IIsX79evH888+Luro6cf78eTF06FCRk5Mj6urqTLbbzp07hVKpFF988YWoqqoSs2fPFkqlUhQUFAhvb29x5MgRab994oknRENDg8jJyRFBQUGiuLhYGI1GkZSUJPz9/U36VFdXJ73/hw0bJoqLi0VFRYUYN26cePfdd2/4XrvRPubt7S2ys7OFEEL8+OOP4rHHHhP/+7//K23befPmierqavHTTz8JT09P8d1334na2loxcOBA8dFHHwmtViuUSqVQKpXim2++EV9//bXw8PAQJSUlQqlUimXLlgm9Xi+qq6vFq6++KmbPni0qKyvFuXPnxJgxY8SePXtM+pGfny8uXrwonnjiCfHBBx802U8b97eWtn92drYICQlpsm+1xm0d2efk5ODQoUPYv38/Dh06BIPBgB07dph9XVZWFuLi4rBv3z58++23+Pjjj5vULFy4EE5OTjh8+DA2b96Mt99+GydOnAAAPPfcc3j44YeRk5OD9evX49VXX4WDgwOWLFkCLy+vJqdLQkNDsW/fPmk4PT0dw4cPN/ll8MKFC+Hj44PFixcjOjoaarXaZD579+7FmDFjWuzX6NGjsXXrVqSlpeH+++9Hly5dpGkpKSmor6/Hvn37MH/+fJSVlWHy5Ml49NFHcfDgQaxduxbvvvsuLCws8NVXX0EIAQ8PDxiNRvTq1QuffPIJ9Ho9oqKi0Lt3bwCAv78/bG1tMXv2bCxYsAAXL15EWVkZHnvsMRw5cgS+vr6YOXMm+vfvj+zsbKxduxZvvvkm/vOf/zTp73fffYfly5fjrbfewjfffANXV1fplNiXX36J+Ph4xMbGIjs7GwqFAmvWrMG6devg4uKCuLg4k29kMTExsLa2hp+fHzp37oyioiLp6NHa2hq+vr4YPHgw0tPTm6zDTp06Yc6cObCxscHTTz8Na2traZqNjQ2mT58OKysrjBs3DtXV1dKR67U+++wzTJ8+HQ8++CDs7e0RExODzz77DEIIZGRkYNq0aejVqxccHR2xdu3aG94GvHv3bkRHR6NLly7o3LkzoqKisHv3buj1ehw+fBjR0dGwtbVFQEAAvL29UV1djZSUFFy8eBGxsbGIjo7G6tWrMWvWLOh0Oly4cAGdOnXC77//3mRZX3/9NXr16gWNRgMrKyuMHDkSrq6uNzzFtmjRItja2iI4OBiPPfYYampqpGmpqamYOHEi+vbtCxsbG8yfPx/Z2dkoLS1FSEgIEhIS0LFjRxQXF8PBwUG6PuHg4IAff/wR+/btg62tLQ4ePAiVSoWTJ0+abOkaBuYAAA4VSURBVLfi4mI88MADOHv2LBwcHPDcc88BuPreCAoKQmBgIKytrTFt2jRcuXIFJ0+ehKenJ5KTk9GjRw9cuHABtra2KCsra/YazFNPPYWePXuiY8eOGDhwYLPX4K7fxwoKCpCamoqAgABcvnwZ1dXVsLe3N7kGExkZCXt7ezz66KNQKpUoKCiQThE+9dRTsLK6+rOjjh07wsrKCkFBQejcubP0rWPUqFGwsbGBnZ0dUlNTsXDhQjg6OsLFxQWRkZH49NNPpWVNnToVDz74ILp27Ypp06aZ5M+tbH8HBwdcvHixyb7VGmZ/VNWSaxvy+OOPIzY2Fh06dJC+Xjdn6tSp0umVadOm4bPPPkNERIQ0/eLFi8jJycGxY8dga2sLpVKJ8ePH49NPP4WzszNOnz6NHTt2wMbGBp6envjoo4/QuXPnZpcXFBSEV155BWfOnMFf/vIXZGRk4MUXX2yxjWq1Gk899RQMBgPq6+tx+PBhvPLKKy2+pnv37qitrZWuSVz7Vfvo0aNwdHSEs7MzHB0dUVdXB1dXV2RnZ2PixInw9PTE3r17odfr8dtvv0GlUknzdXJygpubG1544QW89dZbUkg++eSTcHJykgL+119/ldquUCiQnZ2Nuro6zJkzBx06dICnpycmTJiA1NRU+Pn5mbT92qAAgPnz58Pb2xulpaXIyMjAhAkTpB/FvfLKKy1+lbz2hx3W1tbSh5Cvr680vqGhAU5OTk1e27NnT+lNBwD3338/Ll68CADo3LmzdNdGY821p+0alZSUYO3atVi3bp00zmg04tKlSygtLTX5hWGPHj1u2Ifz589jwYIF6NDh6vGQEAIWFhYoLy9HfX29yTweeeQRODs7Y9++fVizZg3++te/YtmyZbh8+TJmzZqF8vJyPPLII6isrLzhc0tKSkrw888/w8fHRxpXX1+PkpISk7r77rsPnTp1koa7d+9uEmYlJSVITU3Fzp07pXFWVlYoLi5Gr1698Prrr+PYsWPo3bs3unXrJrVl+vTp0Ol02Lx5M1588UUEBQVhxYoVKCkpMdluOp0OQgjpor6Li4u03IMHD5q0v66uDsXFxejTpw/eeecdHDp0CD179pSekXWj9QDAZJ+wtrZu9kPh+n1MCIH9+/dj27ZtsLOzQ9++fSGEMFmOs7OzyXoxGo0oLS1Ft27dTOZ97T7RWAdAOngrKyuDXq/HlClTpLrGg7JG1/7/+u10vZa2/5gxY7B06VJ89NFHJvuWp6dns/Nrzm2Fvaen5w0bYk7jTgJcXRHXH+2cP38eRqMRQ4YMkcY1NDRApVKhtLQU9913n8mzdh599NEWl2djY4ORI0ciIyMDISEhKCsrw8CBA1t8jYeHB3r06IEjR45Ar9ejb9++TXaK63Xv3h2xsbF47733cOnSJbz11lvStCtXrpi8UT09PZGUlARfX1+cPXsWANC1a1e4urrCwcEBM2fORJcuXbBgwQLpm0BtbS2MRiNsbW1RV1eHBQsWwN7eHk5OTiY71LU7ZY8ePaTAAq6u+19++aVJ21sKikuXLqFfv37SeGdnZ5M3jjl5eXlwdXU1+aZUUlICBwcHVFRUmNSWlpZKwSqEuOGRsDldunRBVFSUdMRuMBhw7tw53H///ejevbv04QEA//3vf3Hq1Cnp/PG181i7di369+8P4OpDpi5fvoxOnTpJR7kPP/wwAKCgoAAuLi7YvHkzrly5gi1btmDRokU4f/483nnnHWk/njNnzg3b27VrV/j5+eH999+XxhUWFjZZx1VVVaitrZW+kRYXF5vsx439fvbZZ6VxZ8+exYMPPoglS5bAzs4OWVlZsLa2xhdffCGdFz5z5gwmTZqE5557DoWFhXj55ZcRGxsrHWE2brcNGzbg559/lh5x3rhtunTpAo1GY/Le12q1cHFxwQcffICioiJ8+eWXsLe3x88//4w9e/a0sPVa5/vvv8e2bduwa9cuPPDAAxBCNDmguZEuXbrg/PnzJh8KzQVz44FG4z6wZ88e6UP/8uXLMBgMUu21+21JSUmzjzAAWt7+JSUl+Otf/4qPP/5Y2rdeffVV6Rrfrbit0zjXNuTbb7+FSqXCq6++CgsLC5MLEtdfZLl+RVz/eIQuXbrA1tYWR48eRW5uLnJzc3HgwAG8+eab6N69OyoqKkye1/PRRx/h1KlTLba18WLf/v37MWbMGJOjx+ao1WocPHgQmZmZUKvVZuvLysrg5OSEDz/8EN26dTM5Ou/cubPJUWhNTQ0OHDgAPz8/fPvttzh79iz69esHo9GI/Px8ODk54dy5c7h8+TKysrJQVFSErVu3onv37vj8889hYWGBnj17Yu/evYiJiUFxcbG0QzXulD169JA+OBs1ht71GoOicX3n5uZi9+7dePTRR9GtWzeTgCwoKEB8fLzZ9dHIy8sLRqMRO3bsQH19Pc6ePYuJEyciKyurSe3vv/+O7du3o66uDomJiWbvwrmR0NBQvP/++yguLkZdXR3Wr18vnXJQq9XYvn07zp8/j6qqKqxfv166ddTa2lp6cmBoaCi2bNkifcguXrwYy5Ytg62tLUaMGIENGzagtrYWubm5yM7Oxp49e1BcXIyOHTvC3t4eXbp0gV6vh729PYQQOHToEI4cOXLDC3VDhgzBqVOn8MUXX8BoNOK7777D2LFjpYOARkajERs3bkRdXR0yMzPx66+/mvwmYOzYsdi5cyd+/fVXGI1GbNu2DU8//TTq6upQUVEBhUIBS0tLlJSUYOvWrVJbkpOTsWTJElRXV6NLly6wtrZGp06dpP2xcbv17dsXX375JbZv3y59EwCunr48cOAAvvvuOwghcODAAYwbNw6XL19GRUUFbG1tYWVlhbKyMmzYsAHA1SNXGxsbALf3hNtGjzzyCCwtLWFrawuDwYAtW7agoqJCuqjenAEDBsDKygrvv/++tD7MXQC1tLTE6NGjsW7dOlRXV+PKlSuYN2+eyU0ZiYmJuHDhAi5cuIAPP/ywxScGtLT9T5w4gTlz5pjsWzf6Rnwzbivsm2vIgw8+iIyMDKnh19+zun37dpSUlOD8+fP44IMPoNFoTKa7uLigb9++2LBhAwwGAy5cuIBp06bh008/hYuLCzw9PaVpJ0+exIYNG+Do6AgbGxvprovrDRgwQDqv2tyKt7GxMdnxnnjiCRw5cgTHjh2T7pFvyblz5zBz5kz88ssvsLCwMPn2ERAQgKqqKpSXl6OqqgpFRUXQ6/WYOnUqLC0t8Y9//ANCCAwePBh1dXWYP38+1qxZA3t7e4wePRqenp6YN28eLly4gJEjR0IIgT59+mDChAmIjY3Fr7/+2uQRFp6ennBwcMC7774Lg8GA//73v0hJSZGuPVzb35aCQq1WIyUlBWfOnJHeSI13W1wbkM2xtrZGXFwcMjMzERAQgOnTp2PatGkYPXp0k9r7778fp06dQkBAANLT07F8+XKz6/16EydOxOjRoxEeHg5/f3+cOnUKmzZtgoWFBSZOnIiRI0ciLCwMjz/+OB566CHMmjULADB+/Hg8/fTT+OKLLzBnzhwolUpoNBoEBQVBp9Nh5cqVAIA33ngDDQ0NGDhwIFauXIng4GAolUpMmjQJAwYMwHfffYdly5bhlVdeQUxMDFQqFT744ANMmDChSYADVw8E4uLikJCQAF9fXyxatAivvfbaDb+qNzQ0IDAwEBs2bMC7775rcvQfEBCAuXPnYu7cufDx8UF6ejri4+NhZ2eH5557DqdOncKAAQMwdepUhISEoKKiAmVlZZg/fz6sra0xbNgwBAUFoUuXLpg5cyZsbGxMttuSJUukfWHw4MHS860efvhhrF69GkuWLMGAAQOwadMmbNq0CT169EBkZCR0Oh1UKhXGjx+Pv/3tb+jUqRPOnj2Lrl27YvDgwRg2bFiTu49ulY2NDQYPHoyRI0di6NCh+O233xAQEIC8vDyzr4uLi8OePXswduxYAMBf/vIXs8tbvHgxOnTogJCQEISEhOCBBx4wOTX86KOPIiIiAmPHjkVISAgmT57c7Lxa2v6jRo1CaGhok32rVVp1Wfca69atEwMHDhReXl4iPDxcaLVacfLkSTF+/Hjh7e0tZsyYIRYvXmxyN86yZcvEsGHDxMCBA8WmTZuE0WiUpjXejXP+/Hkxd+5c4efnJwICAsTKlStFfX29EEKIc+fOiVmzZgkfHx8REhIiMjMzpdeMGDFCDBw4UBiNRpO7K4QQ4u233xbDhw83af+1y0xJSRFeXl5i1apV0vQnn3xSuqPhZmzfvl0MGTJE9OvXTzz55JPixIkTQgghamtrxdKlS8WgQYOkfjf65JNPREhIiLQOf/31VyGEEDk5OdKdFo3OnDkjwsLChFKpFF5eXsLT01Oo1WqRk5PT5O6GxvqpU6eK/v37i+DgYLFz505p2vX93bVrlwgJCRHe3t5i4sSJ4ocffpBqP/roIxEcHCx8fHzEggULpDtFtmzZIvr16ye2b99+0+uoOTfqL111o21Ld6drM+Vuclc9LiE8PBxPPvkkJkyYcKebIpk7dy6GDx/e5NvHnVRUVITHH38cP/30002djrpXHD16FAsXLmy3H7bdy/6s2/zPqPGIftKkSXe6KSbumh9VlZWVoaSk5JYu/LWnCxcu4PDhwzh+/Pht/QSfiOhucFccIlRWVuLxxx/HI488YnJR805KTU1FfHw8XnvtNekPrVRWVrb4HJINGzbcseeU/BmoVCoe1TejV69eN7yLiu4+iYmJd7oJN3RXncYhIqL2cdecxiEiovbDsCcikgGGPRGRDDDsiYhkgGFPRCQD/w9zPvX911DryQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.bar(dt_features.keys(), dt_features.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Confusion Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_confusion_matrix(cm, classes,\n",
    "                          normalize=False,\n",
    "                          title='Confusion matrix',\n",
    "                          cmap=plt.cm.Blues):\n",
    "    \"\"\"\n",
    "    This function prints and plots the confusion matrix.\n",
    "    Normalization can be applied by setting `normalize=True`.\n",
    "    \"\"\"\n",
    "    if normalize:\n",
    "        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
    "        print(\"Normalized confusion matrix\")\n",
    "    else:\n",
    "        print('Confusion Matrix, without normalization')\n",
    "    print(cm)\n",
    "    plt.imshow(cm, interpolation='nearest', cmap=cmap)\n",
    "    plt.title(title, color='white')\n",
    "    plt.colorbar()\n",
    "    tick_marks = np.arange(len(classes))\n",
    "    plt.xticks(tick_marks, classes, color='white', rotation=45)\n",
    "    plt.yticks(tick_marks, classes, color='white')\n",
    "    fmt = '.2f' if normalize else 'd'\n",
    "    thresh = cm.max() / 2.\n",
    "    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n",
    "        plt.text(j, i, format(cm[i, j], fmt), fontsize=15,\n",
    "                 horizontalalignment=\"center\", verticalalignment=\"center\",\n",
    "                 color=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "    plt.tight_layout()\n",
    "    plt.ylabel('True Label', color='white')\n",
    "    plt.xlabel('Predicted Label', color='white')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Normalized confusion matrix\n",
      "[[0.70889576 0.08239822 0.20870602]\n",
      " [0.14535307 0.72822131 0.12642562]\n",
      " [0.19625418 0.06832776 0.73541806]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cm_dt_mm_scl = confusion_matrix(y_test, dt_preds_mm_scl)\n",
    "classes = ['Negative', 'Neutral', 'Positive']\n",
    "plot_confusion_matrix(cm_dt_mm_scl, classes, normalize=True,\n",
    "                      title='Decision Tree Confusion Matrix', cmap=plt.cm.Blues)\n",
    "\n",
    "# plt.savefig('Images/dt_conf_matrix.png', dpi = 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "from io import StringIO\n",
    "from sklearn.tree import export_graphviz\n",
    "from IPython.display import Image  \n",
    "import pydotplus"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dot_data = StringIO()\n",
    "export_graphviz(dt_fit_mm_scl, out_file=dot_data,  \n",
    "                filled=True, rounded=True,\n",
    "                special_characters=True,\n",
    "                feature_names=feature_cols,\n",
    "                class_names=['negative','neutral', 'positive'])\n",
    "graph = pydotplus.graph_from_dot_data(dot_data.getvalue())  \n",
    "graph.write_png('decision_twee.png')\n",
    "Image(graph.create_png())"
   ]
  }
 ],
 "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.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}