diff --git a/Deep_Learning/Tweet_Classificaion_DL/Disaster Tweet Classification using NLP and Deep Learning.ipynb b/Deep_Learning/Tweet_Classificaion_DL/Disaster Tweet Classification using NLP and Deep Learning.ipynb new file mode 100644 index 0000000000..9b64e902a8 --- /dev/null +++ b/Deep_Learning/Tweet_Classificaion_DL/Disaster Tweet Classification using NLP and Deep Learning.ipynb @@ -0,0 +1,3103 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Real or Not? NLP with Disaster Tweets" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![](https://img3.goodfon.com/wallpaper/nbig/f/29/katastrofa-razrusheniya-zdaniya.jpg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 1. Import" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "_uuid": "e8f35d2c74c370d4b01dc540862a67254031e8b5" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Using TensorFlow backend.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['nlp-getting-started']\n" + ] + } + ], + "source": [ + "# System\n", + "import os\n", + "\n", + "# Time\n", + "import time\n", + "import datetime\n", + "\n", + "# Numerical\n", + "import numpy as np\n", + "import pandas as pd\n", + "import random\n", + "\n", + "# Tools\n", + "import itertools\n", + "from collections import Counter\n", + "\n", + "# NLP\n", + "import re\n", + "from nltk.corpus import stopwords\n", + "from nltk.tokenize import word_tokenize \n", + "from nltk.stem import SnowballStemmer\n", + "from nltk.stem import PorterStemmer\n", + "from nltk.stem import WordNetLemmatizer\n", + "# from pywsd.utils import lemmatize_sentence\n", + "\n", + "# Preprocessing\n", + "from sklearn import preprocessing\n", + "from sklearn.utils import class_weight as cw\n", + "from sklearn.feature_extraction.text import CountVectorizer\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.preprocessing import LabelEncoder\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.feature_extraction.text import TfidfVectorizer\n", + "from bs4 import BeautifulSoup\n", + "\n", + "# Model Selection\n", + "from sklearn.model_selection import train_test_split, cross_val_score, GridSearchCV\n", + "\n", + "# Machine Learning Models\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn import svm\n", + "from sklearn.svm import SVC\n", + "from sklearn.naive_bayes import MultinomialNB\n", + "from sklearn.neighbors import KNeighborsClassifier\n", + "from sklearn.ensemble import AdaBoostClassifier, RandomForestClassifier, BaggingClassifier, ExtraTreesClassifier\n", + "from sklearn.tree import DecisionTreeClassifier\n", + "\n", + "# Evaluation Metrics\n", + "from sklearn import metrics \n", + "from sklearn.metrics import f1_score, accuracy_score,confusion_matrix,classification_report\n", + "\n", + "# Deep Learing Preprocessing - Keras\n", + "from keras.preprocessing.text import Tokenizer\n", + "from keras.preprocessing import sequence\n", + "from keras.utils import to_categorical\n", + "\n", + "# Deep Learning Model - Keras\n", + "from keras.models import Model\n", + "from keras.models import Sequential\n", + "\n", + "# Deep Learning Model - Keras - CNN\n", + "from keras.layers import Conv1D, Conv2D, Convolution1D, MaxPooling1D, SeparableConv1D, SpatialDropout1D, \\\n", + " GlobalAvgPool1D, GlobalMaxPool1D, GlobalMaxPooling1D \n", + "from keras.layers.pooling import _GlobalPooling1D\n", + "from keras.layers import MaxPooling2D, GlobalMaxPooling2D, GlobalAveragePooling2D\n", + "\n", + "from keras.layers import MaxPooling3D, GlobalMaxPooling3D, GlobalAveragePooling3D\n", + "\n", + "\n", + "\n", + "# Deep Learning Model - Keras - RNN\n", + "from keras.layers import Embedding, LSTM, Bidirectional\n", + "\n", + "# Deep Learning Model - Keras - General\n", + "from keras.layers import Input, Add, concatenate, Dense, Activation, BatchNormalization, Dropout, Flatten\n", + "from keras.layers import LeakyReLU, PReLU, Lambda, Multiply\n", + "\n", + "\n", + "\n", + "# Deep Learning Parameters - Keras\n", + "from keras.optimizers import RMSprop, Adam\n", + "\n", + "# Deep Learning Callbacs - Keras\n", + "from keras.callbacks import ModelCheckpoint, EarlyStopping, TensorBoard, ReduceLROnPlateau\n", + "\n", + "# Visualization\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "\n", + "%matplotlib inline\n", + "\n", + "print(os.listdir(\"../input\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "_uuid": "bcf244fb2623377e6c472520181f55b570f22225" + }, + "outputs": [], + "source": [ + "# print date and time for given type of representation\n", + "def date_time(x):\n", + " if x==1:\n", + " return 'Timestamp: {:%Y-%m-%d %H:%M:%S}'.format(datetime.datetime.now())\n", + " if x==2: \n", + " return 'Timestamp: {:%Y-%b-%d %H:%M:%S}'.format(datetime.datetime.now())\n", + " if x==3: \n", + " return 'Date now: %s' % datetime.datetime.now()\n", + " if x==4: \n", + " return 'Date today: %s' % datetime.date.today() " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "_uuid": "f9941e463091c0974df63b98ddf42ef039d07044" + }, + "source": [ + "# 2. Read Data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "_uuid": "24a1fce867bde9c19af86e6ad3fdcc9368db4907" + }, + "outputs": [], + "source": [ + "input_directory = r\"../input/nlp-getting-started/\"\n", + "output_directory = r\"../output/\"\n", + "\n", + "if not os.path.exists(output_directory):\n", + " os.mkdir(output_directory)\n", + " \n", + "figure_directory = \"../output/figures\"\n", + "if not os.path.exists(figure_directory):\n", + " os.mkdir(figure_directory)\n", + " \n", + " \n", + "file_name_pred_batch = figure_directory + r\"/result\"\n", + "file_name_pred_sample = figure_directory + r\"/sample\"" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "_cell_guid": "79c7e3d0-c299-4dcb-8224-4455121ee9b0", + "_uuid": "d629ff2d2480ee46fbb7e2d37f6b5fab8052498a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(7613, 5) (3263, 4) (3263, 2)\n" + ] + } + ], + "source": [ + "# Load data\n", + "\n", + "df_train = pd.read_csv(\"../input/nlp-getting-started/train.csv\")\n", + "df_test = pd.read_csv(\"../input/nlp-getting-started/test.csv\")\n", + "sub_sample = pd.read_csv(\"/kaggle/input/nlp-getting-started/sample_submission.csv\")\n", + "\n", + "print (df_train.shape, df_test.shape, sub_sample.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 3. Explorarory Data Analysis" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lets see first few columns of the dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "_uuid": "82c38ef0a849c0e1b35dfaa6609497033690ecb3" + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idkeywordlocationtexttarget
01NaNNaNOur Deeds are the Reason of this #earthquake M...1
14NaNNaNForest fire near La Ronge Sask. Canada1
25NaNNaNAll residents asked to 'shelter in place' are ...1
36NaNNaN13,000 people receive #wildfires evacuation or...1
47NaNNaNJust got sent this photo from Ruby #Alaska as ...1
\n", + "
" + ], + "text/plain": [ + " id keyword location text \\\n", + "0 1 NaN NaN Our Deeds are the Reason of this #earthquake M... \n", + "1 4 NaN NaN Forest fire near La Ronge Sask. Canada \n", + "2 5 NaN NaN All residents asked to 'shelter in place' are ... \n", + "3 6 NaN NaN 13,000 people receive #wildfires evacuation or... \n", + "4 7 NaN NaN Just got sent this photo from Ruby #Alaska as ... \n", + "\n", + " target \n", + "0 1 \n", + "1 1 \n", + "2 1 \n", + "3 1 \n", + "4 1 " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_train.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "_kg_hide-input": true, + "_uuid": "5cf2744b1ea01acdb6e9100bba9c3e2a41833de0" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 7613 entries, 0 to 7612\n", + "Data columns (total 5 columns):\n", + "id 7613 non-null int64\n", + "keyword 7552 non-null object\n", + "location 5080 non-null object\n", + "text 7613 non-null object\n", + "target 7613 non-null int64\n", + "dtypes: int64(2), object(3)\n", + "memory usage: 297.5+ KB\n" + ] + } + ], + "source": [ + "df_train.info()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There are many null values in location and keyword" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Following are the unique values of location and keyword" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "221 3341\n", + "221 1602\n" + ] + } + ], + "source": [ + "print (df_train.keyword.nunique(), df_train.location.nunique())\n", + "print (df_test.keyword.nunique(), df_test.location.nunique())" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "set()" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Check if train and test have the same set of keywords\n", + "set(df_train.keyword.unique()) - set(df_test.keyword.unique())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lets see few tweet texts" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 : Our Deeds are the Reason of this #earthquake May ALLAH Forgive us all \n", + "\n", + "1 : Forest fire near La Ronge Sask. Canada \n", + "\n", + "2 : All residents asked to 'shelter in place' are being notified by officers. No other evacuation or shelter in place orders are expected \n", + "\n", + "3 : 13,000 people receive #wildfires evacuation orders in California \n", + "\n", + "4 : Just got sent this photo from Ruby #Alaska as smoke from #wildfires pours into a school \n", + "\n", + "5 : #RockyFire Update => California Hwy. 20 closed in both directions due to Lake County fire - #CAfire #wildfires \n", + "\n", + "6 : #flood #disaster Heavy rain causes flash flooding of streets in Manitou, Colorado Springs areas \n", + "\n", + "7 : I'm on top of the hill and I can see a fire in the woods... \n", + "\n", + "8 : There's an emergency evacuation happening now in the building across the street \n", + "\n", + "9 : I'm afraid that the tornado is coming to our area... \n", + "\n" + ] + } + ], + "source": [ + "c = 10\n", + "for i in range(c):\n", + " r = random.randint(0, len(df_train)-1)\n", + " r=i\n", + " print(r,\" : \", df_train.iloc[r].text, \"\\n\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "_kg_hide-input": true, + "_uuid": "cd9d8e8cccbe7be826ff80ebba85c94059b19d81" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['id', 'keyword', 'location', 'text', 'target'], dtype='object')" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "columns = df_train.columns\n", + "columns" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "_uuid": "13bfcbe5c9e172fad039501b7c6604dc81abe010" + }, + "source": [ + "## 3.2 Visualize Data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Number of tweets for disaster and non disaster in dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "_uuid": "0ffeb6d063fb09a80db926657faddf0c719333b5" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Count')" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "figsize=(20, 5)\n", + "\n", + "ticksize = 18\n", + "titlesize = ticksize + 8\n", + "labelsize = ticksize + 5\n", + "\n", + "params = {'figure.figsize' : figsize,\n", + " 'axes.labelsize' : labelsize,\n", + " 'axes.titlesize' : titlesize,\n", + " 'xtick.labelsize': ticksize,\n", + " 'ytick.labelsize': ticksize}\n", + "\n", + "plt.rcParams.update(params)\n", + "\n", + "col = \"target\"\n", + "xlabel = \"Real vs Not\"\n", + "ylabel = \"Count\"\n", + "\n", + "sns.countplot(x=df_train[col])\n", + "plt.title(\"Real vs Not Count\")\n", + "# plt.xticks(rotation=90)\n", + "plt.xlabel(xlabel)\n", + "plt.ylabel(ylabel)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Number of null values in feature columns" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "_uuid": "6415fba24b67ddc166a43327d1327bc8c75f7f2c" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "figsize=(18, 5)\n", + "\n", + "ticksize = 14\n", + "titlesize = ticksize + 8\n", + "labelsize = ticksize + 5\n", + "\n", + "xlabel = \"Train Feature\"\n", + "ylabel = \"Null Count\"\n", + "\n", + "title = \"Train Feature Null Count\"\n", + "\n", + "\n", + "params = {'figure.figsize' : figsize,\n", + " 'axes.labelsize' : labelsize,\n", + " 'axes.titlesize' : titlesize,\n", + " 'xtick.labelsize': ticksize,\n", + " 'ytick.labelsize': ticksize}\n", + "\n", + "plt.rcParams.update(params)\n", + "\n", + "df_train.isnull().sum().plot(kind=\"bar\")\n", + "plt.title(title)\n", + "plt.xlabel(xlabel)\n", + "plt.ylabel(ylabel)\n", + "plt.xticks(rotation=90)\n", + "plt.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "figsize=(18, 5)\n", + "\n", + "ticksize = 14\n", + "titlesize = ticksize + 8\n", + "labelsize = ticksize + 5\n", + "\n", + "xlabel = \"Test Feature\"\n", + "ylabel = \"Null Count\"\n", + "\n", + "title = \"Test Feature Null Count\"\n", + "\n", + "\n", + "params = {'figure.figsize' : figsize,\n", + " 'axes.labelsize' : labelsize,\n", + " 'axes.titlesize' : titlesize,\n", + " 'xtick.labelsize': ticksize,\n", + " 'ytick.labelsize': ticksize}\n", + "\n", + "plt.rcParams.update(params)\n", + "\n", + "df_train.isnull().sum().plot(kind=\"bar\")\n", + "plt.title(title)\n", + "plt.xlabel(xlabel)\n", + "plt.ylabel(ylabel)\n", + "plt.xticks(rotation=90)\n", + "plt.plot()\n", + "\n", + "\n", + "df_test.isnull().sum().plot(kind=\"bar\")\n", + "plt.title(title)\n", + "plt.xlabel(xlabel)\n", + "plt.ylabel(ylabel)\n", + "plt.xticks(rotation=90)\n", + "plt.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Top keywords for tweets" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABUcAAAFgCAYAAACYOchnAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3Xe0pFWZv/3rS5QkBjJIVARJAk0yEATEAAZkxgSSFH4oJkyjjIo66KCYRgxgAhUTOr4IOKJkBSWpBEkKkgQJgg1NDvf7x34KiuKcPqe7T/dpuq7PWrXq1N772ft+nqpei3WzQ6oKSZIkSZIkSRo28012AJIkSZIkSZI0GUyOSpIkSZIkSRpKJkclSZIkSZIkDSWTo5IkSZIkSZKGkslRSZIkSZIkSUPJ5KgkSZIkSZKkoWRyVJIkaQYkqZl4HTnZcQ9KcmsX21KTHcu8Jsni3bOdNpvHWTrJN5Ncn+SBbszvzc4xJUmS5jULTHYAkiRJTzBHjVC2HLADcBfwkxHqfztbI9Kw+i7td/dX4BjgfuCsyQomyeLAncBdVbX4ZMUx0ZLsD3wJ+HJV7T/Z8UiSpIllclSSJGkGVNUeg2VJtqYlqW4dqV6aaEmWoP3m/gWsX1X3THJIkiRJT0guq5ckSZKeeJ7Rvf/dxKgkSdLMMzkqSZI0hyXZOcmvk9yW5L4k13R7Rz5zlPaP7A+a5I1JzkkyLcm/kpyQZJMJjG3+JF/pxrswyUoD9cskOSTJn5Pc1cVxTpK3Jpl/oO3ZXT87Tme8I7o2H+k+f7v7vNtAuwW7sSrJN0fo5xdd3fYD5QsnOSDJeUnuTHJ3kouTfCLJkiP0s27Xz8VJFkryoe7vu5NcP9B24yTHJ7m9exbnJnnTGM933SRHJ7kuyf1J7khyVZKfJNlpetd21y+epIA/d0XrDOxvu1Rf2ycn+ViSi7r47kxyfpL3JnnSCH3v2PVxfJIluu/5L0nuTTLdrSGSHEpbUg+w2EBM07o2H+0+f3iE66/o6k4eoa73e3zLCHUvTHJMkhu653lzkv9Nsul0Yl0iyYFJ/tD3m7iw+64XGWh7K21JPcDbBu7rsL52Kyc5vPsu7+ue9zXdv8/p/iYkSdLkSlVNdgySJElPaGnL6k8FrqmqVcdo+yVgf+Ah4DfAP4ANgWfT9ix9ZVWdPHDNrcDTgS8A76LtK3kNsB6wLvAA8OqqOmEGYu71uXRV3dqVLQr8ENgJOBnYuaru6LtmCnACsEw3/gXAwsBmwFOA44FXVdVDXftdafti/l9VvWyEGJYE/g4sBKxSVTcmeSPwPeA7VbV7X9sXAmd0H6+tqlX66hYEbgMWBJ7am0mZtgfmr4HNaYm7U2n7cm4FLE3bq3Obqrq+r691gYuAy4HrgBcAp9OWry9dVdt27V4CHNvFfglwIbAS8Hza9/RuBvbeTEtinw4sQktuXgYEWBF4LnB8Ve0y+JwGntnCwOHd835lF9exfU32r6ppSVbo7ndN4J/AabQttbYBngycA2xXVXf29b0jcFwX49OAVbpnfjfwUFW9YTpxvZb2u3kj8CBwdF/1vVX1/5I8n7b/7hlVtVXftc8Aru0+3kffd9jVX97dxxpVdVVf+UeAjwEPA+cDV3cxb0L797V7VX1/IM7VgROBZ9L+7f2J9u9nM9rv+lzgRVXVS+h+qetvM9r3dXZfdydV1feSrAqcR/v3dBXtt/AA7XtdH7i8qqaM9uwkSdIkqypfvnz58uXLly9fs/ACtgYKuHqMdv/etfsXsGlfeWhJngJuAZ4ycN2tXd0DwE4Dde/t6m6lJZXGG3Ovz6W6z8vQEmZFS2guONC+l8gs4J3AfH11S9MSvQW8t698IVoC6iFg9RFieEd3zQ/7ypbryq4faHtQV35h9/6svroXdGWnDlzzla78T8CyfeWLA7/o6n49cM26XXkBf6ElbQfjXhK4uWtz4EDdDrQEXwHTBup+3JW/fZQ+N5uB768X58Wj1Pfu70RgiYHv6vyu7usD1+zYd++/A54+g/8OFh/pvvvqF6Alqe8DFu0r32Pgu92+r26lruxvA329plcObDhQ9yJaQvduYOW+8vm730IBhwALD8T+k67usIH+9h+pvK/+0139oSPULQK8YEaeoy9fvnz58uVrzr5cVi9JkjTnvKd7P6SqzukVVlXRkn8XA0sBuz/+UgCOrqrj+guq6lBasuvpwEwt302yJi0ZtgnwyararaoeGGi2D7AC8K2q+mJVPdwXwy3d2AW8va/8fuAI2lZO/2+Eoffr3r/Sd80/aDMxV0yyVl/bbWkzaz/Zfd5uoA7gpL57egqwV2+cqrqpb4xp3f3cB2yXZIMRYgN4T1VdM0L5G2hJxov74un1fSJw5Cj9Ldu9/99gRVVNraqzB8tnRpK1gZfSkun7VN/s0O676n0Xu/cvw+8Ph/bM/jkR8fSN/SBtJupCwJZ9Vb3v78Dufbrfbefj3fubquqPA+OcQktYLgLs3Ve1M7ABcEpVfaCq7uu7ZhrwZmAqsPfg8vox9L7XXw5WVNU9VTXdLQkkSdLkMjkqSZI0ByRZDOgtrT1ysL5LkPbKtx6lm++NUT7addPzfNoy/VWAfavqwFHa9ZbFHzNSZVX9jbYMfeVuSXfP12hJur3697lMsi2wFm3m4xk8Vi8R1lvCvhhtWfMZtJmQDzNyAq1/O4LNaUv+r6iq340Q7/W0Jfcw8nN7gLZNwEh6S8KP7r63Qd8d5bpeQvxbSbbptgOYHXrxnTpScreqzqUldhekff+DrqqqP82m2B7z3XZeBFxK27Lhn4zx3SZZBXgOcFNV/WaUcU7v3rfoKxvrN/wv2lYRT6JtdTFeve/1892+rTOSWJUkSZPM5KgkSdKcsRztv73upS01H8mV3fuKo9T/bZTyq7v3lUapn56f0GadvqOqjphOu9W79/8bOJTmkRewctdm6d5FVXUD8NNujH/v6++t3fuXRxirlwjrJcm2pCXyTqqq24E/ANskma9LnG4O3EHbL7Kn9wxHe2Yw/ed9Xf/s2AG95zzW9zHov4AzgRcCpwB3JDkrycHdbM+JMqv3PtJs2YnymO+2u+8VaN/tw7R9Up+b5OlduxfRZrKe0tdH77e47HR+i732S49w3Venc92WI1w3lsOBn9G2OjgOmNodfPW5TOBhaZIkafZYYLIDkCRJGhLp3muU2Yb9bWbWzJy0+R3a8vMPJTm5qi4fpV3vJPpjaXumTs/Ugc9fAl5HS4h+J8mKwCtoCc2RZsOeRtundOsk8/P42YMn02bhbkxLui5IO/Tpob4+Hnne04lzes/7nunUzZSqmgq8oDuYaAfarM3NabMbP5jkfVX12QkYaq679z4X0fZr3aBb0j/Sd7sL8KIkF9GStxdW1c19ffR+i/9k9Nm9Pdf3/d277uSB8pH8fYz6R3TbBeyc5LnAy2nf6/OAjYB3J/mfqnrnePuTJElzlslRSZKkOeNG2nLwRZIsX1U3jtBmte59tMTMqjw642+wHOCGmYjrA7RE0UeAM5JsV1UXjdDuOlqi6vNVdfoI9aOqqrOS/AHYLMlGwKto/x36nW6vx8H2dyQ5l5Y43JiWQLuFdmAPtKXZH6DNPnxaV3byQDe95NfqjG6s5z2aXvtVR6kfrRyAqjqTNoO0d/r8nrQZtIck+XFVXTeD8Qyanfc+S6qqkpxCS5a/iPbdPkRLiMOjy+63ox0SBo//bnvP586q2mMGhu9d992qOmoGrhuXbiuCPwF0Sf1X0bZYeEeSH1XVWRM9piRJmnUuq5ckSZoDquou4Lzu4+MOTkoSHj2I6bRRunnjGOWjXTdWbB8F/oOWjDo1ycYjNOsdIvRvMzMGbfYotJPu39z9/ZVR2sKjCbHX8ughOr2ZkL+lbU+wHSPvNwrwe9qBS2sm2Wyw825f1O27j6eN7xYe0UsOv6H73gaN9j09TlXdV1VfoyV+56ctzZ5Vvfi2TvKMwcru+12Ptq/qmRMwXs/93ftYEzB639WLafu9ntfNqqWq/kpb1j/qd9vNbr4KWDXJFMZvZn/D472vR1TVQ1X1U9oeudB+w5IkaS5kclSSJGnO+Vz3/oH+BGSXYPtPYH3gVmC0WW27JnlZf0GSd9OWmN9OWyI/U6rqENpJ808DTk6yxUCTw4CbgP2S/Ef/4Up9sWyYZLdRhvgBbfbnm4DlaYcFXTqdkHoJsbfSloA/clp5Vd1LO0TqBcBzgX9U1Z8H7udfwLe7j19J8sgekt0+pYfTDt45qaoumE4cI/k+bUn3+rQZrI9Isj1tJujjJHlHkjVGKF8LeFb3cZb3++ye6y9pp8IfnmTxvrGWAr7afTyqqm6d1fH6xr2f9vtdOMlq02na+y7fCDyFx59EfzJt1utLgQd5NNnb7yPd+4+TbD1YmeRJSXYeSPT/ALgEeHmSzydZcoTrnpVk34Hi3uzaEfeFTbJ3kvVHKF+ORw9hm537uEqSpFngsnpJkqQ5pKp+lOQFwP7A2UlOpyUcN6Sd3H4X8LousTeSLwPHJzmLlmxZj0dnAO5RVbfNYnyHJbkHOAL4VZKdquq0ru62JDsCPwc+BRzQ7Ql5My3ZuRrtQKaTGeG09qq6L8nXgQ/13cv0nEXb+7J38vfgzNCTacuyR6rreR8tebo5cGW3nPsB2qE7ywB/ZZRE5vRU1b+S7E47hOdTSXalzfxciZaw/QLw7hEufQfwxSR/oSXp7qIdRvR82r6p36iqS2Y0nlHsTTvc6KXAVd1vbQHaM3sy7YT1AyZorH4/A94CnNmNeRdwb1Xt32tQVVcnuYpHl/2P9N3uRUtenznK1gtHJ1kd+BhttvOlwBW0rStWov17WgLYDTi/u+aBJDsBvwDeBeyZ5EJa8nNpYBXgmbStKw7vG+504DZgyyS/By6jJW1PqarvA68HvpHkWtrvYGrX3wtpv98TaclqSZI0F3LmqCRJ0hxUVW+nHThzGu3All2AxWizHDesqtESfQAHA3vQkkavoiVzfglsWVU/n6D4vgns2o3xiyQ79NWdR1v2/RFacnYTYGdakus64KO0BOBoft29/512sNP04riPtnwe4KqqGjx5vX+24YjPrEuqbQO8F/gLban2jrRZnwcDm1TVWAfzjBbfCbSk5i9oybhX0r7HvXl0VuOg9wPfoCV9X0D77lfr7uXVwD4zE8so8d0AbAp8nJbAfjltGfuVXRxbVdWdEzVen/fQtlC4H3gN7XnsMUK73nd2Dy0RPlhXA+0ep6o+AWxGm2m9CPAS2ne8JO2Z7kk7Pb7/mqvoDkoCLqb9z4XX0GaF3g4cQkt29l8zrev7RGBN2uznvWmHLkH7nwWH0WZGb0pbtr8OcHbXdqeqeni0+5AkSZMrox+WKkmSpLlBkltpp7IvPZHLoOe0bubom4GPdIktSZIkaVKZHJUkSZrLzQvJ0STPAi6inUy+alXdMskhSZIkSe45KkmSpNknyedp+3vuACwMfNTEqCRJkuYWJkclSZI0O+0GPA24nnYI039NbjiSJEnSo1xWL0mSJEmSJGkoeVq9JEmSJEmSpKHksvp5wFJLLVWrrrrqZIchSZIkSZIkzRXOP//8W6tq6bHamRydB6y66qqcd955kx2GJEmSJEmSNFdIcs142rmsXpIkSZIkSdJQcuboPODS6//Jxu/7zmSHIUmSJEmSpLnY+Z9502SHMNdx5qgkSZIkSZKkoWRyVJIkSZIkSdJQMjkqSZIkSZIkaSiZHJUkSZIkSZI0lJ6wydEk8yU5PMk/k1SSrWfjWFcnee9on0e5Zo8k02ZXTJIkSZIkSZJmzRM2OQq8DNgT2AlYHjhreo2TrNolUadMwNibAF/p67uS7DLQ5kfA6hMwliRJkiRJkqTZYIHJDmAWPBO4saqmmxSdHarqlnG0uQe4Zw6EI0mSJEmSJGkmPCFnjiY5Evg8sHI3a/PqJC9J8psktye5LcmJSdbuu+xv3fu53TWndX1tkuRXSW5NckeS3ybZYozxH1lWn+TqrviYXixd+eOW1SfZKcn5Se5N8rckBydZqK9+5yQXJrmnu4fTkyw70w9KkiRJkiRJ0qiekMlR4J3Ax4HraUvqNwEWA74AbApsDUwFjutLPm7avb+ku2bn7vMSwHeBF3Zt/gT8IslS44xlk+79LX2xPE6SHYCjgcOAdYC9gF2AT3b1ywE/BI4C1ga27OKSJEmSJEmSNBs8IZfVV9XUJHcCD1XVP7rin/a3SbIncAct4flboLcU/p9911BVpwxc93bgNbQk6vfGEcstSQD+1d/vCA4EPlNV3+4+X5nkA8D3krwPWAFYEPhJVV3Ttbl4rPElSZIkSZIkzZwn6szRx0myRpLvJ7kyyR3ATbT7W3mM65bpTr2/IslU4E5gmbGumwkbAwcmmdZ7Ad+nzXhdDrgAOAm4OMlPk+yXZOnpxL1PkvOSnPfg3XdOcKiSJEmSJEnSvO8JOXN0FMcBfwf27d4fBC4BFpreRbRl7MsC7wauBu4DTh7HdTNqPuBjwDEj1N1SVQ8leTGwOfBiYG/gU0m2qqoLBi+oqiOAIwAWW261muBYJUmSJEmSpHnePJEcTfJ02j6db6uqU7uyjXjs/d3fvc8/cPkLgHdU1QnddcvS9g6dEQ+M0O+gPwBrVdVfR2tQVQX8Dvhdko8DfwZeS5tVKkmSJEmSJGkCzRPJUeB24FbgLUmuA1YEPkObPdpzM3APsEN3ovy9VTUVuALYNcnZtCXun+bRROp4XQ1sm+R04L6qun2ENh8Hjk9yDfDjLrZ1gU2r6v1JNge2A06kbQmwIfAM2uxXSZIkSZIkSRNsnthztKoeps2wXJ92iNGXgQ/Tlsj32jwIvAN4M3ADcGxXtRewOHA+7bT4b9GSnTPiPcA2wHXAH0eJ8UTg5V27c7rXfwDXdk2mAs8Hjgf+AnwW+ERVjXkolCRJkiRJkqQZl7aSW09kiy23Wq2128cmOwxJkiRJkiTNxc7/zJsmO4Q5Jsn5VTVlrHbzxMxRSZIkSZIkSZpRJkclSZIkSZIkDSWTo5IkSZIkSZKGkslRSZIkSZIkSUNpgckOQLNu7ZWeznlDtKGuJEmSJEmSNBGcOSpJkiRJkiRpKJkclSRJkiRJkjSUTI5KkiRJkiRJGkomRyVJkiRJkiQNJZOjkiRJkiRJkoaSp9XPA+6/8c9c+/H1JjsMSZIkSZKkOWblj1w02SFoHuDMUUmSJEmSJElDyeSoJEmSJEmSpKFkclSSJEmSJEnSUDI5KkmSJEmSJGkomRwFkhyf5Mhxtl01SSWZMpvDkiRJkiRJkjQbmRyVJEmSJEmSNJRMjkqSJEmSJEkaSkOXHE2yaJIjk0xLclOSDw3UL5TkkCTXJ7kryblJdphOf1t3y+yX6it73NL7JC9PcnmSe5OckeR1XZtV+9o8L8npSe5O8vckX03y5Il9ApIkSZIkSZJgCJOjwKHA9sBrgG2BDYEt++q/DWwFvAFYDzgKOC7JBjM7YJKVgf8FTgA2AP4H+PRAm/WAXwE/79rsDDwX+NbMjitJkiRJkiRpdAtMdgBzUpLFgb2BvarqxK5sT+D67u81gNcDq1bVtd1lhyXZDtgXeOtMDr0fcBXwnqoq4PIkawIH97V5H/CjqvpsX7z7AX9MskxV3TyTY0uSJEmSJEkawVAlR4E1gIWA3/UKqmpakou6jxsBAS5J0n/dwsApszDuWsC5XWK05+yBNhsDz0zy2r6yXhBrAI9JjibZB9gHYMUlF5yF0CRJkiRJkqThNGzJ0YxRPx9QwCbAAwN194xyzcMj9D2YrUzX71hjfwP4/Ah1fx8sqKojgCMA1l9xkbH6liRJkiRJkjRg2JKjf6UlPTenLXMnyWLAusCVwB9piczlqurUcfZ5S/e+fN/fzx1ocynwyoGyTQc+/wFYp6r+Os5xJUmSJEmSJM2CoTqQqaqmAd8EDkmyfZJ1aAcezd/VXwEcDRyZZJckqyeZkuS9SXYepdu/AtcBByVZM8mLgf8caPM1YI0khyZ5dtfXvr2wuvdDgE2TfC3JhkmemWTHJIdP1P1LkiRJkiRJetRQJUc77wVOBX7WvV8MnNFXvyftxPpPA5cBx9NOs79mpM6q6gHgdcDqwAXAx4APDbS5BngN8Iquzbu7dgD3dm0u7MZZFTi9a/cp4KaZv1VJkiRJkiRJo8ljzwjSnJLkncDHgadW1cNjtZ+e9VdcpI7f95kTE5gkSZIkSdITwMofuWjsRhpaSc6vqiljtRu2PUcnTZK3AefS9iXdHPgwcOSsJkYlSZIkSZIkzRyTo3POM2nL7Z8OXE/bh/TjkxqRJEmSJEmSNMRMjs4hVfVu2l6jkiRJkiRJkuYCw3ggkyRJkiRJkiSZHJUkSZIkSZI0nFxWPw9YaPl1WPkj5012GJIkSZIkSdITijNHJUmSJEmSJA0lk6OSJEmSJEmShpLJUUmSJEmSJElDyeSoJEmSJEmSpKHkgUzzgMtuvoznf+n5kx2GJEmSJEnSHHPm28+c7BA0D3DmqCRJkiRJkqShZHJUkiRJkiRJ0lAyOSpJkiRJkiRpKJkclSRJkiRJkjSUTI5KkiRJkiRJGkomR2dCksOSnDZGm+OTHDlnIpIkSZIkSZI0o0yOSpIkSZIkSRpKk5ocTbLgZI4vSZIkSZIkaXhNaHI0yUuS/CbJ7UluS3JikrW7ulWTVJLXJzklyT3Avkn2SDItyUuTXJbk7iQ/T7Jkkl2S/CXJ1CTfTbLIeMbqa7NZkj8kuTfJH5O8rIth6742z0lyQpI7k9yc5AdJluurnz/Jod04tyf5AjD/wDiLJjmyu4+bknxohGfz1CRHdX3ck+SkJOv01feew7ZJLk5yV5JTk6w2AV+NJEmSJEmSpAETPXN0MeALwKbA1sBU4LgkC/W1+RTwFeA5wP/XlS0MvAd4I7AtMAX4CbA78BrgVcCOwFvHO1aSxYHjgcuAjYH3A5/pDzbJ8sAZwMVdP9sBiwM/T9J7Nu8B3gLsC2xBS4y+ceC+DwW272LdFtgQ2HKgzZHAZsAru7HuBn7Zn/DtnsMHgb26sZ4CfA1JkiRJkiRJE26Bieysqn7a/znJnsAdtGTg9V3xl6rqJ31tenG8raou78q+D7wbWLaqbu3KjgW2AT47jrF+S0tgzg/sXVX3AH9OcjBwdN9l+wEXVNUH+vp5E3AbLUF7DvAu4NNV9eOu/p3ADn3tFwf2BvaqqhP7Yrm+r82zgFcAW1XVGV3ZbsC1XZzf6JoOPodDgW8nma+qHh64332AfQAWemp/7lmSJEmSJEnSeEz0svo1knw/yZVJ7gBu6sZYua/ZeSNcel8vIdi5CfhHLzHaV7bMDIy1FnBxlxjtOXtg3I2BLbvl7NOSTAOu6+rWSLIksDzwu94FXZKyv581gIUG2kwDLuprszbw8ECbqV2b50znOdwALEibQfoYVXVEVU2pqikLLu7WrZIkSZIkSdKMmtCZo8BxwN9pS9D/DjwIXEJLHvbcNcJ1Dw58LuCBEcr6k7ljjZXumumZDzgBeO8Idb1k61gyi236YxzpOTDOOCRJkiRJkiTNgAlLuiV5Om2G5Cer6qSquhRYgolPwI53rEuB9Qb29Nx0oKs/AOsA11TVXwded3azO28ENu8bOwP9/JWWyO1vsxiwbl+bS2jPeou+Nk8G1uvqJEmSJEmSJM1hEzkj8XbgVuAtSZ6ZZCvaYUKDsyHn1FhHAw8BX+9OpN8O6J0i35uR+WVgSeBH3cn2qyfZLskRSZbo2nwReH+SXZI8m3YI1PK9Qbol9N8EDkmyfXcC/bfoO9G+qv4CHAscnuSFSdYDvkfbI/X7E/ZUJEmSJEmSJI3bhCVHu704XwusTzv9/cvAh4H7JmqMGRmrS1ruRJsZ+kfaSfUHddX3dm1uAJ5P2w/0l8Cfu77u6+vrs8C3aYcmnU17Zv2HOkFbln8q8LPu/WLgjIE2e9IOePp5974o8JKBPVElSZIkSZIkzSGpGmtbznlHklfSEpjLDBz29IS2+MqL1wbv22Cyw5AkSZIkSZpjznz7mZMdguZiSc6vqiljtZvw/UDnJkl2B66inUC/Lm1J/HHzUmJUkiRJkiRJ0syZp5OjwLLAx2h7hP6DdjL9ByY1IkmSJEmSJElzhXk6OVpVnwY+PdlxSJIkSZIkSZr7TORp9ZIkSZIkSZL0hDFPzxwdFmsts5abEEuSJEmSJEkzyJmjkiRJkiRJkoaSyVFJkiRJkiRJQ8nkqCRJkiRJkqShZHJUkiRJkiRJ0lDyQKZ5wJ2XX87pW2412WFIkiRJkiSx1RmnT3YI0rg5c1SSJEmSJEnSUDI5KkmSJEmSJGkomRyVJEmSJEmSNJRMjkqSJEmSJEkaSiZHJUmSJEmSJA2lMZOjSU5LcthEDppklyQ1kX3OLkn2SDJtsuOQJEmSJEmSNLGeEDNHkzwtyXFJpiX5Y5INB+o/l+STI1zzpSSXJbknyXVJvprk6QPtnprku0mmdq/vJnnKnLgvSZIkSZIkSZPnCZEcBQ4ElgA2Ak4Dvt6rSLIx8FLg4wPXrACsCLwfWA/YFdgS+MFAu+93/b4UeEn393cn+gYkSZIkSZIkzV3GmxxdIMkXk9zevT6TZD54ZOblUV35PUlOSrJO/8VJ3pTkmiR3JzkeWLavbtUkDyWZMnDNW5LcmmQhYG3gh1V1BXBE95kkC9ASpW+tqnv7r6+qi6tq56r6eVX9tapOB94HbJfkyd31a9MSovtU1VlV9TtgX2DHJM8eiGenJFckuTfJqUlW76tbI8mxSf6R5K4kf0iy48D1yyb5efeMrkmyZ5KLkxzU12bfvjFuSXJid4+SJEmSJEmSJth4k6Nv7NpuQUse7gO8q6s7EtgMeCWwKXA38MskiwAk2axrcwTwXOA4+mZ5VtXVwEnAXgNj7gV8t6ruBy4AXtQlCncALuzaHAD8sapOHed9PBm4r4uR7n6mAWf1tTkTuAt4Xl/ZwsBHgT27a+YHfpYkXf3iwP8B2wMbAD8F/jfJWn19HAWsAryI9qx27T4D0CWHvwx8DHg2sB3wy3HelyRJkiRJkqQZNN5ZiTcC76iqAi5LsiZwQJLjgFcAW1XVGQBJdgOupSVUvwG8Ezhev57rAAAgAElEQVS5qg7u+roiySbA3n39fx34epIDqurebkbn5sBbuvr/Br4KXAlcDezdzdzcD9g8yZeAlwGXAW+uqhsHb6DbR/QTwNer6sGueDnglu6+AKiqSnJzV9f/nN5ZVWf23eNVwLbASVV1AS2B23Nwkp2AXYD/6mah7gBsUVW/7/rYo7uXnpVpSdmfV9WdwDUDfQ7ezz60JDXLLrzwaM0kSZIkSZIkjWK8M0d/359ABH5H289zbeDh7jMAVTUVuAh4Tle0dn993/X9jgXuB3buPu8FnFNVF/f6rKo3VNUqVbVVVV0CHA58EPg3YJ1unD8B/zMYfJLFaDNW/07bg7RfDbYHMlD+MHBO3z1eA9zQu8ckiyX5dJJLuu0FpgFTaAlPgLW6Ps7r6+O6ro+eX9MSon9LcnSS3ZMsMUJsveuPqKopVTVlyQUXHK2ZJEmSJEmSpFHM6oFMmU5djaNNa1j1APAdYK9u6fxuwDdHHTR5E3B/Vf2Qtkz9p93y++93n/vb9pa8A+w4sDfpP4Bl+pbH0/29NHDTWHH3OZSWpP0wsBVt+4BzgIV63Y7VQTdbdCPg32kzbz9Im6W7wgzEIUmSJEmSJGmcxpsc3aw/gUhb8n4DcAmP7kUKQHfY0XpdHd375gP9DX6GtrR+G+CttJPpfzhSIEmWou1Zul/fPfSmTi5E2w+013YJ2r6d8wMvq6ppA939jrZf6BZ9ZVsAi/HYfUjnAzbp63dlYAXg0q7oBcB3quqnVXUhcD2wRt/1l3Z9bNzXx0pdH4+oqger6pSq+iCwfhfHYw52kiRJkiRJkjQxxpscXQH4QpJnJ9mFdur756vqL7Ql8YcneWGS9YDvAXfQZnFCW+a+XZIPJnlWkrcArx4coDuJ/rfAZ4CfVNUdo8TyhW7sa7vPvwV27/YpfVf3uZcY/RXwVGAPYLEky3WvhboxL6UlTw9PsnmSLWjL9Y+vqsv7xnywu/8tkjyXdrjSn2kHSQFcAbw6yUZ9z+BJffd2OXAi8LVunOcC36YdDFVdvDsmeWeSDZOsAryBliTuJWAlSZIkSZIkTaDxJkePps2+PJs2w/ObwOe7uj1pS8h/3r0vCrykqu4B6A4g2ps20/NC2r6iB40yzjdpsz9HXFKf5MXAmsCX+oq/TEsgnt3VvaMr35g2Q/U5tOTljX2v/pPo30g7+OhXtATmBbRl/f3uAw6mLf0/m/bcdu7bh/UA4GbgN7Ql/L/v/u63B21G6Wm0Z3V0d01vmf+/gFfREq6XAe+lHS412I8kSZIkSZKkCZDHnrM0uZJ8ANi7qtac7Fhmt257gBuA11fVT2elr2cvsUQdseFGExOYJEmSJEnSLNjqjNMnOwSJJOdX1ZSx2i0wJ4IZS3do0lrAO2kzNOc5SV5EWyZ/EbAM7T5vpS3rlyRJkiRJkjSHzepp9RPlMODM7nX4JMcyuywI/BctOXoccA+wZVXdNalRSZIkSZIkSUNqrpg5WlV70PbknGdV1Ym0PU0lSZIkSZIkzQXmlpmjkiRJkiRJkjRHzRUzRzVrlnj2s93sWJIkSZIkSZpBzhyVJEmSJEmSNJRMjkqSJEmSJEkaSiZHJUmSJEmSJA0lk6OSJEmSJEmShpIHMs0Dbr5+Koe957jJDkOSJEmSJIn9P7vTZIcgjZszRyVJkiRJkiQNJZOjkiRJkiRJkoaSyVFJkiRJkiRJQ8nkqCRJkiRJkqShZHJUkiRJkiRJ0lAyOTodSU5LcthkxyFJkiRJkiRp4pkclSRJkiRJkjSUTI7OYUkWnOwYJEmSJEmSJJkcHY/5knwyya1Jbk5yaJL5AJLsmuTcJHd2dcckWbF3YZKtk1SSlyU5J8n9wA5JDkpycZLdk1ydZFqSbydZKMlbk1yX5J9JPtcbS5IkSZIkSdLEMvE2tjcCDwLPA/YH3gW8tqtbCPgosAGwI7AU8IMR+jgE+E9gLeDsrmxV4JXdda8B/g04FtgEeDHwZuDtwKsn+H4kSZIkSZIkAQtMdgBPAJdU1Ue6v69I8hZgW+AHVfWtvnZXJdkPuDTJSlV1fV/dQVX1q96HJADzA3tW1VTg4iS/BLYCVqyq+7t+zgS2AX46GFSSfYB9AJ66xNITda+SJEmSJEnS0HDm6NguHPh8A7AMQJKNkhyb5JokdwLndW1WHrjmPB7v2i4x2nMTcEWXGO0vW2akoKrqiKqaUlVTFl90yfHeiyRJkiRJkqSOydGxPTDwuWj7kC4GnAjcDexGWw7/kq7NQgPX3DXOfkcca0YDliRJkiRJkjQ2l9XPvLVoe4x+qKr+BpBk58kNSZIkSZIkSdJ4OStx5l0L3Afsn2T1JC8HPjHJMUmSJEmSJEkaJ5OjM6mqbgF2B14FXEI7tf6ASQ1KkiRJkiRJ0rilqiY7Bs2ilZd7Vr3/jZ+b7DAkSZIkSZLY/7M7TXYIEknOr6opY7Vz5qgkSZIkSZKkoWRyVJIkSZIkSdJQMjkqSZIkSZIkaSiZHJUkSZIkSZI0lBaY7AA065ZZaUk3O5YkSZIkSZJmkDNHJUmSJEmSJA0lk6OSJEmSJEmShpLJUUmSJEmSJElDyeSoJEmSJEmSpKFkclSSJEmSJEnSUPK0+nnAjX+7koN33WWyw5AkSZIkSeLA7/1kskOQxs2Zo5IkSZIkSZKGkslRSZIkSZIkSUPJ5KgkSZIkSZKkoWRyVJIkSZIkSdJQmueTo0mOT3LkZMchSZIkSZIkae4yzydHJUmSJEmSJGkkJkclSZIkSZIkDaV5KjmaZNEkRyaZluSmJB8aqN81yblJ7kxyc5JjkqzYV791kkry0iTnJ7knyW+SrJRkqyQXdH0fn+TpfddtkuRXSW5NckeS3ybZYmDsNZOcnuTeJJcneVnX1x59bVZM8sMkt3evE5I8azY+MkmSJEmSJGlozVPJUeBQYHvgNcC2wIbAln31CwEfBTYAdgSWAn4wQj8fA94FbAY8FfgR8BFgH2BrYB3goL72SwDfBV4IbAr8CfhFkqUAkswH/Ax4ENgc2KOLY+FeB0kWBU4F7gW2ArYAbgRO6uokSZIkSZIkTaAFJjuAiZJkcWBvYK+qOrEr2xO4vtemqr7Vd8lVSfYDLk2yUlVd31f34ar6TdfH14AvARtX1R+6sqOAXfr6PWUglrfTErQvAb5HS9g+G3hxVf29a/Nu4My+y14HBNizqqprsy9wMy2R++OBMfahJWtZctFFxvmUJEmSJEmSJPXMSzNH16DNDP1dr6CqpgEX9T4n2SjJsUmuSXIncF5XtfJAXxf2/X1T937RQNkyff0uk+TwJFckmQrc2dX3+l0LuKGXGO2cCzzc93ljYDXgzm65/TRgKm3m6hqDN1tVR1TVlKqastiTFh6sliRJkiRJkjSGeWbmKG3W5eiVyWLAicBJwG60GZlLAb+hJVX7PdD3dwFU1WBZf2L5KGBZ4N3A1cB9wMl9/abXz3TMR1uO/7oR6m4b41pJkiRJkiRJM2heSo7+lZbU3By4Ch5JiK4LXEmbvbkU8KGq+ltXv/MEjf0C4B1VdULX77LA8n31lwIrJlmhqm7oyqbw2ATrH4DXA7dW1b8mKC5JkiRJkiRJo5hnltV3S+i/CRySZPsk6wDfAubvmlxLm9G5f5LVk7wc+MQEDX8FsGuS5yTZBPghcH9f/a+By4GjkmyQZHPgc7QDmnozSo+mLdc/NslWSVZLsmWSz3pivSRJkiRJkjTx5pnkaOe9tBPff9a9XwycAVBVtwC7A68CLqGdFn/ABI27F7A4cD4tMfot2vJ6urEfBl5NO53+HNoy/INpidF7uzZ3A1vSZr0eA1zWtXsqcPsExSlJkiRJkiSpk+5gdM1hSTag7TE6parOn5W+Vnz6U+utL912YgKTJEmSJEmaBQd+7yeTHYJEkvOraspY7ealPUfnakleDdwF/AVYlbas/gLaXqOSJEmSJEmS5jCTo3POEsAhwDNoy+RPA95dTt2VJEmSJEmSJoXJ0Tmkqr4DfGey45AkSZIkSZLUzGsHMkmSJEmSJEnSuDhzdB6w/GpruNmxJEmSJEmSNIOcOSpJkiRJkiRpKJkclSRJkiRJkjSUTI5KkiRJkiRJGkomRyVJkiRJkiQNJZOjkiRJkiRJkoaSp9XPA+698U4uPfiUyQ5DkiRJkiSJtQ980WSHII2bM0clSZIkSZIkDSWTo5IkSZIkSZKGkslRSZIkSZIkSUPJ5KgkSZIkSZKkoTT0ydEkWyepJEvNwDUHJbl4IvuUJEmSJEmSNGcNfXIUOAtYHvjnXN6nJEmSJEmSpAm0wGQHMNmq6n7gH3N7n5IkSZIkSZIm1tDMHE2yZZLfJ5mWZGqSs5OsO7gEPskeXZttk1yc5K4kpyZZbTp9r5zksiRHJVlgZvtM8sEkN3Vtv5Pko0munq0PRpIkSZIkSRpSQ5EcTbIAcCzwW2ADYDPgi8BDo1yyMPBBYC9gC+ApwNdG6Xtt4EzgF8AeVfXgzPSZ5HXAR4EDgY2AS4EDxnuPkiRJkiRJkmbMsCyrfzItGXlcVV3ZlV0GkGTZEdovALytqi7v2hwKfDvJfFX1cK9Rkk1pSdHPV9XBY8QwVp/vBI6sqm907T+VZBtgzZm4X0mSJEmSJEljGIqZo1V1G3AkcGKSE5IckOQZ07nkvl4Ss3MDsCAtwdqzInAycMg4EqPj6XMt4JyBa84erbMk+yQ5L8l5t931r3EML0mSJEmSJKnfUCRHAapqT9py+jOAVwBXJNlhlOaDS+Ore+9/XrcCvwdel+Sp4whhPH0W41RVR1TVlKqa8rTFnjL2BZIkSZIkSZIeY2iSowBVdUFVHVJVWwOnAbvPQnf30ZKstwO/HmeCdHouAzYdKBv8LEmSJEmSJGmCDEVyNMlqSf47yfOSrNLt5bk+cMms9FtV9wA7AVNpCdJZmcL5RWCPJHsleVaS99Nmuo57NqkkSZIkSZKk8RuK5ChwN+1go2OAK4CjgKOBQ2a14y5BuiOzmCCtqh8CnwD+G/gjsC7tNPt7ZzVGSZIkSZIkSY+XKicmzq2S/AxYoKp2ml67dVd8dh3z1q/OoagkSZIkSZJGt/aBL5rsECSSnF9VU8Zqt8CcCEZjS7IosB/wS9rhTa8BXtm9S5IkSZIkSZpgJkfnHgW8FPgQsAjwF2C3qvrZpEYlSZIkSZIkzaNMjs4lur1Lt5vsOCRJkiRJkqRhMSwHMkmSJEmSJEnSY5gclSRJkiRJkjSUXFY/D3jS8kt4EpwkSZIkSZI0g5w5KkmSJEmSJGkomRyVJEmSJEmSNJRMjkqSJEmSJEkaSiZHJUmSJEmSJA0lD2SaB9xwww0cdNBBkx2GJEmSJEmai5k7kB7PmaOSJEmSJEmShpLJUUmSJEmSJElDyeSoJEmSJEmSpKFkclSSJEmSJEnSUDI5KkmSJEmSJGkomRydAUmOTHL8ZMchSZIkSZIkadYNVXI0yWlJDpuFLt4J7DrOsfZIMm0WxpIkSZIkSZI0Gy0w2QE8kVTV1MkYN8mCVfXAZIwtSZIkSZIkzauGZuZokiOBrYC3JanudVOSD/S1OborX677vGiS+5M8v9dH/7L6JFsm+X2SaUmmJjk7ybpJtga+DSzWN9ZB3TULJTkkyfVJ7kpybpId+vrcumv/siTnJLkfeKRekiRJkiRJ0sQYmuQobUn872hJy+W713eAbfrabAXcCmzdfX4+8ABwzmBnSRYAjgV+C2wAbAZ8EXgIOAt4F3B331iHdpd+uxvnDcB6wFHAcUk2GBjiEOA/gbWAs2fqjiVJkiRJkiSNamiW1VfV1G4W5t1V9Q+AJKcA+3WJztWAJYH/oSVMf0hLkp41ypL2JwNPAY6rqiu7sst6lUmmtmHbWF3ZGsDrgVWr6tqu+LAk2wH7Am/t6/+gqvrVaPeTZB9gH4All1xyfA9BkiRJkiRJ0iOGaeboSH4DLAxsQkuE/gY4iUdnjm4NnDbShVV1G3AkcGKSE5IckOQZY4y3ERDgkm4p/rTu0KaXA2sMtD1veh1V1RFVNaWqpiy66KJjDCtJkiRJkiRp0FAnR6tqGvAH2kzRrYFTaUvvV0nyLFrS9LTpXL8nbTn9GcArgCv69w8dwXxAdf0+t++1NrDXQNu7ZviGJEmSJEmSJI3b0Cyr79wPzD9QdhotObo28IWqujfJ2cCBjLLfaL+qugC4ADgkyf8BuwMnjjLWH2kzR5erqlNn7VYkSZIkSZIkzYphmzl6NbBpklWTLJVkPh5Nji5Bm0VKV7Yro+83SpLVkvx3kuclWSXJNsD6wCV9Yz0pyfbdWItW1RXA0cCRSXZJsnqSKUnem2Tn2XPLkiRJkiRJkkYybMnRQ2kzOi8BbgFWpu0zWsBvquqhrt2ptFmfp02nr7uBNYFjgCtop84fTTtlnqo6C/ga8INurPd31+1JO7H+07QDnI4HtgSumYD7kyRJkiRJkjROqarJjkGzaIUVVqh99tlnssOQJEmSJElzsYMOOmiyQ5DmmCTnV9WUsdoN28xRSZIkSZIkSQJMjkqSJEmSJEkaUiZHJUmSJEmSJA0lk6OSJEmSJEmShpIHMs0DpkyZUuedd95khyFJkiRJkiTNFTyQSZIkSZIkSZKmw+SoJEmSJEmSpKFkclSSJEmSJEnSUDI5KkmSJEmSJGkoLTDZAWjW3X77pfz4mE0nOwxJkiRJkjQX+/d/O2eyQ5DmOs4clSRJkiRJkjSUTI5KkiRJkvT/t3fnwXYWdRrHv49BXFgcNEZAR1RQkUUEAyNINOqwKFoFIw67Cw6oCG4oiAoiijiIChpUUkwEArigjlsUECEoQ0okCJhBEtCwiSwqS6Ls/OaP9z3D8eResxFu7n2/n6pb57zd/fbpc6vounno7leS1EmGo5IkSZIkSZI6yXBUkiRJkiRJUicZjkqSJEmSJEnqJMNRSZIkSZIkSZ1kODoCklSSXUd6HJIkSZIkSVKXGY5KkiRJkiRJ6qRRFY6mcUiS3yW5J8lvkuzd1s1K8rmB9mu27XZpr/dO8qskC5LcluSsJM8cuGfDJD9IcleShW2/m7Z1pyT50UD7I5PM6bveMsm5Sf6U5O4kFyXZuq/+uvbtWe0K0uv66t6QZHaSe5PMT3J0klUflV+eJEmSJEmSpL8zqsJR4FPA24F3AxsBxwAnJdkJOB3YPUn/d3ojcA8wo71eFfg4sBnwemA88PVe4yTrAhcBBWwHbAGcCIxbijGuAUwHJgFbAZcDP04yvq3fsn3dD1ind51kB+AMYAqwMbAvsCvw6aX4bEmSJEmSJElLaJWRHsCSSrIa8AFg+6r6RVs8P8lWNGHpPsAXgFcBP2vr9wLOqqr7AapqWl+Xv0/yLuC3SZ5VVTe1/fwVeFPvHmDe0oyzqs4fGPdBNCHtjsDpVXV7EoA7q+qWvqYfBT5bVV9rr3+X5FDg9CQfqqoa6Hd/YH+A8eNdXCpJkiRJkiQtrdG0cnQj4InA2e1294VJFgLvAtavqj8D59AEoiRZhyYoPb3XQZItknw/yfVJFgCXtlXPbl83By7qC0aXWpIJSU5KMi/JXcACYELfZwznpcBHB77bmcBqwNqDjatqalVNrKqJa645ajJuSZIkSZIkaaUxmlK1XpD7BuCGgboH2tfTgalJDgD2AG6k2SbfW3l6DnAezSrT22i21f+CZrs9QBYzhoeHaPP4getTgWcA7weuA+6jWcm6uOWdjwM+AZw1RN3ti7lXkiRJkiRJ0lIaTeHoVTRB43qDW9f7fB+YSnOe6F7AGX3b0TekCUM/UlXzAZL828D9lwF7J1l1mNWjtwMvGSgbvN4WeE9VzWg/4xk0Z4v2e4BFzzG9DNiwqq4d5rtJkiRJkiRJehSNmm31VbUAOA44Lsm+STZI8pIk72zP36Sq7gW+C3yM5mFKp/d1cQNNuHpgkue1D3H65MDHfBlYHfhW+9T5DZLskaQXgJ4PbN73+YcALx/oYx5NwLpRki2BbwCDQet1wGuSrJ1krbbsKGDPJEcl2STJhkl2TXLsMvy6JEmSJEmSJC3GqAlHW4cDRwIfBP4X+CnNw47m97WZTvM0+suq6re9wqq6HXgLsDPNKtSP0zzgib42fwBeQbMF/gLg18BBwINt/Tk0W9+PBmYDz6EJVPvtSxOwzqYJRqfRhKH9DqY5D/XG9jN6fe/Ull/S/nyYRY8QkCRJkiRJkvQoyMBD0DUKrb/+anXMZzYe6WFIkiRJkqSV2L+/6ZKRHoL0mEkyu6omLq7daFs5KkmSJEmSJEmPCsNRSZIkSZIkSZ1kOCpJkiRJkiSpkwxHJUmSJEmSJHXSKiM9AC2/tdZ6kYcqS5IkSZIkSUvJlaOSJEmSJEmSOslwVJIkSZIkSVInGY5KkiRJkiRJ6iTDUUmSJEmSJEmd5AOZxoCr7ribzb59zkgPQ5IkSZIkrcSu2HWHkR6CtNJx5agkSZIkSZKkTjIclSRJkiRJktRJhqOSJEmSJEmSOslwVJIkSZIkSVInGY5KkiRJkiRJ6iTD0SEkOTLJnCW9HqaPKUlmLuc4xiepJJOXpx9JkiRJkiRJizIcXTbHAa8c6UFIkiRJkiRJWnarjPQARqOqWggsHOlxSJIkSZIkSVp2Y3blaBoHJ7kmyX1JbkpyTFu3aZLzktyT5C9JTknylKXoe3Cb/bgkxyW5o/05Hhg3xHgOSfK79nN/k2TvgTZbJpmd5N4kvwb+Zfl+C5IkSZIkSZKGM2bDUeDTwOHAMcDGwJuAG5M8GTibZuXnVsAuwDbAtOX4rIOB/YB3AFvTBKN7DbT5FPB24N3ARu24TkqyE0CS1YAZwO+BicCHabbvS5IkSZIkSVoBxuS2+iSrA+8H3ldVvdDzWmBWkv2A1YF9qmpB235/4IIkG1TVtcvwke8Djq2qb7X9vRfYoW88qwEfALavql+0xfOTbEUTls6gCVNXBd7Wbtufk+RoYPow33F/YH+Ax4+fsAxDliRJkiRJkrptTIajNCsznwD8bIi6FwFX9oLR1sXAw+19SxWOttvx1wFm9cqq6uEkvwT+uW88TwTOTlJ9tz8euG5gXP1nmc5iGFU1FZgK8OT1X1DDtZMkSZIkSZI0tLEajmYxdcOFiSsqZOwdX/AG4IaBugfa1380ZkmSJEmSJEmPsrF65uhVwH3Aa4ap2yzJGn1l29D8Ln67tB9UVXcBfwRe1itLEprzTAfHs15VXTvwc31fm03bLfg9L0OSJEmSJEnSCjEmV45W1YIkJwDHJLkP+DnwNOClwKnAJ4DTkhwBrAWcBHx3Gc8bBTgBOCzJPOA3wAE0W+3/2Dee44Dj2uD05zTnnr4MeLjdIn8mcDQwLclRwLrAR5dxPJIkSZIkSZIWY0yGo63DgDtonlj/LOBW4LSq+luSHYDjgUuAe4HvA+9djs/6HLA2cHJ7PR04g+Yc0Z7D2zF8EPgKcDdwOXAsQFUtTPL6tu4y4GrgUOAHyzEuSZIkSZIkScNIlc/yGe2evP4L6vn/+aWRHoYkSZIkSVqJXbHrDiM9BOkxk2R2VU1cXLuxeuaoJEmSJEmSJP1DhqOSJEmSJEmSOslwVJIkSZIkSVInGY5KkiRJkiRJ6qSx/LT6zthorTW51EOVJUmSJEmSpKXiylFJkiRJkiRJnWQ4KkmSJEmSJKmTUlUjPQYtpyQLgLkjPQ5JK4XxwJ9GehCSVgrOB5J6nA8k9TgfqEvWq6qnL66RZ46ODXOrauJID0LSyEtyqfOBJHA+kPQI5wNJPc4H0qLcVi9JkiRJkiSpkwxHJUmSJEmSJHWS4ejYMHWkByBppeF8IKnH+UBSj/OBpB7nA2mAD2SSJEmSJEmS1EmuHJUkSZIkSZLUSYajkiRJkiRJkjrJcHSUS3JAkvlJ7k0yO8mkkR6TpBUrySuS/CDJH5JUkrcO1CfJkUluTnJPkplJNh6h4UpaQZIcluRXSe5OcnuSHybZZKCN84HUAUneneTKdj64O8msJDv11TsXSB2U5CPtvxem9JU5H0gDDEdHsSS7AScAnwY2By4GfpLk2SM6MEkr2urAHOC9wD1D1B8CHAwcBGwJ3Ab8NMkaj9kIJT0WJgNfBrYBXg08CJyX5Kl9bZwPpG64CTgU2AKYCJwPfC/Ji9t65wKpY5K8DNgPuHKgyvlAGuADmUaxJL8Erqyq/frKrgG+XVWHjdzIJD1WkiwEDqyqU9rrADcDU6rq6LbsSTR/9Hywqk4aqbFKWrGSrA7cBexcVT90PpC6LclfgMNonkztXCB1SJKnAJfRhKNHAHOq6kD/NpCG5srRUSrJqsBLgXMHqs6lWUEiqZueC6xN39xQVfcAP8e5QRrr1qD52+6O9tr5QOqgJOOS7E6z0+RinAukLppKs2jq/IFy5wNpCIajo9d4YBxw60D5rTSTnaRu6v3379wgdc8JwOXArPba+UDqkCSbtjtK7gO+CuxSVb/BuUDqlCT7ARsAhw9R7XwgDWGVkR6AltvguQgZokxS9zg3SB2S5PPAtsC2VfXQQLXzgdQNc4GXAP8EvBE4NcnkvnrnAmmMS/JCmmeSTKqq+/9BU+cDqY8rR0evPwEPsej/3ZnAov8XSFJ33NK+OjdIHZHkC8AewKur6vd9Vc4HUodU1f1VdW1VXdo+f+By4P04F0hdsjXNLtM5SR5M8iDwSuCA9v2f23bOB1Ifw9FRqv2/QLOB7QaqtqM5W0hSN82n+UfQ/88NSZ4ITMK5QRpzkpwA7EkTjF49UO18IHXb44An4Fwgdcn3gE1pVpH3fi4FvtG+n4fzgbQIt9WPbp8Hpie5BPgf4J3AujRnDEkao9onUm/QXj4OeHaSlwB/qaobkhwPfDTJ1TR/AH0MWAicOSIDlrRCJDkR2AfYGbgjSW8VyMKqWlhV5XwgdUOSzwAzgBtpHs62JzAZ2Mm5QOqOqroTuLO/LMlfaf6dMKe9dj6QBhiOjmJV9c0kT6OZzDkwMv4AAAaJSURBVNYB5gCvq6rrR3ZkklawicAFfdefaH9OBd4KHAs8CTgRWAv4JbB9VS14bIcpaQU7oH392UD5J4Aj2/fOB1I3rA2c3r7eBVwJvLaqzmnrnQsk9TgfSANS5Zm7kiRJkiRJkrrHM0clSZIkSZIkdZLhqCRJkiRJkqROMhyVJEmSJEmS1EmGo5IkSZIkSZI6yXBUkiRJkiRJUicZjkqSJEmSJEnqJMNRSZIkjSpJJiepJEeO9FhWdkmObH9Xk0d6LJIkSSsjw1FJkiRJkiRJnWQ4KkmSJEmSJKmTDEclSZIkSZIkdZLhqCRJksaEJM9MclWSvybZsa98+yTnJrkjyb1Jrkzy7iTpa3NEezbnzsP0fWJbv02Sp7fvvzbQZu+2/OaB8rWHab9Fku8l+VM7rquTHJ7kiQPtntPef0qSzZL8JMmdSe7oa7NGki8muSXJ35LMSvKaZftNSpIkdYfhqCRJkka9JBsAFwHrAttX1dlt+fuAc4BNgO8AX2lvmQJ8sa+LacDDwL5D9P0EYA9gblVdXFW3A1cBkweavrJ9XSfJC4Yov7Cvz1cBFwM7AjOA44GFwFHAjCTjhviaz2+/46rAVOC/277GtX0cBFwHnADcAPwY2GaIfiRJktRaZaQHIEmSJC2PJC+mCUAfB0yuqsvb8k2A42gCxddV1YK2fBXgm8CBSaZX1SVVdVOSs4HXJlm7qm7p+4idgbWAz/SVXQi8K8l6VXV9WzYZmNm+Tgbm9ZX37umFmf9F87f4pKqa1ZYH+DqwG/BO4MSBr7oN8JGqOmagfF9gUvud9qiqavt7M3DqP/rdSZIkdZ0rRyVJkjRqJdmGJnS8H9i2F4y23gGMAw7qBaMAVfUgcER7uVtf+5NpAst9Bj7mbcCDwGl9Zb1VoJPbcawLbAB8A5jLI6tFad/fWFXz2+ttgecC3+kFo+24CjiMZgXrW4b4un+kCXsH7QUUcHgvGG1NB64eor0kSZJarhyVJEnSaDUJ+BDNFvLtquqmgfqtgIeAXYY4S/Tx7esL+8p+CNxKE4Z+FiDJs4DtgB8NrCad2b5OplmdObmvfAtgp/b+CcCLaILKns3a1wsZUFXzk9wAvHjRr8sVVfXAEOUvBm6rqmsG+qokFwMbDnGPJEmSMByVJEnS6LU58GTgEuAPQ9Q/lWbl6BFD1PWs1ntTVQ8mOQU4NMnW7arOt9DstprWf1NV3ZpkLo+Eoq8E/lhVc5PMBPZvz0HdvK3vD0LXbF9vHWZMtwLPSfKEqrqvr/y2YdqvCfx2mLrh7pEkSRJuq5ckSdLoNYVmReabgS8PUX838ACwalVlmJ9XDdxzMs0W9be112+lCStnDNH/hTQh5no04eiFfeW0ZYs8jKkdF8AzhvlezwDuGwhGacc1lLuBpw9TN2GYckmSJGE4KkmSpNHrYZrw8kzgnUlOGKi/hGb7/BZL2mFVXUsTZO6WZAeac0Snt+eUDuoFnrvTbM+f2fZxM3ANjzyY6Q9tvz1XtK+vGOywDVr/ua/NkrgSmJDk+QN9Bdh6KfqRJEnqHMNRSZIkjVpV9TDNytFvAe9J8rm+6q/SnDl6Ynv2599Jsl6S5wzR7ck0W9V7W+mnDdEGHjl39OCBa2iC0x2BjVj0bNGLgPnArkm26htPgE/THAVwGkvuDCDAJ9s+evahOe9UkiRJw/DMUUmSJI1qVfVQkr1o/rb9QJL7q+qwqroiyfuALwLzkvwEuB4YT/OQom2APYHrBrr8DvAlYF1gVlUNeZ5nVd2c5Fqa1aW3VNXcvuqZwH+07y8cuO+hJG8HfgJcmOSbNE+i/1dgInA+TbC7pKbRBMS70WzzvwB4HrAz8FOaB0pJkiRpCK4clSRJ0qjXbnvfHfg+8OEkR7XlU2i2r58PvBr4APA6mi35hwDnDdHXvcC328vhVo329ILPmcOUD77vfcYFwMuBc4E3tONaE/g4sFNVPbSYz+3v6yGa7zSFJhR9L/DstuziJe1HkiSpi1I13LnukiRJUjcl+SWwMbBOVS0Y6fFIkiRpxXDlqCRJktQnydbAVsDXDUYlSZLGNleOSpIkSUCSPWnOIn0bMAHYtKrmjeyoJEmStCL5QCZJkiSpsT8wCfgdsKfBqCRJ0tjnylFJkiRJkiRJneSZo5IkSZIkSZI6yXBUkiRJkiRJUicZjkqSJEmSJEnqJMNRSZIkSZIkSZ1kOCpJkiRJkiSpkwxHJUmSJEmSJHXS/wG9SUPjUyXyHQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "figsize=(22, 5)\n", + "\n", + "ticksize = 14\n", + "titlesize = ticksize + 8\n", + "labelsize = ticksize + 5\n", + "\n", + "# xlabel = \"Train Feature\"\n", + "# ylabel = \"Null Count\"\n", + "\n", + "# title = \"Train Feature Null Count\"\n", + "\n", + "\n", + "params = {'figure.figsize' : figsize,\n", + " 'axes.labelsize' : labelsize,\n", + " 'axes.titlesize' : titlesize,\n", + " 'xtick.labelsize': ticksize,\n", + " 'ytick.labelsize': ticksize}\n", + "\n", + "plt.rcParams.update(params)\n", + "\n", + "kw = df_train.keyword.value_counts().head(10)\n", + "kw_d = df_train[df_train.target==1].keyword.value_counts().head(10)\n", + "kw_nd = df_train[df_train.target==0].keyword.value_counts().head(10)\n", + "\n", + "# plt.figure(figsize=(13,5))\n", + "sns.barplot(kw, kw.index)\n", + "plt.title('Top keywords for tweets')\n", + "plt.show()\n", + "plt.subplot(121)\n", + "sns.barplot(kw_d, kw_d.index)\n", + "plt.title('Top keywords for disaster tweets')\n", + "plt.subplot(122)\n", + "sns.barplot(kw_nd, kw_nd.index)\n", + "plt.title('Top keywords for non-disaster tweets')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Top locations for tweets" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "figsize=(22, 5)\n", + "\n", + "ticksize = 14\n", + "titlesize = ticksize + 8\n", + "labelsize = ticksize + 5\n", + "\n", + "# xlabel = \"Train Feature\"\n", + "# ylabel = \"Null Count\"\n", + "\n", + "# title = \"Train Feature Null Count\"\n", + "\n", + "\n", + "params = {'figure.figsize' : figsize,\n", + " 'axes.labelsize' : labelsize,\n", + " 'axes.titlesize' : titlesize,\n", + " 'xtick.labelsize': ticksize,\n", + " 'ytick.labelsize': ticksize}\n", + "\n", + "plt.rcParams.update(params)\n", + "\n", + "kw = df_train.location.value_counts().head(10)\n", + "kw_d = df_train[df_train.target==1].location.value_counts().head(10)\n", + "kw_nd = df_train[df_train.target==0].location.value_counts().head(10)\n", + "\n", + "# plt.figure(figsize=(13,5))\n", + "sns.barplot(kw, kw.index)\n", + "plt.title('Top locations for tweets')\n", + "plt.show()\n", + "plt.subplot(121)\n", + "sns.barplot(kw_d, kw_d.index)\n", + "plt.title('Top locations for disaster tweets')\n", + "plt.subplot(122)\n", + "sns.barplot(kw_nd, kw_nd.index)\n", + "plt.title('Top locations for non-disaster tweets')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 4. Feature Extraction" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idkeywordlocationtexttargettext_lenword_countunique_word_counthash_countmention_count
01NaNNaNOur Deeds are the Reason of this #earthquake M...169131310
14NaNNaNForest fire near La Ronge Sask. Canada1387700
25NaNNaNAll residents asked to 'shelter in place' are ...1133222000
36NaNNaN13,000 people receive #wildfires evacuation or...1658810
47NaNNaNJust got sent this photo from Ruby #Alaska as ...188161520
\n", + "
" + ], + "text/plain": [ + " id keyword location text \\\n", + "0 1 NaN NaN Our Deeds are the Reason of this #earthquake M... \n", + "1 4 NaN NaN Forest fire near La Ronge Sask. Canada \n", + "2 5 NaN NaN All residents asked to 'shelter in place' are ... \n", + "3 6 NaN NaN 13,000 people receive #wildfires evacuation or... \n", + "4 7 NaN NaN Just got sent this photo from Ruby #Alaska as ... \n", + "\n", + " target text_len word_count unique_word_count hash_count mention_count \n", + "0 1 69 13 13 1 0 \n", + "1 1 38 7 7 0 0 \n", + "2 1 133 22 20 0 0 \n", + "3 1 65 8 8 1 0 \n", + "4 1 88 16 15 2 0 " + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Tweet length\n", + "df_train['text_len'] = df_train['text'].apply(len)\n", + "df_test['text_len'] = df_test['text'].apply(len)\n", + "# Word count\n", + "df_train[\"word_count\"] = df_train[\"text\"].apply(lambda x: len(str(x).split()))\n", + "df_test[\"word_count\"] = df_test[\"text\"].apply(lambda x: len(str(x).split()))\n", + "# Unique word count\n", + "df_train[\"unique_word_count\"] = df_train[\"text\"].apply(lambda x: len(set(str(x).split())))\n", + "df_test[\"unique_word_count\"] = df_test[\"text\"].apply(lambda x: len(set(str(x).split())))\n", + "# Count of hashtags (#)\n", + "df_train['hash_count'] = df_train['text'].apply(lambda x: str(x).count(\"#\"))\n", + "df_test['hash_count'] = df_test['text'].apply(lambda x: str(x).count(\"#\"))\n", + "# Count of mentions (@)\n", + "df_train['mention_count'] = df_train['text'].apply(lambda x: str(x).count(\"@\"))\n", + "df_test['mention_count'] = df_test['text'].apply(lambda x: str(x).count(\"@\"))\n", + "\n", + "df_train.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idkeywordlocationtexttext_lenword_countunique_word_counthash_countmention_counttarget
01NaNNaNOur Deeds are the Reason of this #earthquake M...691313101
14NaNNaNForest fire near La Ronge Sask. Canada3877001
25NaNNaNAll residents asked to 'shelter in place' are ...1332220001
36NaNNaN13,000 people receive #wildfires evacuation or...6588101
47NaNNaNJust got sent this photo from Ruby #Alaska as ...881615201
\n", + "
" + ], + "text/plain": [ + " id keyword location text \\\n", + "0 1 NaN NaN Our Deeds are the Reason of this #earthquake M... \n", + "1 4 NaN NaN Forest fire near La Ronge Sask. Canada \n", + "2 5 NaN NaN All residents asked to 'shelter in place' are ... \n", + "3 6 NaN NaN 13,000 people receive #wildfires evacuation or... \n", + "4 7 NaN NaN Just got sent this photo from Ruby #Alaska as ... \n", + "\n", + " text_len word_count unique_word_count hash_count mention_count target \n", + "0 69 13 13 1 0 1 \n", + "1 38 7 7 0 0 1 \n", + "2 133 22 20 0 0 1 \n", + "3 65 8 8 1 0 1 \n", + "4 88 16 15 2 0 1 " + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_train = df_train[['id', 'keyword', 'location', 'text', 'text_len', 'word_count',\n", + " 'unique_word_count', 'hash_count', 'mention_count', 'target']]\n", + "df_train.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lets see" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idkeywordlocationtexttext_lenword_countunique_word_counthash_countmention_count
00NaNNaNJust happened a terrible car crash346600
12NaNNaNHeard about #earthquake is different cities, s...649910
23NaNNaNthere is a forest fire at spot pond, geese are...96191900
39NaNNaNApocalypse lighting. #Spokane #wildfires404420
411NaNNaNTyphoon Soudelor kills 28 in China and Taiwan458800
\n", + "
" + ], + "text/plain": [ + " id keyword location text \\\n", + "0 0 NaN NaN Just happened a terrible car crash \n", + "1 2 NaN NaN Heard about #earthquake is different cities, s... \n", + "2 3 NaN NaN there is a forest fire at spot pond, geese are... \n", + "3 9 NaN NaN Apocalypse lighting. #Spokane #wildfires \n", + "4 11 NaN NaN Typhoon Soudelor kills 28 in China and Taiwan \n", + "\n", + " text_len word_count unique_word_count hash_count mention_count \n", + "0 34 6 6 0 0 \n", + "1 64 9 9 1 0 \n", + "2 96 19 19 0 0 \n", + "3 40 4 4 2 0 \n", + "4 45 8 8 0 0 " + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_test.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idkeywordlocationtexttext_modifiedtext_lenword_countunique_word_counthash_countmention_counttarget
01NaNNaNOur Deeds are the Reason of this #earthquake M...Our Deeds are the Reason of this #earthquake M...691313101
14NaNNaNForest fire near La Ronge Sask. CanadaForest fire near La Ronge Sask . Canada3877001
25NaNNaNAll residents asked to 'shelter in place' are ...All residents asked to ' shelter in place ' ar...1332220001
36NaNNaN13,000 people receive #wildfires evacuation or...13 , 0 0 0 people receive #wildfires evacuatio...6588101
47NaNNaNJust got sent this photo from Ruby #Alaska as ...Just got sent this photo from Ruby #Alaska as ...881615201
\n", + "
" + ], + "text/plain": [ + " id keyword location text \\\n", + "0 1 NaN NaN Our Deeds are the Reason of this #earthquake M... \n", + "1 4 NaN NaN Forest fire near La Ronge Sask. Canada \n", + "2 5 NaN NaN All residents asked to 'shelter in place' are ... \n", + "3 6 NaN NaN 13,000 people receive #wildfires evacuation or... \n", + "4 7 NaN NaN Just got sent this photo from Ruby #Alaska as ... \n", + "\n", + " text_modified text_len word_count \\\n", + "0 Our Deeds are the Reason of this #earthquake M... 69 13 \n", + "1 Forest fire near La Ronge Sask . Canada 38 7 \n", + "2 All residents asked to ' shelter in place ' ar... 133 22 \n", + "3 13 , 0 0 0 people receive #wildfires evacuatio... 65 8 \n", + "4 Just got sent this photo from Ruby #Alaska as ... 88 16 \n", + "\n", + " unique_word_count hash_count mention_count target \n", + "0 13 1 0 1 \n", + "1 7 0 0 1 \n", + "2 20 0 0 1 \n", + "3 8 1 0 1 \n", + "4 15 2 0 1 " + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Tweet length\n", + "df_train['text_modified'] = df_train['text']\n", + "df_train['text_modified'] = df_train['text_modified'].apply(lambda x: re.sub(r\"(%20)\", r\" \", x, flags=re.MULTILINE))\n", + "df_train['text_modified'] = df_train['text_modified'].apply(lambda x: re.sub(r'^https?:\\/\\/.*[\\r\\n]*', 'http://', x, flags=re.MULTILINE))\n", + "df_train['text_modified'] = df_train['text_modified'].apply(lambda x: re.sub(r\"([^a-zA-Z1-9#])\", r\" \\1 \", x, flags=re.MULTILINE))\n", + "df_train['text_modified'] = df_train['text_modified'].apply(lambda x: re.sub(r\"\\s+\", \" \", x, flags=re.MULTILINE))\n", + "\n", + "\n", + "df_train = df_train[['id', 'keyword', 'location', 'text', 'text_modified', 'text_len', 'word_count',\n", + " 'unique_word_count', 'hash_count', 'mention_count', 'target']]\n", + "df_train.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 : @ Camilla _ 33 @ CrayKain Hate to shatter your delusions but a hatchet is a deadly weapon justifying lethal force . #gunsense\n", + "1 : Thu Aug 0 6 2 0 15 0 1 : 2 0 : 32 GMT + 0 0 0 0 ( UTC ) #millcityio #2 0 15 0 613 theramin sirens\n", + "1 : @ Bill _ Roose That looks so desolate and just . . . depressing\n", + "0 : @ nprfreshair I really can ' t believe he is skipping out before the Republican meltdown . . . I mean ' debate ' . \n", + "0 : @ RaynbowAffair Editor In Chief @ DiamondKesawn Releases Issue #7 http : / / t . co / 7mzYcU2IHo of #RAmag . #Fashion #Models and #Mayhem\n", + "1 : California man facing manslaughter charge in Sunday ' s wrong - way fatal crash in . . . - http : / / t . co / 1vz3RmjHy4 : Ca . . . http : / / t . co / xevUEEfQBZ\n", + "0 : Yay for sirens\n", + "1 : Udhampur terror attack : Militants attack police post 2 SPOs injured : Suspected militants tonight attacked a p . . . http : / / t . co / FPhFESemyJ\n", + "1 : A Look at State Actions a Year After #Ferguson ' s Upheaval http : / / t . co / qwSbVfLPE1\n", + "0 : ' Education is the most powerful weapon which you can use to change the world . ' Nelson #Mandela #quote http : / / t . co / QR1L2JYUEZ\n" + ] + } + ], + "source": [ + "for i in range(10):\n", + " r = random.randrange(len(df_train)-1)\n", + " print(df_train.target[r], \" : \", df_train.text_modified\t[r])" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "# from sklearn.model_selection import train_test_split\n", + "\n", + "X_train, X_test, y_train, y_test = train_test_split(df_train.loc[:,'id':'mention_count'], df_train['target'], test_size=0.2, random_state=0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Training Model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4.1 Gaussian Naive Bayes and TFIDF Vectorizer " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 4.1.1 Original Text\n", + "Using Gassuan Naive Bayes, as machine learning algorithm and TFIDF vectorizer on original text" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of mislabeled points out of a total 1523 points : 359\n", + "Percentage of Correct points : 76.43\n" + ] + } + ], + "source": [ + "from sklearn.naive_bayes import GaussianNB\n", + "\n", + "vectorizer = TfidfVectorizer(\n", + "# input='content', \n", + "# encoding='utf-8', \n", + "# decode_error='strict', \n", + "# strip_accents=None, \n", + "# lowercase=False,\n", + "# preprocessor=None,\n", + "# tokenizer=None, \n", + "# analyzer='word',\n", + " stop_words=None, \n", + " ngram_range=(1, 2), \n", + " max_df=0.6, \n", + " min_df=4, \n", + " max_features=None, \n", + "# vocabulary=None, \n", + "# binary=False, \n", + " norm='l2', \n", + " use_idf=True, \n", + " smooth_idf=True,\n", + " sublinear_tf=True\n", + ")\n", + "\n", + "X_train_tf = vectorizer.fit_transform(X_train.text.tolist()).toarray()\n", + "y_train = y_train\n", + "\n", + "# print(train_X.shape)\n", + "# print(len(Y_train))\n", + "\n", + "\n", + "############################\n", + "\n", + "gnb = GaussianNB()\n", + "\n", + "X_test_tf = vectorizer.transform(X_test.text.tolist()).toarray()\n", + "\n", + "y_pred = gnb.fit(X_train_tf, y_train).predict(X_test_tf)\n", + "\n", + "print(\"Number of mislabeled points out of a total %d points : %d\" % (X_test.shape[0], (y_test != y_pred).sum()))\n", + "print(\"Percentage of Correct points : %.2f\" % (100-((y_test != y_pred).sum())/(len(y_test))*100))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 4.1.2 Modified Text\n", + "Using Gassuan Naive Bayes, as machine learning algorithm and TFIDF vectorizer on modified text" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of mislabeled points out of a total 1523 points : 379\n", + "Percentage of Correct points : 75.11\n" + ] + } + ], + "source": [ + "from sklearn.naive_bayes import GaussianNB\n", + "\n", + "vectorizer = TfidfVectorizer(\n", + "# input='content', \n", + "# encoding='utf-8', \n", + "# decode_error='strict', \n", + "# strip_accents=None, \n", + " lowercase=False,\n", + "# preprocessor=None,\n", + "# tokenizer=None, \n", + "# analyzer='word',\n", + " stop_words=None, \n", + " ngram_range=(1, 2), \n", + " max_df=.6, \n", + " min_df=4, \n", + " max_features=None, \n", + "# vocabulary=None, \n", + "# binary=False, \n", + " norm='l2', \n", + " use_idf=True, \n", + " smooth_idf=True,\n", + " sublinear_tf=True\n", + ")\n", + "\n", + "X_train_tf = vectorizer.fit_transform(X_train.text_modified.tolist()).toarray()\n", + "y_train = y_train\n", + "\n", + "# print(train_X.shape)\n", + "# print(len(Y_train))\n", + "\n", + "\n", + "############################\n", + "\n", + "gnb = GaussianNB()\n", + "\n", + "X_test_tf = vectorizer.transform(X_test.text_modified.tolist()).toarray()\n", + "\n", + "y_pred = gnb.fit(X_train_tf, y_train).predict(X_test_tf)\n", + "\n", + "print(\"Number of mislabeled points out of a total %d points : %d\" % (X_test.shape[0], (y_test != y_pred).sum()))\n", + "print(\"Percentage of Correct points : %.2f\" % (100-((y_test != y_pred).sum())/(len(y_test))*100))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4.2 Logistic Regression of derived numerical features" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "macro: 0.5968089777364534\n", + "micro: 0.6231122783978988\n", + "weighted: 0.6136457948693581\n", + "None: [0.69979079 0.49382716]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/conda/lib/python3.6/site-packages/sklearn/linear_model/logistic.py:432: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n", + " FutureWarning)\n" + ] + } + ], + "source": [ + "# Most stupid model: Just to test submission\n", + "from sklearn.linear_model import LogisticRegression\n", + "\n", + "\n", + "X_train_at = X_train.loc[:,'text_len':'mention_count']\n", + "X_test_at = X_test.loc[:,'text_len':'mention_count']\n", + "\n", + "\n", + "model = LogisticRegression()\n", + "model.fit(X_train_at, y_train)\n", + "y_pred = model.predict(X_test_at)\n", + "\n", + "from sklearn.metrics import f1_score\n", + "print('macro: ', f1_score(y_test, y_pred, average='macro'))\n", + "print('micro: ', f1_score(y_test, y_pred, average='micro'))\n", + "print('weighted: ', f1_score(y_test, y_pred, average='weighted'))\n", + "print('None: ', f1_score(y_test, y_pred, average=None))\n", + "# f1_score(y_test, y_pred, zero_division=1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "_uuid": "63bd6eb6b6e61629f6584772897655d98fa4253e" + }, + "source": [ + "## 4.3. Deep Learning" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "_uuid": "727e5f0c3130d2df7403d96c743c8d4f4c3b7c4d" + }, + "source": [ + "### 4.3.1 Output Configuration" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "_uuid": "c8703accc04a96fda2e561b6e66e474a23dde81a" + }, + "outputs": [], + "source": [ + "main_model_dir = output_directory + r\"models/\"\n", + "main_log_dir = output_directory + r\"logs/\"\n", + "\n", + "try:\n", + " os.mkdir(main_model_dir)\n", + "except:\n", + " print(\"Could not create main model directory\")\n", + " \n", + "try:\n", + " os.mkdir(main_log_dir)\n", + "except:\n", + " print(\"Could not create main log directory\")\n", + "\n", + "\n", + "\n", + "model_dir = main_model_dir + time.strftime('%Y-%m-%d %H-%M-%S') + \"/\"\n", + "log_dir = main_log_dir + time.strftime('%Y-%m-%d %H-%M-%S')\n", + "\n", + "\n", + "try:\n", + " os.mkdir(model_dir)\n", + "except:\n", + " print(\"Could not create model directory\")\n", + " \n", + "try:\n", + " os.mkdir(log_dir)\n", + "except:\n", + " print(\"Could not create log directory\")\n", + " \n", + "model_file = model_dir + \"{epoch:02d}-val_acc-{val_acc:.2f}-val_loss-{val_loss:.2f}.hdf5\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 4.3.2 Callback Settings" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "_uuid": "0eeca633f28358dbfafd3db7fd22518fc77a276a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Settting Callbacks\n", + "Set Callbacks at Timestamp: 2020-01-30 08:14:01\n" + ] + } + ], + "source": [ + "print(\"Settting Callbacks\")\n", + "\n", + "checkpoint = ModelCheckpoint(\n", + " model_file, \n", + " monitor='val_accuracy', \n", + " save_best_only=True)\n", + "\n", + "early_stopping = EarlyStopping(\n", + " monitor='val_loss',\n", + " patience=5,\n", + " verbose=1,\n", + " restore_best_weights=True)\n", + "\n", + "\n", + "reduce_lr = ReduceLROnPlateau(\n", + " monitor='val_loss',\n", + " factor=0.5,\n", + " patience=2,\n", + " verbose=1)\n", + "\n", + "\n", + "# callbacks = [checkpoint, reduce_lr, early_stopping]\n", + "\n", + "callbacks = [reduce_lr, early_stopping]\n", + "\n", + "print(\"Set Callbacks at \", date_time(1))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "_uuid": "42410b8507438ce15c28b5e9778908515dfaeb51" + }, + "source": [ + "### 4.3.3. Preprocessing" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "# Calculate Class Weights\n", + "def get_weight(y):\n", + " class_weight_current = cw.compute_class_weight('balanced', np.unique(y), y)\n", + " return class_weight_current" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "_uuid": "c97ce5c809f58080f13ab1da76fbeff96817a321" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1 1 1 ... 1 1 1]\n", + "[[0. 1.]\n", + " [0. 1.]\n", + " [0. 1.]\n", + " ...\n", + " [0. 1.]\n", + " [0. 1.]\n", + " [0. 1.]]\n" + ] + }, + { + "data": { + "text/plain": [ + "array([[0., 1.],\n", + " [0., 1.],\n", + " [0., 1.],\n", + " ...,\n", + " [0., 1.],\n", + " [0., 1.],\n", + " [0., 1.]], dtype=float32)" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X = df_train.text\n", + "Y = df_train.target\n", + "\n", + "label_encoder = LabelEncoder()\n", + "\n", + "Y = label_encoder.fit_transform(Y)\n", + "print(Y)\n", + "Y = to_categorical(Y)\n", + "print(Y)\n", + "# Y = Y.reshape(-1, 1)\n", + "Y" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "_uuid": "972b31926122af0747be40fa2b5d3bf14dcbe16a" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(28366, 157)" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.15)\n", + "\n", + "max_words = len(set(\" \".join(X_train).split()))\n", + "max_len = X_train.apply(lambda x: len(x)).max()\n", + "\n", + "# max_words = 1000\n", + "# max_len = 150\n", + "max_words, max_len" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "_uuid": "6f82546a785e1eba0e6df397078497dffc94e902" + }, + "outputs": [], + "source": [ + "tokenizer = Tokenizer(num_words=max_words)\n", + "\n", + "tokenizer.fit_on_texts(X_train)\n", + "\n", + "X_train_seq = tokenizer.texts_to_sequences(X_train)\n", + "X_train_seq = sequence.pad_sequences(X_train_seq, maxlen=max_len)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "_uuid": "15756f1979d321902f18964c00c515fb31342613" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.87540584, 1.16594595])" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "class_weight = get_weight(np.argmax(Y_train ,axis=1))\n", + "class_weight" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "_uuid": "19a3f4532b9398234b6f78e758688d7903d6b66b" + }, + "source": [ + "### 4.3.4. Model" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "_uuid": "ffc3ae3a4fb844cd20a9cb33750de42b2c71392d" + }, + "outputs": [], + "source": [ + "# def get_rnn_model(num_class=2):\n", + "# model = Sequential()\n", + " \n", + "# model.add(Embedding(max_words, 100, input_length=max_len))\n", + "# model.add(LSTM(256))\n", + " \n", + "# model.add(Dropout(0.5))\n", + "# model.add(BatchNormalization())\n", + "# model.add(Dropout(0.5))\n", + " \n", + "# model.add(Dense(512, activation='relu'))\n", + " \n", + "# model.add(Dropout(0.5))\n", + "# model.add(BatchNormalization())\n", + "# model.add(Dropout(0.5))\n", + " \n", + "# if num_class>=2:\n", + "# model.add(Dense(num_class, activation='softmax'))\n", + "# else:\n", + "# model.add(Dense(1, activation='sigmoid'))\n", + " \n", + "# model.summary()\n", + " \n", + "# return model\n", + "\n", + "def get_rnn_model(num_class=2):\n", + " model = Sequential()\n", + " \n", + " model.add(Embedding(max_words, 100, input_length=max_len))\n", + " \n", + " model.add(Dropout(0.2))\n", + " model.add(Bidirectional(LSTM(256)))\n", + " model.add(Dropout(0.2))\n", + " \n", + " model.add(Dense(512, activation='relu'))\n", + " \n", + " model.add(Dropout(0.5))\n", + " model.add(BatchNormalization())\n", + " \n", + " if num_class>=2:\n", + " model.add(Dense(num_class, activation='softmax'))\n", + " else:\n", + " model.add(Dense(1, activation='sigmoid'))\n", + " \n", + " model.summary()\n", + " \n", + " return model\n", + "\n", + "\n", + "def get_cnn_model(num_class=2): \n", + " model = Sequential()\n", + " \n", + " model.add(Embedding(max_words, 100, input_length=max_len))\n", + " \n", + " model.add(Conv1D(1024, 3, padding='valid', activation='relu', strides=1))\n", + " model.add(GlobalMaxPooling1D())\n", + " \n", + " \n", + " model.add(Dropout(0.5))\n", + " model.add(BatchNormalization())\n", + " model.add(Dropout(0.5))\n", + " \n", + " model.add(Dense(2048, activation='relu'))\n", + " \n", + " model.add(Dropout(0.5))\n", + " model.add(BatchNormalization())\n", + " model.add(Dropout(0.5))\n", + " \n", + " if num_class>=2:\n", + " model.add(Dense(num_class, activation='softmax'))\n", + " else:\n", + " model.add(Dense(1, activation='sigmoid'))\n", + " \n", + " model.summary()\n", + " return model" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "_uuid": "a5472569b1c7c8f13fe14c9dcac3a7957db1300e" + }, + "outputs": [], + "source": [ + "def plot_performance(history=None, figure_directory=None):\n", + " xlabel = 'Epoch'\n", + " legends = ['Training', 'Validation']\n", + "\n", + "# ylim_pad = [0.1, 0.005]\n", + " ylim_pad = [0, 0.5]\n", + "\n", + "\n", + " plt.figure(figsize=(20, 5))\n", + "\n", + " # Plot training & validation Accuracy values\n", + "\n", + " y1 = history.history['accuracy']\n", + " y2 = history.history['val_accuracy']\n", + "\n", + " min_y = min(min(y1), min(y2))-ylim_pad[0]\n", + " max_y = max(max(y1), max(y2))+ylim_pad[0]\n", + " \n", + " min_y = 0\n", + " max_y = 1\n", + "\n", + "\n", + " plt.subplot(121)\n", + "\n", + " plt.plot(y1)\n", + " plt.plot(y2)\n", + "\n", + " plt.title('Model Accuracy\\n'+date_time(1), fontsize=17)\n", + " plt.xlabel(xlabel, fontsize=15)\n", + " plt.ylabel('Accuracy', fontsize=15)\n", + " plt.ylim(min_y, max_y)\n", + " plt.legend(legends, loc='upper left')\n", + " plt.grid()\n", + "\n", + "\n", + " # Plot training & validation loss values\n", + "\n", + " y1 = history.history['loss']\n", + " y2 = history.history['val_loss']\n", + "\n", + " min_y = min(min(y1), min(y2))-ylim_pad[1]\n", + " max_y = max(max(y1), max(y2))+ylim_pad[1]\n", + "\n", + "# min_y = 0\n", + "# max_y = .8\n", + "\n", + " plt.subplot(122)\n", + "\n", + " plt.plot(y1)\n", + " plt.plot(y2)\n", + "\n", + " plt.title('Model Loss\\n'+date_time(1), fontsize=17)\n", + " plt.xlabel(xlabel, fontsize=15)\n", + " plt.ylabel('Loss', fontsize=15)\n", + " plt.ylim(min_y, max_y)\n", + " plt.legend(legends, loc='upper left')\n", + " plt.grid()\n", + " \n", + " if figure_directory:\n", + " plt.savefig(figure_directory+\"/history\")\n", + "\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "_uuid": "b424eb9a6e314ef397df89dcfeffc4c9c15839ee" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"sequential_1\"\n", + "_________________________________________________________________\n", + "Layer (type) Output Shape Param # \n", + "=================================================================\n", + "embedding_1 (Embedding) (None, 157, 100) 2836600 \n", + "_________________________________________________________________\n", + "dropout_1 (Dropout) (None, 157, 100) 0 \n", + "_________________________________________________________________\n", + "bidirectional_1 (Bidirection (None, 512) 731136 \n", + "_________________________________________________________________\n", + "dropout_2 (Dropout) (None, 512) 0 \n", + "_________________________________________________________________\n", + "dense_1 (Dense) (None, 512) 262656 \n", + "_________________________________________________________________\n", + "dropout_3 (Dropout) (None, 512) 0 \n", + "_________________________________________________________________\n", + "batch_normalization_1 (Batch (None, 512) 2048 \n", + "_________________________________________________________________\n", + "dense_2 (Dense) (None, 2) 1026 \n", + "=================================================================\n", + "Total params: 3,833,466\n", + "Trainable params: 3,832,442\n", + "Non-trainable params: 1,024\n", + "_________________________________________________________________\n" + ] + } + ], + "source": [ + "num_class = 2\n", + "model1 = get_rnn_model(num_class=num_class)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "_uuid": "72903b1167548759e416d9b8ba643fdf90305e06" + }, + "outputs": [], + "source": [ + "loss = 'categorical_crossentropy'\n", + "# loss = 'binary_crossentropy'\n", + "metrics = ['accuracy']" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "_uuid": "2bd1166ccac602ca7d908e9f9b17c8ffb2a1f92c" + }, + "source": [ + "### 4.3.5 Model Trainning" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "_uuid": "a1ce715c032b60131950b0946776b41040ec97f4" + }, + "source": [ + "#### 4.3.5.1 RNN" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "_uuid": "3499506821ecfcfa499a1195742796152939cc94" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting...\n", + "\n", + "Timestamp: 2020-01-30 08:14:06\n", + "\n", + "\n", + "Compliling Model ...\n", + "\n", + "Trainning Model ...\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/conda/lib/python3.6/site-packages/tensorflow_core/python/framework/indexed_slices.py:433: UserWarning: Converting sparse IndexedSlices to a dense Tensor of unknown shape. This may consume a large amount of memory.\n", + " \"Converting sparse IndexedSlices to a dense Tensor of unknown shape. \"\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train on 5176 samples, validate on 1295 samples\n", + "Epoch 1/100\n", + "5176/5176 [==============================] - 96s 19ms/step - loss: 0.6403 - accuracy: 0.6285 - val_loss: 0.6457 - val_accuracy: 0.5807\n", + "Epoch 2/100\n", + "5176/5176 [==============================] - 94s 18ms/step - loss: 0.4553 - accuracy: 0.7960 - val_loss: 0.4862 - val_accuracy: 0.7792\n", + "Epoch 3/100\n", + "5176/5176 [==============================] - 94s 18ms/step - loss: 0.3238 - accuracy: 0.8644 - val_loss: 0.5362 - val_accuracy: 0.7776\n", + "Epoch 4/100\n", + "5176/5176 [==============================] - 94s 18ms/step - loss: 0.2323 - accuracy: 0.9042 - val_loss: 0.7195 - val_accuracy: 0.7575\n", + "\n", + "Epoch 00004: ReduceLROnPlateau reducing learning rate to 4.999999873689376e-05.\n", + "Epoch 5/100\n", + "5176/5176 [==============================] - 94s 18ms/step - loss: 0.1582 - accuracy: 0.9397 - val_loss: 0.8979 - val_accuracy: 0.6903\n", + "Epoch 6/100\n", + "5176/5176 [==============================] - 94s 18ms/step - loss: 0.1274 - accuracy: 0.9507 - val_loss: 0.8110 - val_accuracy: 0.7483\n", + "\n", + "Epoch 00006: ReduceLROnPlateau reducing learning rate to 2.499999936844688e-05.\n", + "Epoch 7/100\n", + "5176/5176 [==============================] - 95s 18ms/step - loss: 0.1064 - accuracy: 0.9614 - val_loss: 0.8494 - val_accuracy: 0.7367\n", + "Restoring model weights from the end of the best epoch\n", + "Epoch 00007: early stopping\n", + "\n", + "Elapsed Time: 00:11:02\n", + "Completed Model Trainning Timestamp: 2020-01-30 08:25:08\n" + ] + } + ], + "source": [ + "print(\"Starting...\\n\")\n", + "\n", + "start_time = time.time()\n", + "print(date_time(1))\n", + "\n", + "print(\"\\n\\nCompliling Model ...\\n\")\n", + "learning_rate = 0.0001\n", + "optimizer = Adam(learning_rate)\n", + "# optimizer = Adam()\n", + "\n", + "model1.compile(optimizer=optimizer, loss=loss, metrics=metrics)\n", + "\n", + "verbose = 1\n", + "epochs = 100\n", + "batch_size = 16\n", + "validation_split = 0.2\n", + "\n", + "print(\"Trainning Model ...\\n\")\n", + "\n", + "history1 = model1.fit(\n", + " X_train_seq,\n", + " Y_train,\n", + " batch_size=batch_size,\n", + " epochs=epochs,\n", + " verbose=verbose,\n", + " callbacks=callbacks,\n", + " validation_split=validation_split,\n", + " class_weight=class_weight\n", + " )\n", + "\n", + "elapsed_time = time.time() - start_time\n", + "elapsed_time = time.strftime(\"%H:%M:%S\", time.gmtime(elapsed_time))\n", + "\n", + "print(\"\\nElapsed Time: \" + elapsed_time)\n", + "print(\"Completed Model Trainning\", date_time(1))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "_uuid": "174b2e76795372f6e7d09d6fa48579f782609b78" + }, + "source": [ + "##### 4.3.5.1.2 Visualization" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "_uuid": "5e6865d7574bb08bfc6e20ce51c8c0a6ab39ef4c" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_performance(history=history1)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "_uuid": "29bb4e66b2f030e88d88ca12d48209a93991647c" + }, + "source": [ + "#### 4.3.5.2. CNN" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "_uuid": "106063a66e2031658fd6649c2bc68ff54a2d6e9a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"sequential_2\"\n", + "_________________________________________________________________\n", + "Layer (type) Output Shape Param # \n", + "=================================================================\n", + "embedding_2 (Embedding) (None, 157, 100) 2836600 \n", + "_________________________________________________________________\n", + "conv1d_1 (Conv1D) (None, 155, 1024) 308224 \n", + "_________________________________________________________________\n", + "global_max_pooling1d_1 (Glob (None, 1024) 0 \n", + "_________________________________________________________________\n", + "dropout_4 (Dropout) (None, 1024) 0 \n", + "_________________________________________________________________\n", + "batch_normalization_2 (Batch (None, 1024) 4096 \n", + "_________________________________________________________________\n", + "dropout_5 (Dropout) (None, 1024) 0 \n", + "_________________________________________________________________\n", + "dense_3 (Dense) (None, 2048) 2099200 \n", + "_________________________________________________________________\n", + "dropout_6 (Dropout) (None, 2048) 0 \n", + "_________________________________________________________________\n", + "batch_normalization_3 (Batch (None, 2048) 8192 \n", + "_________________________________________________________________\n", + "dropout_7 (Dropout) (None, 2048) 0 \n", + "_________________________________________________________________\n", + "dense_4 (Dense) (None, 2) 4098 \n", + "=================================================================\n", + "Total params: 5,260,410\n", + "Trainable params: 5,254,266\n", + "Non-trainable params: 6,144\n", + "_________________________________________________________________\n" + ] + } + ], + "source": [ + "num_class = 2\n", + "model2 = get_cnn_model(num_class=num_class)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "_uuid": "f15fae20f343530b2e83e9c890fe674fc0d3ea1a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting...\n", + "\n", + "Timestamp: 2020-01-30 08:25:10\n", + "\n", + "\n", + "Compliling Model ...\n", + "\n", + "Trainning Model ...\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/conda/lib/python3.6/site-packages/tensorflow_core/python/framework/indexed_slices.py:433: UserWarning: Converting sparse IndexedSlices to a dense Tensor of unknown shape. This may consume a large amount of memory.\n", + " \"Converting sparse IndexedSlices to a dense Tensor of unknown shape. \"\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train on 5176 samples, validate on 1295 samples\n", + "Epoch 1/100\n", + "5176/5176 [==============================] - 7s 1ms/step - loss: 1.2181 - accuracy: 0.5189 - val_loss: 0.7872 - val_accuracy: 0.4270\n", + "Epoch 2/100\n", + "5176/5176 [==============================] - 3s 574us/step - loss: 1.1197 - accuracy: 0.5526 - val_loss: 0.7037 - val_accuracy: 0.5784\n", + "Epoch 3/100\n", + "5176/5176 [==============================] - 3s 580us/step - loss: 1.0146 - accuracy: 0.5767 - val_loss: 0.6748 - val_accuracy: 0.6255\n", + "Epoch 4/100\n", + "5176/5176 [==============================] - 3s 579us/step - loss: 0.9761 - accuracy: 0.5852 - val_loss: 0.6368 - val_accuracy: 0.6394\n", + "Epoch 5/100\n", + "5176/5176 [==============================] - 3s 571us/step - loss: 0.8764 - accuracy: 0.6086 - val_loss: 0.6256 - val_accuracy: 0.6425\n", + "Epoch 6/100\n", + "5176/5176 [==============================] - 3s 565us/step - loss: 0.8392 - accuracy: 0.6190 - val_loss: 0.6117 - val_accuracy: 0.6502\n", + "Epoch 7/100\n", + "5176/5176 [==============================] - 3s 592us/step - loss: 0.7346 - accuracy: 0.6528 - val_loss: 0.5723 - val_accuracy: 0.6842\n", + "Epoch 8/100\n", + "5176/5176 [==============================] - 4s 701us/step - loss: 0.6582 - accuracy: 0.7031 - val_loss: 0.5310 - val_accuracy: 0.7320\n", + "Epoch 9/100\n", + "5176/5176 [==============================] - 3s 603us/step - loss: 0.5772 - accuracy: 0.7344 - val_loss: 0.5211 - val_accuracy: 0.7475\n", + "Epoch 10/100\n", + "5176/5176 [==============================] - 3s 641us/step - loss: 0.4970 - accuracy: 0.7734 - val_loss: 0.5228 - val_accuracy: 0.7552\n", + "Epoch 11/100\n", + "5176/5176 [==============================] - 3s 576us/step - loss: 0.4468 - accuracy: 0.8058 - val_loss: 0.5314 - val_accuracy: 0.7506\n", + "\n", + "Epoch 00011: ReduceLROnPlateau reducing learning rate to 4.999999873689376e-05.\n", + "Epoch 12/100\n", + "5176/5176 [==============================] - 3s 591us/step - loss: 0.3779 - accuracy: 0.8360 - val_loss: 0.5435 - val_accuracy: 0.7568\n", + "Epoch 13/100\n", + "5176/5176 [==============================] - 3s 583us/step - loss: 0.3420 - accuracy: 0.8547 - val_loss: 0.5502 - val_accuracy: 0.7544\n", + "\n", + "Epoch 00013: ReduceLROnPlateau reducing learning rate to 2.499999936844688e-05.\n", + "Epoch 14/100\n", + "5176/5176 [==============================] - 3s 567us/step - loss: 0.3103 - accuracy: 0.8729 - val_loss: 0.5540 - val_accuracy: 0.7575\n", + "Restoring model weights from the end of the best epoch\n", + "Epoch 00014: early stopping\n", + "\n", + "Elapsed Time: 00:00:48\n", + "Completed Model Trainning Timestamp: 2020-01-30 08:25:58\n" + ] + } + ], + "source": [ + "print(\"Starting...\\n\")\n", + "\n", + "start_time = time.time()\n", + "print(date_time(1))\n", + "\n", + "print(\"\\n\\nCompliling Model ...\\n\")\n", + "learning_rate = 0.0001\n", + "optimizer = Adam(learning_rate)\n", + "# optimizer = Adam()\n", + "\n", + "model2.compile(optimizer=optimizer, loss=loss, metrics=metrics)\n", + "\n", + "verbose = 1\n", + "epochs = 100\n", + "batch_size = 16\n", + "validation_split = 0.2\n", + "\n", + "print(\"Trainning Model ...\\n\")\n", + "\n", + "history2 = model2.fit(\n", + " X_train_seq,\n", + " Y_train,\n", + " batch_size=batch_size,\n", + " epochs=epochs,\n", + " verbose=verbose,\n", + " callbacks=callbacks,\n", + " validation_split=validation_split,\n", + " class_weight =class_weight\n", + " )\n", + "\n", + "elapsed_time = time.time() - start_time\n", + "elapsed_time = time.strftime(\"%H:%M:%S\", time.gmtime(elapsed_time))\n", + "\n", + "print(\"\\nElapsed Time: \" + elapsed_time)\n", + "print(\"Completed Model Trainning\", date_time(1))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "_uuid": "357b590e09d3e623822c3e68b280ef42db952075" + }, + "source": [ + "#### 4.3.5.2.2 Visualization" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "_uuid": "50d81ffc4f78b45a59b7f08ec404d008a3c63f94" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_performance(history=history2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "_uuid": "b64920b6ac5a1bb4e60f1d937245007292dd1681" + }, + "source": [ + "### 14.3.6 Inference/ Prediction" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "_uuid": "a6e1d8e3639c5e739a67c484b00faf148fa6edd4" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1142/1142 [==============================] - 2s 2ms/step\n", + "1142/1142 [==============================] - 0s 108us/step\n" + ] + } + ], + "source": [ + "test_X_seq = tokenizer.texts_to_sequences(X_test)\n", + "test_X_seq = sequence.pad_sequences(test_X_seq, maxlen=max_len)\n", + "accuracy1 = model1.evaluate(test_X_seq, Y_test)\n", + "accuracy2 = model2.evaluate(test_X_seq, Y_test)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "_uuid": "08c78c65d45aaa855de2d16533dc5ddeb1a52c9b" + }, + "source": [ + "### 4.3.7 Evaluation" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "_uuid": "fd3d9e8a332ab50eb69d3995fa0847c642ca942d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model Performance of RNN (Test Accuracy):\n", + "Accuracy: 79.16%\n", + "Loss: 0.479\n", + "\n", + "\n", + "Model Performance of RNN (Test Accuracy):\n", + "v: 76.01%\n", + "Loss: 0.486\n", + "\n" + ] + } + ], + "source": [ + "print(\"Model Performance of RNN (Test Accuracy):\")\n", + "print('Accuracy: {:0.2f}%\\nLoss: {:0.3f}\\n'.format(accuracy1[1]*100, accuracy1[0]))\n", + "\n", + "print(\"\\nModel Performance of RNN (Test Accuracy):\")\n", + "print('v: {:0.2f}%\\nLoss: {:0.3f}\\n'.format(accuracy2[1]*100, accuracy2[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "_uuid": "68d1b5720cecae415e852c1f35563da08cfea2b5" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1142/1142 [==============================] - 2s 2ms/step\n", + "1142/1142 [==============================] - 0s 144us/step\n" + ] + } + ], + "source": [ + "ypreds1 = model1.predict_classes(test_X_seq, verbose=1)\n", + "ypreds2 = model2.predict_classes(test_X_seq, verbose=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": { + "_uuid": "3feb7baf3e5658dce6bdcf929af34676b5f23fd7" + }, + "outputs": [], + "source": [ + "def plot_model_performace(result):\n", + " sns.set_style(\"ticks\")\n", + " figsize=(22, 6)\n", + "\n", + " ticksize = 12\n", + " titlesize = ticksize + 8\n", + " labelsize = ticksize + 5\n", + "\n", + " xlabel = \"Model\"\n", + " ylabel = \"Score\"\n", + "\n", + " title = \"Model Performance\"\n", + "\n", + " params = {'figure.figsize' : figsize,\n", + " 'axes.labelsize' : labelsize,\n", + " 'axes.titlesize' : titlesize,\n", + " 'xtick.labelsize': ticksize,\n", + " 'ytick.labelsize': ticksize}\n", + "\n", + " plt.rcParams.update(params)\n", + "\n", + " col1 = \"model\"\n", + " col2 = \"score\"\n", + " sns.barplot(x=col1, y=col2, data=result)\n", + " plt.title(title.title())\n", + " plt.xlabel(xlabel)\n", + " plt.ylabel(ylabel)\n", + " plt.xticks(rotation=90)\n", + " plt.grid()\n", + " plt.plot()\n", + " plt.show()\n", + " print(result)" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": { + "_uuid": "dc19b344d18b16e4f15d4b21eb86bf6acde8c2f0" + }, + "outputs": [], + "source": [ + "# print(classification_report(Y_test, ypreds1))" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "_uuid": "47e7e60a9e06662083a4971f84589129d307be40" + }, + "outputs": [], + "source": [ + "# plot_confusion_matrix(Y_test, ypreds1, title=\"RNN\")" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": { + "_uuid": "0fc73dddd076f5c15ff41a9dff2abf47d7126589" + }, + "outputs": [], + "source": [ + "# print(classification_report(Y_test, ypreds2))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "_uuid": "73e7f87fdfb70dd3eddabd607a9eefb96a086831" + }, + "source": [ + "#### 10.5.1.2 Visualization" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": { + "_uuid": "675a75e41d24b34491a9b9e310b30803b90e9188" + }, + "outputs": [], + "source": [ + "# plot_confusion_matrix(Y_test, ypreds2, title=\"CNN\")" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": { + "_uuid": "6679f27d3d8d66fcc4c99d3183821051f823f688" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/conda/lib/python3.6/site-packages/ipykernel_launcher.py:3: FutureWarning: \n", + ".ix is deprecated. Please use\n", + ".loc for label based indexing or\n", + ".iloc for positional indexing\n", + "\n", + "See the documentation here:\n", + "http://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#ix-indexer-is-deprecated\n", + " This is separate from the ipykernel package so we can avoid doing imports until\n" + ] + } + ], + "source": [ + "result = pd.DataFrame({'model': 'RNN', 'score': accuracy1[1]*100}, index=[-1])\n", + "row2 = pd.DataFrame({'model': 'CNN', 'score': accuracy2[1]*100}, index=[-1])\n", + "result = pd.concat([row2, result.ix[:]]).reset_index(drop=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": { + "_uuid": "fa8ce5f06a1b2884dd5b1c113dcd041c86aa26bb" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " model score\n", + "0 CNN 76.007003\n", + "1 RNN 79.159367\n" + ] + } + ], + "source": [ + "plot_model_performace(result)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Final" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idkeywordlocationtexttext_modifiedtext_lenword_countunique_word_counthash_countmention_counttarget
01NaNNaNOur Deeds are the Reason of this #earthquake M...Our Deeds are the Reason of this #earthquake M...691313101
14NaNNaNForest fire near La Ronge Sask. CanadaForest fire near La Ronge Sask . Canada3877001
25NaNNaNAll residents asked to 'shelter in place' are ...All residents asked to ' shelter in place ' ar...1332220001
36NaNNaN13,000 people receive #wildfires evacuation or...13 , 0 0 0 people receive #wildfires evacuatio...6588101
47NaNNaNJust got sent this photo from Ruby #Alaska as ...Just got sent this photo from Ruby #Alaska as ...881615201
\n", + "
" + ], + "text/plain": [ + " id keyword location text \\\n", + "0 1 NaN NaN Our Deeds are the Reason of this #earthquake M... \n", + "1 4 NaN NaN Forest fire near La Ronge Sask. Canada \n", + "2 5 NaN NaN All residents asked to 'shelter in place' are ... \n", + "3 6 NaN NaN 13,000 people receive #wildfires evacuation or... \n", + "4 7 NaN NaN Just got sent this photo from Ruby #Alaska as ... \n", + "\n", + " text_modified text_len word_count \\\n", + "0 Our Deeds are the Reason of this #earthquake M... 69 13 \n", + "1 Forest fire near La Ronge Sask . Canada 38 7 \n", + "2 All residents asked to ' shelter in place ' ar... 133 22 \n", + "3 13 , 0 0 0 people receive #wildfires evacuatio... 65 8 \n", + "4 Just got sent this photo from Ruby #Alaska as ... 88 16 \n", + "\n", + " unique_word_count hash_count mention_count target \n", + "0 13 1 0 1 \n", + "1 7 0 0 1 \n", + "2 20 0 0 1 \n", + "3 8 1 0 1 \n", + "4 15 2 0 1 " + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_train.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.naive_bayes import GaussianNB\n", + "\n", + "vectorizer = TfidfVectorizer(\n", + "# input='content', \n", + "# encoding='utf-8', \n", + "# decode_error='strict', \n", + "# strip_accents=None, \n", + "# lowercase=False,\n", + "# preprocessor=None,\n", + "# tokenizer=None, \n", + "# analyzer='word',\n", + " stop_words=None, \n", + " ngram_range=(1, 2), \n", + " max_df=0.6, \n", + " min_df=4, \n", + " max_features=None, \n", + "# vocabulary=None, \n", + "# binary=False, \n", + " norm='l2', \n", + " use_idf=True, \n", + " smooth_idf=True,\n", + " sublinear_tf=True\n", + ")\n", + "\n", + "X_train_tf = vectorizer.fit_transform(df_train.text.tolist()).toarray()\n", + "\n", + "y_train = df_train.target.tolist()\n", + "\n", + "# print(train_X.shape)\n", + "# print(len(Y_train))\n", + "\n", + "\n", + "############################\n", + "\n", + "gnb = GaussianNB()\n", + "\n", + "X_test_tf = vectorizer.transform(df_test.text.tolist()).toarray()\n", + "\n", + "y_pred = gnb.fit(X_train_tf, y_train).predict(X_test_tf)" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idkeywordlocationtexttext_lenword_countunique_word_counthash_countmention_count
00NaNNaNJust happened a terrible car crash346600
12NaNNaNHeard about #earthquake is different cities, s...649910
23NaNNaNthere is a forest fire at spot pond, geese are...96191900
39NaNNaNApocalypse lighting. #Spokane #wildfires404420
411NaNNaNTyphoon Soudelor kills 28 in China and Taiwan458800
\n", + "
" + ], + "text/plain": [ + " id keyword location text \\\n", + "0 0 NaN NaN Just happened a terrible car crash \n", + "1 2 NaN NaN Heard about #earthquake is different cities, s... \n", + "2 3 NaN NaN there is a forest fire at spot pond, geese are... \n", + "3 9 NaN NaN Apocalypse lighting. #Spokane #wildfires \n", + "4 11 NaN NaN Typhoon Soudelor kills 28 in China and Taiwan \n", + "\n", + " text_len word_count unique_word_count hash_count mention_count \n", + "0 34 6 6 0 0 \n", + "1 64 9 9 1 0 \n", + "2 96 19 19 0 0 \n", + "3 40 4 4 2 0 \n", + "4 45 8 8 0 0 " + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_test.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [], + "source": [ + "sample_list = list(sub_sample.id)\n", + "\n", + "pred_dict = dict((key, value) for (key, value) in zip(df_test.id, y_pred))\n", + "\n", + "pred_list_new = [pred_dict[f] for f in sample_list]\n", + "\n", + "test_df = pd.DataFrame({'id': sample_list, 'target': pred_list_new})\n", + "\n", + "test_df.to_csv(\"submission.csv\", header=True, index=False)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/Project-Structure.md b/Project-Structure.md index 06ebc58d7b..6b2d7b8147 100644 --- a/Project-Structure.md +++ b/Project-Structure.md @@ -554,6 +554,8 @@ * [Thyroid-Disease-Detection-Using-Deep-Learning](Deep_Learning/Thyroid_detection/thyroid-disease-detection-using-deep-learning.ipynb) * Traffic Accident Prediction Model Using Deep Learning * [Traffic Accident Prediction Model Using Deep Learning](Deep_Learning/Traffic%20Accident%20Prediction%20Model%20using%20Deep%20Learning/Traffic%20Accident%20Prediction%20Model%20using%20Deep%20Learning.ipynb) + * Tweet Classificaion Dl + * [Disaster Tweet Classification Using Nlp And Deep Learning](Deep_Learning/Tweet_Classificaion_DL/Disaster%20Tweet%20Classification%20using%20NLP%20and%20Deep%20Learning.ipynb) * Yolo-Drowsiness-Detection-Main * [Drowsiness Detection Tutorial](Deep_Learning/YOLO-Drowsiness-Detection-main/Drowsiness%20Detection%20Tutorial.ipynb) * Smart Attendance System