Thesis Code V3-Alt.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load Dependencies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# -*- coding: unicode -*-"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n",
      "C:\\Users\\insuf\\AppData\\Local\\conda\\conda\\envs\\python352\\lib\\site-packages\\gensim\\utils.py:1197: UserWarning: detected Windows; aliasing chunkize to chunkize_serial\n",
      "  warnings.warn(\"detected Windows; aliasing chunkize to chunkize_serial\")\n"
     ]
    }
   ],
   "source": [
    "import sys, os, re, csv, codecs, numpy as np, pandas as pd\n",
    "# os.environ[\"CUDA_DEVICE_ORDER\"] = \"PCI_BUS_ID\"   # see issue #152\n",
    "# os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"\"\n",
    "import tensorflow as tf\n",
    "from keras import backend as K\n",
    "from keras.preprocessing.text import Tokenizer\n",
    "from keras.preprocessing.sequence import pad_sequences\n",
    "from matplotlib import pyplot as plt\n",
    "import gensim\n",
    "import nltk\n",
    "from sklearn import metrics\n",
    "from sklearn.model_selection import train_test_split\n",
    "from keras.layers import Dense, Input, LSTM, Embedding, Dropout, Activation, GRU\n",
    "from keras.layers import Bidirectional, BatchNormalization, GlobalMaxPooling1D\n",
    "from keras.models import Model, Sequential\n",
    "from keras.utils import plot_model\n",
    "from keras import initializers, regularizers, constraints, optimizers, layers\n",
    "from keras.callbacks import TensorBoard, EarlyStopping, Callback"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.backend.tensorflow_backend import set_session\n",
    "\n",
    "config = tf.ConfigProto()\n",
    "config.gpu_options.per_process_gpu_memory_fraction = 0.3\n",
    "set_session(tf.Session(config=config))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert gensim.models.doc2vec.FAST_VERSION > -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package stopwords to\n",
      "[nltk_data]     C:\\Users\\insuf\\AppData\\Roaming\\nltk_data...\n",
      "[nltk_data]   Package stopwords is already up-to-date!\n",
      "[nltk_data] Downloading package punkt to\n",
      "[nltk_data]     C:\\Users\\insuf\\AppData\\Roaming\\nltk_data...\n",
      "[nltk_data]   Package punkt is already up-to-date!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nltk.download('stopwords')\n",
    "nltk.download('punkt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[name: \"/cpu:0\"\n",
      "device_type: \"CPU\"\n",
      "memory_limit: 268435456\n",
      "locality {\n",
      "}\n",
      "incarnation: 2889012619958428759\n",
      ", name: \"/gpu:0\"\n",
      "device_type: \"GPU\"\n",
      "memory_limit: 3129039257\n",
      "locality {\n",
      "  bus_id: 1\n",
      "}\n",
      "incarnation: 6539754278862205395\n",
      "physical_device_desc: \"device: 0, name: GeForce GTX 1060 6GB, pci bus id: 0000:01:00.0\"\n",
      "]\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.python.client import device_lib\n",
    "print(device_lib.list_local_devices())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy.random import seed\n",
    "seed(123)\n",
    "from tensorflow import set_random_seed\n",
    "set_random_seed(123)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "train = pd.read_csv('train_clean.csv')\n",
    "train.comment_text = train.comment_text.astype(str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_classes = list_classes = [\"toxic\", \"obscene\", \"threat\", \"insult\", \"identity_hate\"]\n",
    "y = train[list_classes].values\n",
    "list_sentences_train = train[\"comment_text\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "223043"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max_features = 20000\n",
    "tokenizer = Tokenizer(num_words=max_features)\n",
    "tokenizer.fit_on_texts(list(list_sentences_train))\n",
    "list_tokenized_train = tokenizer.texts_to_sequences(list_sentences_train)\n",
    "len(tokenizer.word_index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# totalNumWords = [len(one_comment) for one_comment in list_tokenized_train]\n",
    "# plt.hist(totalNumWords)\n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# meanLen = np.mean(totalNumWords)\n",
    "# stdLen = np.std(totalNumWords)\n",
    "# ub = meanLen + 2.576*stdLen/np.sqrt(len(totalNumWords))\n",
    "# ub"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "maxlen = 100\n",
    "X_t = pad_sequences(list_tokenized_train,maxlen=maxlen,padding='post')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# X_t[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# list_sentences_train[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# list_sentences_train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# X_t[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# description = train.comment_text.values.tolist()\n",
    "# stop_words = set(nltk.corpus.stopwords.words('english'))\n",
    "\n",
    "\n",
    "# # Function to filter stop words from tokens for each sentence\n",
    "# def sentence_filter(sentence_token, stop_words):\n",
    "#     filtered = []\n",
    "#     for token in sentence_token:\n",
    "#         if not token in stop_words:\n",
    "#             filtered.append(token)\n",
    "#     return filtered\n",
    "\n",
    "\n",
    "# # Input description, tokenize each sentence and return token for each sentence without stopping words\n",
    "# def sentence_tokenizer(description, stop_words):\n",
    "#     value = []\n",
    "#     for sentence in description:\n",
    "#         sentence = sentence.lower()\n",
    "#         tokenizer_ = nltk.tokenize.RegexpTokenizer(r'[a-zA-Z]+')\n",
    "#         sentence_token = tokenizer_.tokenize(sentence)\n",
    "#         # sentence_token = nltk.word_tokenize(sentence)\n",
    "#         filtered_token = sentence_filter(sentence_token, stop_words)\n",
    "#         value.append(filtered_token)\n",
    "#     return value\n",
    "\n",
    "\n",
    "# # Tokenize the sentence\n",
    "# description_token = sentence_tokenizer(description, stop_words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# len(description_token)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Skip gram model with minimum word count = 10 and output vector of length 300\n",
    "# model_sg = gensim.models.Word2Vec(description_token, window=2, min_count=10, size=300, workers=4, seed=123, iter=10)\n",
    "\n",
    "# CBOW(continuous bag of words) model\n",
    "# model_cbow = gensim.models.Word2Vec(description_token, window=2, min_count=10, size=300, workers=4, seed=123, iter=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# model_sg.save('model_sg')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# model_cbow.save('model_cbow')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded 25653 word vectors.\n",
      "total embedded: 19861 common words\n"
     ]
    }
   ],
   "source": [
    "model_sg = gensim.models.Word2Vec.load('model_sg')\n",
    "\n",
    "embed_size = 300\n",
    "embeddings_index = dict()\n",
    "for word in model_sg.wv.vocab:\n",
    "    embeddings_index[word] = model_sg.wv[word]\n",
    "print('Loaded %s word vectors.' % len(embeddings_index))\n",
    "\n",
    "nb_words = min(max_features, len(tokenizer.word_index))\n",
    "embedding_matrix = np.zeros((nb_words, embed_size))\n",
    "\n",
    "embeddedCount = 0\n",
    "for word, i in tokenizer.word_index.items():\n",
    "    if i >= max_features: continue\n",
    "    embedding_vector = embeddings_index.get(word)\n",
    "    if embedding_vector is not None:\n",
    "        # words not found in embedding index will be all-zeros.\n",
    "        embedding_matrix[i] = embedding_vector\n",
    "        embeddedCount += 1\n",
    "print('total embedded:',embeddedCount,'common words')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2451"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tokenizer.word_index['stuck']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# model_cbow = gensim.models.Word2Vec.load('model_cbow')\n",
    "\n",
    "# embed_size = 300\n",
    "# embeddings_index = dict()\n",
    "# for word in model_cbow.wv.vocab:\n",
    "#     embeddings_index[word] = model_cbow.wv[word]\n",
    "# print('Loaded %s word vectors.' % len(embeddings_index))\n",
    "\n",
    "# nb_words = min(max_features, len(tokenizer.word_index))\n",
    "# embedding_matrix = np.zeros((nb_words, embed_size))\n",
    "\n",
    "# embeddedCount = 0\n",
    "# for word, i in tokenizer.word_index.items():\n",
    "#     if i >= max_features: continue\n",
    "#     embedding_vector = embeddings_index.get(word)\n",
    "#     if embedding_vector is not None:\n",
    "#         # words not found in embedding index will be all-zeros.\n",
    "#         embedding_matrix[i] = embedding_vector\n",
    "#         embeddedCount += 1\n",
    "# print('total embedded:',embeddedCount,'common words')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(20000, 300)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "embedding_matrix.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# model_sg.wv.most_similar('rape')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def auc(y_true, y_pred):\n",
    "     auc = tf.metrics.auc(y_true, y_pred)[1]\n",
    "     K.get_session().run(tf.local_variables_initializer())\n",
    "     return auc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# def precision(y_true, y_pred):\n",
    "#     tp = tf.metrics.true_positives(y_true, y_pred)[1]\n",
    "#     fp = tf.metrics.false_positives(y_true, y_pred)[1]\n",
    "#     precision = tp/(tp+fp)\n",
    "#     K.get_session().run(tf.local_variables_initializer())\n",
    "#     return precision"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# def recall(y_true, y_pred):\n",
    "#     tp = tf.metrics.true_positives(y_true, y_pred)[1]\n",
    "#     fn = tf.metrics.false_negatives(y_true, y_pred)[1]\n",
    "#     recall = tp/(tp+fn)\n",
    "#     K.get_session().run(tf.local_variables_initializer())\n",
    "#     return recall"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# class Metrics(Callback):\n",
    "#     def on_train_begin(self, logs={}):\n",
    "#         self.val_recalls = []\n",
    "#         self.val_precisions = []\n",
    "\n",
    "#     def on_batch_end(self, epoch, logs={}):\n",
    "#         val_predict = (np.asarray(self.model.predict(self.validation_data[0]))).round()\n",
    "#         val_targ = self.validation_data[1]\n",
    "#         _val_recall = metrics.recall_score(val_targ, val_predict)\n",
    "#         _val_precision = metrics.precision_score(val_targ, val_predict)\n",
    "#         self.val_recalls.append(_val_recall)\n",
    "#         self.val_precisions.append(_val_precision)\n",
    "#         print(\" — val_precision: {} — val_recall {}\".format(_val_precision, _val_recall))\n",
    "#         return\n",
    "\n",
    "# pr = Metrics()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\insuf\\AppData\\Local\\conda\\conda\\envs\\python352\\lib\\site-packages\\sklearn\\model_selection\\_split.py:2026: FutureWarning: From version 0.21, test_size will always complement train_size unless both are specified.\n",
      "  FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "X_train, X_val, y_train, y_val = train_test_split(X_t, y, train_size=0.9, random_state=123)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "embedding_1 (Embedding)      (None, 100, 300)          6000000   \n",
      "_________________________________________________________________\n",
      "bidirectional_1 (Bidirection (None, 200)               320800    \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 50)                10050     \n",
      "_________________________________________________________________\n",
      "dropout_1 (Dropout)          (None, 50)                0         \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 5)                 255       \n",
      "=================================================================\n",
      "Total params: 6,331,105\n",
      "Trainable params: 6,331,105\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model = Sequential()\n",
    "model.add(Embedding(max_features,embed_size,weights=[embedding_matrix],input_length=maxlen))\n",
    "model.add(Bidirectional(LSTM(100,dropout=0.1,recurrent_dropout=0.1)))\n",
    "model.add(Dense(50, activation=\"relu\"))\n",
    "model.add(Dropout(0.1))\n",
    "model.add(Dense(5, activation=\"sigmoid\"))\n",
    "model.compile(loss='binary_crossentropy',optimizer='adam',metrics=[auc])\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot_model(model, to_file='model.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "early = EarlyStopping(monitor=\"val_loss\", mode=\"min\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 143613 samples, validate on 15958 samples\n",
      "Epoch 1/10\n",
      "143613/143613 [==============================] - 165s 1ms/step - loss: 0.0846 - auc: 0.8820 - val_loss: 0.0515 - val_auc: 0.9541\n",
      "Epoch 2/10\n",
      "143613/143613 [==============================] - 163s 1ms/step - loss: 0.0532 - auc: 0.9636 - val_loss: 0.0471 - val_auc: 0.9691\n",
      "Epoch 3/10\n",
      "143613/143613 [==============================] - 164s 1ms/step - loss: 0.0470 - auc: 0.9727 - val_loss: 0.0468 - val_auc: 0.9751\n",
      "Epoch 4/10\n",
      "143613/143613 [==============================] - 163s 1ms/step - loss: 0.0418 - auc: 0.9772 - val_loss: 0.0470 - val_auc: 0.9788\n"
     ]
    }
   ],
   "source": [
    "with tf.device('/gpu:0'):\n",
    "    history = model.fit(X_train,y_train,batch_size=256,epochs=10,validation_data=(X_val, y_val), callbacks=[early])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation Precision: [0.84437596302003082, 0.82375478927203061, 1.0, 0.7750385208012327, 0.65454545454545454],\n",
      "\n",
      "Validation Recall: [0.75482093663911842, 0.79433497536945807, 0.066666666666666666, 0.67516778523489929, 0.30769230769230771],\n",
      "\n",
      "Validation F1: [0.79709090909090907, 0.80877742946708464, 0.125, 0.72166427546628398, 0.41860465116279072]\n"
     ]
    }
   ],
   "source": [
    "val_predict = (np.asarray(model.predict([X_val], batch_size=512))).round()\n",
    "val_target = y_val\n",
    "\n",
    "val_precision = []\n",
    "val_recall = []\n",
    "val_f1 = []\n",
    "for i in range(5):\n",
    "    val_precision.append(metrics.precision_score(val_target[:,i], val_predict[:,i]))\n",
    "    val_recall.append(metrics.recall_score(val_target[:,i], val_predict[:,i]))\n",
    "    val_f1.append(metrics.f1_score(val_target[:,i], val_predict[:,i]))\n",
    "\n",
    "print(\"Validation Precision: {},\\n\\nValidation Recall: {},\\n\\nValidation F1: {}\".format(val_precision, val_recall, val_f1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(history.history['auc'], label=\"AUC\")\n",
    "plt.plot(history.history['val_auc'], label=\"Validation AUC\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(history.history['loss'], label=\"Loss\")\n",
    "plt.plot(history.history['val_loss'], label=\"Validation Loss\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "names = [\"Toxic\", \"Obscene\", \"Threat\", \"Insult\", \"Identity Hate\"]\n",
    "\n",
    "plt.bar(np.arange(5)-0.3/2, val_precision, 0.3, label=\"Baseline Validation Precision\", tick_label=names)\n",
    "plt.bar(np.arange(5)+0.3/2, val_recall, 0.3, label=\"Baseline Validation Recall\", tick_label=names)\n",
    "\n",
    "plt.legend(loc='right', bbox_to_anchor=(1.6,0.5))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Use GRU instead of LSTM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "embedding_2 (Embedding)      (None, 100, 300)          6000000   \n",
      "_________________________________________________________________\n",
      "bidirectional_2 (Bidirection (None, 200)               240600    \n",
      "_________________________________________________________________\n",
      "dense_3 (Dense)              (None, 50)                10050     \n",
      "_________________________________________________________________\n",
      "dropout_2 (Dropout)          (None, 50)                0         \n",
      "_________________________________________________________________\n",
      "dense_4 (Dense)              (None, 5)                 255       \n",
      "=================================================================\n",
      "Total params: 6,250,905\n",
      "Trainable params: 6,250,905\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model2 = Sequential()\n",
    "model2.add(Embedding(max_features,embed_size,weights=[embedding_matrix],input_length=maxlen))\n",
    "model2.add(Bidirectional(GRU(100,dropout=0.1,recurrent_dropout=0.1)))\n",
    "model2.add(Dense(50, activation=\"relu\"))\n",
    "model2.add(Dropout(0.1))\n",
    "model2.add(Dense(5, activation=\"sigmoid\"))\n",
    "model2.compile(loss='binary_crossentropy',optimizer='adam',metrics=[auc])\n",
    "model2.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot_model(model2, to_file='model2.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 143613 samples, validate on 15958 samples\n",
      "Epoch 1/10\n",
      "143613/143613 [==============================] - 128s 894us/step - loss: 0.0814 - auc: 0.8840 - val_loss: 0.0482 - val_auc: 0.9582\n",
      "Epoch 2/10\n",
      "143613/143613 [==============================] - 126s 874us/step - loss: 0.0504 - auc: 0.9670 - val_loss: 0.0463 - val_auc: 0.9720\n",
      "Epoch 3/10\n",
      "143613/143613 [==============================] - 127s 886us/step - loss: 0.0442 - auc: 0.9752 - val_loss: 0.0467 - val_auc: 0.9774\n"
     ]
    }
   ],
   "source": [
    "with tf.device('/gpu:0'):\n",
    "    history2 = model2.fit(X_train,y_train,batch_size=256,epochs=10,validation_data=(X_val, y_val), callbacks=[early])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(history2.history['auc'], label=\"AUC\")\n",
    "plt.plot(history2.history['val_auc'], label=\"Validation AUC\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(history2.history['loss'], label=\"Loss\")\n",
    "plt.plot(history2.history['val_loss'], label=\"Validation Loss\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation Precision: [0.85159285159285159, 0.84300791556728227, 0.59999999999999998, 0.77041602465331283, 0.7142857142857143],\n",
      "\n",
      "Validation Recall: [0.75482093663911842, 0.78694581280788178, 0.066666666666666666, 0.67114093959731547, 0.29914529914529914]\n"
     ]
    }
   ],
   "source": [
    "val_predict2 = (np.asarray(model2.predict([X_val], batch_size=512))).round()\n",
    "\n",
    "val_precision2 = []\n",
    "val_recall2 = []\n",
    "for i in range(5):\n",
    "    val_precision2.append(metrics.precision_score(val_target[:,i], val_predict2[:,i]))\n",
    "    val_recall2.append(metrics.recall_score(val_target[:,i], val_predict2[:,i]))\n",
    "\n",
    "print(\"Validation Precision: {},\\n\\nValidation Recall: {}\".format(val_precision2, val_recall2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.bar(np.arange(5) - 0.3/2,val_precision,0.3,label=\"Baseline Validation Precision\", tick_label=names)\n",
    "plt.bar(np.arange(5) + 0.3/2,val_precision2,0.3,label=\"GRU Validation Precision\", tick_label=names)\n",
    "plt.legend(loc='right', bbox_to_anchor=(1.6,0.5))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.bar(np.arange(5) - 0.3/2,val_recall,0.3,label=\"Baseline Validation Recall\", tick_label=names)\n",
    "plt.bar(np.arange(5) + 0.3/2,val_recall2,0.3,label=\"GRU Validation Recall\", tick_label=names)\n",
    "plt.legend(loc='right', bbox_to_anchor=(1.55,0.5))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Use Pre-trained Embedding - GoogleNews Negative 3mil"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\insuf\\AppData\\Local\\conda\\conda\\envs\\python352\\lib\\site-packages\\ipykernel_launcher.py:6: DeprecationWarning: Call to deprecated `wv` (Attribute will be removed in 4.0.0, use self instead).\n",
      "  \n",
      "C:\\Users\\insuf\\AppData\\Local\\conda\\conda\\envs\\python352\\lib\\site-packages\\ipykernel_launcher.py:7: DeprecationWarning: Call to deprecated `wv` (Attribute will be removed in 4.0.0, use self instead).\n",
      "  import sys\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded 3000000 word vectors.\n",
      "total embedded: 17855 common words\n"
     ]
    }
   ],
   "source": [
    "word2vecDict = gensim.models.keyedvectors.KeyedVectors.load_word2vec_format(\n",
    "    r\"C:\\Users\\insuf\\Desktop\\GoogleNews-vectors-negative300.bin\", binary=True)\n",
    "\n",
    "embed_size = 300\n",
    "embeddings_index = dict()\n",
    "for word in word2vecDict.wv.vocab:\n",
    "    embeddings_index[word] = word2vecDict.wv[word]\n",
    "print('Loaded %s word vectors.' % len(embeddings_index))\n",
    "\n",
    "nb_words = min(max_features, len(tokenizer.word_index))\n",
    "embedding_matrix = np.zeros((nb_words, embed_size))\n",
    "\n",
    "embeddedCount = 0\n",
    "for word, i in tokenizer.word_index.items():\n",
    "    if i >= max_features: continue\n",
    "    embedding_vector = embeddings_index.get(word)\n",
    "    if embedding_vector is not None:\n",
    "        # words not found in embedding index will be all-zeros.\n",
    "        embedding_matrix[i] = embedding_vector\n",
    "        embeddedCount += 1\n",
    "print('total embedded:',embeddedCount,'common words')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "embedding_3 (Embedding)      (None, 100, 300)          6000000   \n",
      "_________________________________________________________________\n",
      "bidirectional_3 (Bidirection (None, 200)               320800    \n",
      "_________________________________________________________________\n",
      "dense_5 (Dense)              (None, 50)                10050     \n",
      "_________________________________________________________________\n",
      "dropout_3 (Dropout)          (None, 50)                0         \n",
      "_________________________________________________________________\n",
      "dense_6 (Dense)              (None, 5)                 255       \n",
      "=================================================================\n",
      "Total params: 6,331,105\n",
      "Trainable params: 6,331,105\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model3 = Sequential()\n",
    "model3.add(Embedding(max_features,embed_size,weights=[embedding_matrix],input_length=maxlen))\n",
    "model3.add(Bidirectional(LSTM(100,dropout=0.1,recurrent_dropout=0.1)))\n",
    "model3.add(Dense(50, activation=\"relu\"))\n",
    "model3.add(Dropout(0.1))\n",
    "model3.add(Dense(5, activation=\"sigmoid\"))\n",
    "model3.compile(loss='binary_crossentropy',optimizer='adam',metrics=[auc])\n",
    "model3.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 143613 samples, validate on 15958 samples\n",
      "Epoch 1/10\n",
      "143613/143613 [==============================] - 162s 1ms/step - loss: 0.0937 - auc: 0.8373 - val_loss: 0.0518 - val_auc: 0.9411\n",
      "Epoch 2/10\n",
      "143613/143613 [==============================] - 165s 1ms/step - loss: 0.0538 - auc: 0.9558 - val_loss: 0.0479 - val_auc: 0.9638\n",
      "Epoch 3/10\n",
      "143613/143613 [==============================] - 158s 1ms/step - loss: 0.0467 - auc: 0.9687 - val_loss: 0.0479 - val_auc: 0.9722\n"
     ]
    }
   ],
   "source": [
    "with tf.device('/gpu:0'):\n",
    "    history3 = model3.fit(X_train,y_train,batch_size=256,epochs=10,validation_data=(X_val, y_val), callbacks=[early])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(history3.history['auc'], label=\"AUC\")\n",
    "plt.plot(history3.history['val_auc'], label=\"Validation AUC\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAD8CAYAAACb4nSYAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvFvnyVgAAIABJREFUeJzt3Xl8VPW5+PHPk21CVsjCkrCERZFshBCCVYsL1iouuKACCgRQRK+111arttflx61t7fUitVqtSliUKyh1a12wKq3WBQgUIcgWkCVEIQmQlax8f3/MJAwhy0BmcjIzz/v1mhcz53zPmWdODs/Zvuc5YoxBKaWUfwiwOgCllFJdR5O+Ukr5EU36SinlRzTpK6WUH9Gkr5RSfkSTvlJK+RFN+kop5Uc06SullB/RpK+UUn4kyOoAWoqLizNJSUlWh6GUUl5l/fr1JcaY+I7adbukn5SURF5entVhKKWUVxGRva6009M7SinlRzTpK6WUH9Gkr5RSfqTbndNXSnWN+vp6CgsLqampsToUdRpCQ0Pp378/wcHBZzS9Jn2l/FRhYSGRkZEkJSUhIlaHo1xgjKG0tJTCwkIGDx58RvPQ0ztK+amamhpiY2M14XsRESE2NrZTR2ea9JXyY5rwvU9n/2Y+k/Sraht47J0tlB2rtzoUpZTqtnwm6W/7vpxla/Zy+5I8auobrQ5HKeWCiIgIq0PwOz6T9EcPimH+TRms23uYe179Nw2Nx60OSSmluh2fSfoAV49M4NGrkvnwm4M8/HY+xhirQ1JKnaa9e/cyfvx40tPTGT9+PPv27QPg9ddfJzU1lZEjRzJu3DgAtmzZQnZ2NhkZGaSnp7Nz504rQ/cKPtdlM+f8wZRU1vHM6gLiImz8/LLhVoekVLf3//66hW+Kyt06z+SEKB69OuW0p7v77ruZPn06M2bMIDc3l3vuuYe33nqLefPmsWrVKhITEzl69CgAzz//PD/96U+55ZZbqKuro7FRT+12xKf29Jv8/LKzmTxmAH/8pIAlX+yxOhyl1Gn48ssvmTp1KgDTpk3jX//6FwDnn38+OTk5vPjii83J/Qc/+AG/+c1veOKJJ9i7dy89evSwLG5v4XN7+mDv0vTra1Mprarjsb9uITYihKvSE6wOS6lu60z2yLtKUxfF559/njVr1vDuu++SkZHBxo0bmTp1KmPHjuXdd9/lxz/+MS+99BKXXHKJxRF3bz65pw8QFBjAH6eMYsygGO5dsZHPC0qsDkkp5YLzzjuP5cuXA7Bs2TIuuOACAHbt2sXYsWOZN28ecXFx7N+/n927dzNkyBDuuecerrnmGjZt2mRl6F7BZ5M+QGhwIC/OyGJofARzluaRf6DM6pCUUk6qq6vp379/82v+/Pk8/fTTLFq0iPT0dF5++WX+8Ic/AHD//feTlpZGamoq48aNY+TIkaxYsYLU1FQyMjLYtm0b06dPt/gXdX/S3Xq4ZGVlGXc/ROVgeQ3X/+kLahsaWTn3PJLiwt06f6W80datWxkxYoTVYagz0NrfTkTWG2OyOprWp/f0m/SJCmXp7GyOG5iWu4ZDFVpVUCnln/wi6QMMjY8gN2cMpZV1zMhdR3mNlmtQSvkfv0n6ABkDevLcraPZebCCOUu1XINSyv+4lPRF5HIR2S4iBSLyYCvjbSKywjF+jYgkOYaHiMgiEdksIl+LyEVujf4MXHh2PE/eOJKvdh/m3hUbaTzeva5pKKWUJ3WY9EUkEHgWuAJIBqaISHKLZrOBI8aYYcBTwBOO4bcDGGPSgB8B/ysilh9dXDsqkYevSub9/O95RMs1KKX8iCsJOBsoMMbsNsbUAcuBiS3aTASWON6vBMaL/Y6KZOBjAGPMIeAo0OHV5a4w+4LBzL1wKMvW7OMPH2u9DqWUf3Al6ScC+50+FzqGtdrGGNMAlAGxwNfARBEJEpHBwGhgQGeDdpcHLh/OpNH9WfDRTl75aq/V4SjlVy666CJWrVp10rAFCxZw1113tTtdUznmoqIiJk2a1Oa8O+r6vWDBAqqrq5s/T5gwobmmT2c89thjPPnkk52ej6e4kvRbe0xLy/MhbbXJxb6RyAMWAF8ADad8gcgcEckTkbzi4mIXQnIPEeF316cx/pzePPx2Pu9v/q7LvlspfzdlypTmO2+bLF++nClTprg0fUJCAitXrjzj72+Z9N977z169ux5xvPzFq4k/UJO3jvvDxS11UZEgoBo4LAxpsEYc68xJsMYMxHoCZxyLsUY84IxJssYkxUfH38mv+OMBQUG8MzUTDIH9uKnyzfy5a7SLv1+pfzVpEmT+Nvf/kZtbS0Ae/bsoaioiAsuuIDKykrGjx9PZmYmaWlpvP3226dMv2fPHlJTUwE4duwYkydPJj09nZtvvpljx441t7vzzjvJysoiJSWFRx99FICnn36aoqIiLr74Yi6++GIAkpKSKCmxl2uZP38+qamppKamsmDBgubvGzFiBLfffjspKSlcdtllJ31PR1qbZ1VVFVdeeSUjR44kNTWVFStWAPDggw+SnJxMeno6991332kt1464UnBtHXCW4/TMAWAyMLVFm3eAGcCXwCTgE2OMEZEw7Hf9VonIj4AGY8w37gvfPXqEBLJwRhY3Pv8lc5bmsfyOc0lJiLY6LKW6zvsPwveb3TvPvmlwxe/aHB0bG0t2djYffPABEydOZPny5dx8882ICKGhobz55ptERUVRUlLCueeeyzXXXNPm82Gfe+45wsLC2LRpE5s2bSIzM7N53OOPP05MTAyNjY2MHz+eTZs2cc899zB//nxWr15NXFzcSfNav349ixYtYs2aNRhjGDt2LBdeeCG9evVi586dvPrqq7z44ovcdNNN/OUvf+HWW2/tcFG0Nc/du3eTkJDAu+++C0BZWRmHDx/mzTffZNu2bYiIW045OetwT99xjv5uYBWwFXjNGLNFROaJyDWOZguBWBEpAH4GNHXr7A1sEJGtwAPANLdG70Y9w0JYOjubyNAgZuSuY19pdccTKaU6xfkUj/OpHWMMv/zlL0lPT+fSSy/lwIEDHDx4sM35fPrpp83JNz09nfT09OZxr732GpmZmYwaNYotW7bwzTft73f+61//4rrrriM8PJyIiAiuv/56PvvsMwAGDx5MRkYGAKNHj2bPnj0u/c625pmWlsZHH33EAw88wGeffUZ0dDRRUVGEhoZy22238cYbbxAWFubSd7jKpdLKxpj3gPdaDHvE6X0NcGMr0+0BvOYpJv2ie7B0djaTnv+SablrWDn3POIjbVaHpZTntbNH7knXXnstP/vZz9iwYQPHjh1r3kNftmwZxcXFrF+/nuDgYJKSkqipab98SmtHAd9++y1PPvkk69ato1evXuTk5HQ4n/a6cNtsJ/JBYGCgy6d32prn2Wefzfr163nvvfd46KGHuOyyy3jkkUdYu3YtH3/8McuXL+eZZ57hk08+cel7XGF5n/nuZljvSHJzxnCwvIaZi9dSWXvKdWellJtERERw0UUXMWvWrJMu4JaVldG7d2+Cg4NZvXo1e/e237tu3LhxLFu2DID8/PzmEsvl5eWEh4cTHR3NwYMHef/995uniYyMpKKiotV5vfXWW1RXV1NVVcWbb77JD3/4w079zrbmWVRURFhYGLfeeiv33XcfGzZsoLKykrKyMiZMmMCCBQvYuHFjp767JZ98iEpnZQ7sxXO3jOa2pXnc8XIeuTljsAUFWh2WUj5pypQpXH/99Sf15Lnlllu4+uqrycrKIiMjg3POOafdedx5553MnDmT9PR0MjIyyM7OBmDkyJGMGjWKlJQUhgwZwvnnn988zZw5c7jiiivo168fq1evbh6emZlJTk5O8zxuu+02Ro0a5fKpHIBf//rXzRdrAQoLC1ud56pVq7j//vsJCAggODiY5557joqKCiZOnEhNTQ3GGJ566imXv9cVflFa+Uz9ZX0hP3/9a65M78cfJ48iIKD1i0hKeSMtrey9OlNaWff023HD6P6UVtXym/e2ERcewmPXpLTZe0AppbyBJv0OzBk3lOKKWl787FviI23cfclZVoeklFJnTJO+Cx66YgQllXU8+eEO4iJsTM4eaHVISrmFMUaPXr1MZ0/Ja+8dFwQECL+flM5Fw+P55Zub+XDL91aHpFSnhYaGUlpaqlVmvYgxhtLSUkJDQ894Hnoh9zRU1zUw9cU1bP2unJdnjyV7cIzVISl1xurr6yksLOyw37rqXkJDQ+nfvz/BwcEnDXf1Qq4m/dN0pKqOSc9/waGKWl6f+wPO6RtldUhKKaUPRveUXuEhLJ09lvCQIKYvXMv+w1quQSnlPTTpn4HEnj1YMiubmvpGZuSupbSy1uqQlFLKJZr0z9DwvvZyDQeOHmPW4nVUabkGpZQX0KTfCVlJMTw7NZP8onLmvrKeuobjVoeklFLt0qTfSZcm9+G316Xx2c4S7l/5NcePd68L40op5UxvznKDm8YMoKSqlt9/sJ3YcBsPXzVCb3hRSnVLmvTd5M4L7eUacj+3l2u486KhVoeklFKn0KTvJiLCw1cmU1pZxxMfbCM2IoSbsgZ0PKFSSnUhTfpuFBAgPHnjSI5U1/HQG5uJCQvh0uQ+VoellFLN9EKum4UEBfDcraNJSYjiP/5vA+v3HrY6JKWUaqZJ3wMibEEsyhlDQs8ezFqcx46Dpz6STSmlrKBJ30NiI2wsnZWNLSiA6QvXcuCoaw9QVkopT9Kk70EDYsJYMiubqroGpi9cw5GqOqtDUkr5OU36HjaiXxQvTc9i/5FjzFy8juo6LdeglLKOJv0uMHZILH+cMopNhUe5a9kG6hu1XINSyhqa9LvIj1P68vh1afxjezEPrNyk5RqUUpbQfvpdaEr2QEoqavnfv+8gPtLGQxNGWB2SUsrPaNLvYndfMoziylr+/Olu4iJs3D5uiNUhKaX8iCb9LiYiPHp1CqWVdTz+3lZiI0K4PrO/1WEppfyEJn0LBAYI82+2l2v4xcpN9AoP4eLhva0OSynlB/RCrkVsQYH8edpozukXyV2vbGDDviNWh6SU8gOa9C0UGRrMopxsekfZmLV4HQWHtFyDUsqzNOlbLD7SXq4hKMBeruG7Mi3XoJTyHE363cCg2HAWzxxDeU0D0xeu5Wi1lmtQSnmGS0lfRC4Xke0iUiAiD7Yy3iYiKxzj14hIkmN4sIgsEZHNIrJVRB5yb/i+IzUxmhemj2ZvaTW3LcnjWF2j1SEppXxQh0lfRAKBZ4ErgGRgiogkt2g2GzhijBkGPAU84Rh+I2AzxqQBo4E7mjYI6lTnDY1jweQM1u87wt3/t4EGLdeglHIzV/b0s4ECY8xuY0wdsByY2KLNRGCJ4/1KYLzYnwxugHARCQJ6AHVAuVsi91ET0voxb2IqH287xENvbMYYLdeglHIfV/rpJwL7nT4XAmPbamOMaRCRMiAW+wZgIvAdEAbca4zRR0l1YNq5gyipqOUPH+8kLtLGA5efY3VISikf4UrSl1aGtdz9bKtNNtAIJAC9gM9E5CNjzO6TJhaZA8wBGDhwoAsh+b7/vPQsiitree4fu4iLsDH7gsFWh6SU8gGunN4pBAY4fe4PFLXVxnEqJxo4DEwFPjDG1BtjDgGfA1ktv8AY84IxJssYkxUfH3/6v8IHiQj/PTGVy1P68t9/+4a3Nx6wOiSllA9wJemvA84SkcEiEgJMBt5p0eYdYIbj/STgE2M/Gb0PuETswoFzgW3uCd33BQYICyZnMHZwDPe9/jWf7ii2OiSllJfrMOkbYxqAu4FVwFbgNWPMFhGZJyLXOJotBGJFpAD4GdDUrfNZIALIx77xWGSM2eTm3+DTQoMDeXFGFsN6RzL3lfV8vf+o1SEppbyYdLfeIVlZWSYvL8/qMLqdQ+U13PD8F1TVNrJy7g8YEh9hdUhKqW5ERNYbY045fd6S3pHrJXpHhbJ01lgEmLZwLQfLa6wOSSnlhTTpe5HBceEsnpnN0eo6ZuSupexYvdUhKaW8jCZ9L5PWP5o/T8tiV3Elty/Jo6ZeyzUopVynSd8LXXBWHPNvymDd3sPc8+q/tVyDUsplmvS91NUjE3j0qmQ+/OYgD7+dr+UalFIu0cclerGc8wdTUlnHM6sLiIuw8fPLhlsdklKqm9Ok7+V+ftnZFFfU8sdP7Il/xnlJVoeklOrGNOl7ORHh8etSOVxdx2N/3UJsRAhXpSdYHZZSqpvSc/o+ICgwgD9OGUXWoF7cu2IjnxeUWB2SUqqb0qTvI0KDA3lp+hiGxEUwZ2ke+QfKrA5JKdUNadL3IdFhwSydnU3PsBByFq1lT0mV1SEppboZTfo+pk9UKEtnZ9N43DA9dy2HKrRcg1LqBE36PmhofASLZmZTUlnLjNx1lNdouQallJ0mfR+VMaAnz906mp0HK5izVMs1KKXsNOn7sAvPjufJG0fy1e7D3LtiI43H9a5dpfydJn0fd+2oRP7ryhG8n/89j2i5BqX8nt6c5Qdu++EQSirreP6fu4iPtPGfl55tdUhKKYto0vcTD1w+nOKKWhZ8tJO4CBu3njvI6pCUUhbQpO8nRITf3ZDGkeo6Hn47n9jwEK5I62d1WEqpLqbn9P1IcGAAz07NZNSAnvx0+Ua+3FVqdUhKqS6mSd/P9AgJJDdnDINiw5izNI8tRVquQSl/oknfD/UMC2Hp7GwiQ4PIWbSOfaXVVoeklOoimvT9VL/oHiydnU1943Gm566hpLLW6pCUUl1Ak74fG9Y7koUzxvB9eQ05i9ZSWdtgdUhKKQ/TpO/nRg/qxXO3jGbrdxXc8XIetQ1arkEpX6ZJX3HxOb35/Q3pfF5Qys9e+5rjWq5BKZ+l/fQVADeM7k9JZS2/fX8bceEhPHZNCiJidVhKKTfTpK+a3XHhUEoqa3nxs2+Jj7Rx9yVnWR2SUsrNNOmrkzx0xQhKKut48sMdxEXYmJw90OqQlFJupElfnSQgQPj9pHQOV9Xxyzc3ExMewmUpfa0OSynlJnohV50iODCA527NJK1/T37y6r9Z++1hq0NSSrmJJn3VqrCQIBbljCGxVw9mL1nHtu/LrQ5JKeUGmvRVm2LCQ3h59ljCQ4KYvnAt+w9ruQalvJ1LSV9ELheR7SJSICIPtjLeJiIrHOPXiEiSY/gtIrLR6XVcRDLc+xOUJyX27MGSWdnU1DcyI3ctpVquQSmv1mHSF5FA4FngCiAZmCIiyS2azQaOGGOGAU8BTwAYY5YZYzKMMRnANGCPMWajO3+A8rzhfSNZmDOGA0ePMWvxOqq0XINSXsuVPf1soMAYs9sYUwcsBya2aDMRWOJ4vxIYL6fe2TMFeLUzwSrrjEmK4dmpmeQXlTP3lfXUNRy3OiSl1BlwJeknAvudPhc6hrXaxhjTAJQBsS3a3Iwmfa92aXIffntdGp/tLOH+lVquQSlv5Eo//dbuxW/5v73dNiIyFqg2xuS3+gUic4A5AAMH6s1A3dlNYwZQXFnL/6zaTmy4jYevGqHlGpTyIq7s6RcCA5w+9weK2mojIkFANODcuXsy7ezlG2NeMMZkGWOy4uPjXYlbWeiui4Yy8/wkcj//luf/udvqcJRSp8GVPf11wFkiMhg4gD2BT23R5h1gBvAlMAn4xBhjAEQkALgRGOeuoJW1RISHr0ymtLKOJz7YRmxECDdlDeh4QqWU5TpM+saYBhG5G1gFBAK5xpgtIjIPyDPGvAMsBF4WkQLse/iTnWYxDig0xuguoQ8JCBCevHEkR6rreOiNzcSGhzB+RB+rw1JKdUAcO+TdRlZWlsnLy7M6DOWiytoGpr74FTsOVrDstrGMHhRjdUhK+SURWW+Myeqond6RqzolwmYv19AvugezFuex42CF1SEppdqhSV91WmyEjaWzsrEFBTB94VoOHD1mdUhKqTZo0lduMSAmjCWzsqmqbWD6wjUcqaqzOiSlVCs06Su3GdEvipdmZLH/yDFmLl5HdZ2Wa1Cqu9Gkr9xq7JBY/jhlFJsKj3LXsg3UN2q5BqW6E036yu1+nNKXX1+bxj+2F/PAyk1arkGpbkQfl6g8YurYgZRU1jL/7zuIj7Tx0IQRVoeklEKTvvKgn1wyjJLKWv786W7iImzcPm6I1SEp5fc06SuPEREevTqF0so6Hn9vK7ERIVyf2d/qsJTya5r0lUcFBgjzb7aXa/jFyk30Cg/h4uG9rQ5LKb+lF3KVx9mCAvnztNEM7xvJXa9s4N/7jlgdklJ+S5O+6hKRocEsnplN7ygbMxevo+CQlmtQygqa9FWXiY+0l2sICrCXa/iuTMs1KNXVNOmrLjUoNpzFM8dQXtPA9IVrOVqt5RqU6kqa9FWXS02M5oXpo9lbWs1tS/I4VtdodUhK+Q1N+soS5w2NY8HkDNbvO8Ld/7eBBi3XoFSX0KSvLDMhrR/zJqby8bZDPPTGZrrbA32U8kXaT19Zatq5gyiuqOXpj3cSH2njF5efY3VISvk0TfrKcvdeehYllbX86R+7iIuwMeuCwVaHpJTP0qSvLCci/PfEVA5X1jHvb98QGxHCxIxEq8NSyifpOX3VLQQGCAsmZzB2cAz3vf41n+4otjokpXySJn3VbYQGB/LijCyG9Y5k7ivr+Xr/UatDUsrnaNJX3UpUaDBLZo4hNiKEmYvXsbu40uqQlPIpmvRVt9M7KpSls8YiwLSFazlYXmN1SEr5DE36qlsaHBfO4pnZHK2uY0buWsqO1VsdklI+QZO+6rbS+kfz52lZ7Cqu5PYledTUa7kGpTpLk77q1i44K475N2Wwbu9h7nn131quQalO0qSvur2rRybw6FXJfPjNQR5+O1/LNSjVCXpzlvIKOecPpriylmdX7yI+wsbPLhtudUhKeSVN+spr3HfZcEoq6nj6kwJiI2zMOC/J6pCU8jqa9JXXEBEevy6V0qo6HvvrFmIjQrgqPcHqsJTyKnpOX3mVoMAAnpk6iqxBvbh3xUY+LyixOiSlvIomfeV1QoMDeWn6GIbERTBnaR75B8qsDkkpr+FS0heRy0Vku4gUiMiDrYy3icgKx/g1IpLkNC5dRL4UkS0isllEQt0XvvJX0WHBLJmVTc+wEHIWrWVPSZXVISnlFTpM+iISCDwLXAEkA1NEJLlFs9nAEWPMMOAp4AnHtEHAK8BcY0wKcBGgt1Yqt+gbHcrS2dk0HjdMz13LoQot16BUR1zZ088GCowxu40xdcByYGKLNhOBJY73K4HxIiLAZcAmY8zXAMaYUmOM3lap3GZofASLZmZTXFHLjNx1lNfoPoVS7XEl6ScC+50+FzqGtdrGGNMAlAGxwNmAEZFVIrJBRH7R+ZCVOlnGgJ48P200Ow9WMGeplmtQqj2uJH1pZVjLWyLbahMEXADc4vj3OhEZf8oXiMwRkTwRySsu1odnqNN34dnxPHnjSL7afZh7V2yk8bjetatUa1xJ+oXAAKfP/YGitto4zuNHA4cdw/9pjCkxxlQD7wGZLb/AGPOCMSbLGJMVHx9/+r9CKeDaUYn815UjeD//ex7Rcg1KtcqVpL8OOEtEBotICDAZeKdFm3eAGY73k4BPjP1/3CogXUTCHBuDC4Fv3BO6Uqe67YdDuOPCISxbs4+nPy6wOhylup0O78g1xjSIyN3YE3ggkGuM2SIi84A8Y8w7wELgZREpwL6HP9kx7RERmY99w2GA94wx73rotygFwIOXn0NJRR1PfbSD2IgQbj13kNUhKdVtSHc7BM7KyjJ5eXlWh6G8XH3jce54eT2rtx/iT1MzuSKtn9UhKeVRIrLeGJPVUTu9I1f5pODAAJ6dmsmoAT356fKNfLmr1OqQlOoWNOkrn9UjJJDcnDEMjA1jztI8thRpuQalNOkrn9YzLISls7KJCA0iZ9E69pVWWx2SUpbSpK98XkLPHrw8O5v6xuNMz11DSWWt1SEpZRlN+sovDOsdycIZY/i+vIacRWuprG2wOiSlLKFJX/mN0YN68adbMtn6XQV3vJxHbYOWa1D+R5O+8iuXnNOH39+QzucFpfz8ta85ruUalJ/RxyUqv3PD6P6UVNby2/e3ERsewmPXpGAvCquU79Okr/zSnHFDKK6o5aV/fUt8pI27LznL6pCU6hKa9JVfEhF+OWEEpVV1PPnhDuIibEzOHmh1WEp5nCZ95bcCAoTfT0rncFUdv3xzMzHhIVyW0tfqsJTyKL2Qq/xacGAAf7olk7T+PfnJq/9m7beHrQ5JKY/SpK/8XrgtiEU5Y0js1YPZS9ax7ftyq0NSymM06SsFxITbyzWEhwQxfeFa9h/Wcg3KN2nSV8qhf68wlszKpqa+kRm5aynVcg3KB2nSV8rJ8L6RLMwZw4Gjx5i1eB1VWq5B+RhN+kq1MCYphmemZpJfVM7cV9ZT13Dc6pCUchtN+kq14kfJffjtdWl8trOE+1dquQblO7SfvlJtuGnMAIora/mfVduJDbfx8FUjtFyD8nqa9JVqx10XDaW4opbcz+3lGu68aKjVISnVKZr0lWqHiPDIVckcrqrjiQ+28eXuUtITo0lNjCY1MYrEnj107195FU36SnUgIEB48saRxEXY+GJXCc8VlNDoOMffKyzYsQGIJjUhmrTEaAbE6IZAdV+a9JVyQUhQAI9cnQzAsbpGtn1fTv6BMvIPlLP5QBkvfrqbBseGICo06MSGIDGa1IQokmLDCQjQDYGyniZ9pU5Tj5BARg3sxaiBvZqH1TY0sv37iuaNwJaiMhZ/voe6Rnt3zwhbEMkJUaQ5TgulJUYzOC6CQN0QqC6mSV8pN7AFBZLevyfp/Xs2D6trOM7OQxUnHRG88tVeah39/sNCAknuF+V0VBDFsPgIggK1J7XyHDGme/U/zsrKMnl5eVaHoZRHNDQep6C4kvwDTaeHythSVM6xevvzem1BAYzod+KIIDUxmrN6RxISpBsC1T4RWW+MyeqwnSZ9pazVeNzwbUll89FA04ag0lECIiQwgHP6RZKScOLU0PC+kdiCAi2OXHUnmvSV8mLHjxv2Hq62Xx84UNa8MSivsW8IggKEs/tENm8EUhKjSe4XRWiwbgj8lf8l/Yrv4ctnISoRohJO/BvRGwL0P4LyfsYY9h8+Rn7RiY1A/oEyjlTXAxAYIAyLj2i1VUG7AAANNklEQVS+PpCWGM2IflGE2/TSnT9wNen7ztpwdD+s+TM0tiiHK4EQ2c+xIXDaGDi/j+wLgcHWxK2Ui0SEgbFhDIwNY0JaP8C+ISgqq2Fzob3H0OYDZfxzxyH+sqHQMQ0MjY8gNeHEBeOUhCgiQ3V991e+s6cPYAxUH4byA1Be5PRv0cnD6ls+IEMgog9E9Wt9oxCVAJEJEBza6d+nlKcZYzhYXku+47RQ08bgYPmJHaLBceHN9xCkJUaTkhBNdJhuCLyZ/53ecZUxUFPW+sageVgR1JadOm1YbNtHC03/hoR7LnalOuFQRQ1bHL2GNjsuFh84eqx5/MCYsOYeQ6kJ9qOCmPAQCyNWp0OTfmfVVkD5d20cLTjeH2vlIdqh0W0fLTS9t0XZj7uVslhpZS1bik7cUJZ/oJx9To+KTOzZg5Tmm8rsr/hIm4URq7a4NemLyOXAH4BA4CVjzO9ajLcBS4HRQClwszFmj4gkAVuB7Y6mXxlj5rb3Xd0m6bui/tjJRwetbSCqDp06XUhE+xuFqETo0Us3DMoSZdX1zaeE8ovsRwbfllQ1j+8TZWs+JdS0MegTZdN6QxZz24VcEQkEngV+BBQC60TkHWPMN07NZgNHjDHDRGQy8ARws2PcLmNMxmn/Am8Q3ANih9pfbWmog4rv7K/WNgq7/2EfZ1o8nSkotPWNQvNF6UQIj4cAvWlHuVd0WDDnDYvjvGFxzcMqaurZUnTihrL8onI+3naIpn3GuAjbie6jCdGk9Y8mITpUNwTdkCu9d7KBAmPMbgARWQ5MBJyT/kTgMcf7lcAzon9tu6AQ6DXI/mpLY4P9iKCtawz7vrSfajpef/J0AcEteia1co0hog8E+k4nLWWNyNBgzh0Sy7lDYpuHVdU2sPW7phvK7BuET3cU0/SQsZjwEFIcvYbSHNcJtAKp9VzJBonAfqfPhcDYttoYYxpEpAxoWjsGi8i/gXLgv4wxn3UuZB8UGHQiadPG0dnx41Bd0vY1hu82wvb3oKHm5OkkACL6dtBltZ9946TUaQi3BZGVFENWUkzzsGN1jWz9vtzphrLyViuQNt1QlpYYzaCYMK1A2oVcSfqt/TVaXghoq813wEBjTKmIjAbeEpEUY0z5SROLzAHmAAwcONCFkPxQQID9RrOI3pAwqvU2xsCxI213WS3eBgUfQ33VqdOG927nGoPjFdzDs79Reb0eIYFkDuxFplMF0pr6RnYcrDjpiGCRUwXSSEcF0uYjgsQorUDqQa4k/UJggNPn/kBRG20KRSQIiAYOG/tV4loAY8x6EdkFnA2cdKXWGPMC8ALYL+Sewe9QYL/wGxZjf/VNa72NMVBb3mKj4HS94cge2Ps51Bw9ddoeMe1vFKISwBbp0Z+ovE9ocOsVSHccrDhxwfhAebsVSNMSoxkaH64VSN2gw947jiS+AxgPHADWAVONMVuc2vwHkGaMmeu4kHu9MeYmEYnHnvwbRWQI8JmjXSt9He28qveOL6uratFltZXTStUlp05ni2r/GkNUAoT21J5J6hRNFUjtdxeXawXS0+TuLpsTgAXYu2zmGmMeF5F5QJ4x5h0RCQVeBkYBh4HJxpjdInIDMA9oABqBR40xf23vuzTpe5H6GkevpHZudKs8yClnA4PDOu6yGharGwbVXIF0s9MzCb5powJp08bAXyuQ6s1ZqntorLcXw2uzLEaRo8tq48nTBdraL4vR3GXV//5z+7vjxw17Squa7yHIb6MCqfMRwQg/qECqSV95j+ONUNlKl9XmowjHsMa6k6cLCOq4mF5EX+2y6geaKpDabygray41cdSpAulZvSMcRwT2DUFyQhRhIb6zbmjSV77FGKgubf8aQ9kBaDh28nQS4Cim51Q4r7WL0EFaWsDXGGM4cPTYiaeUOTYGJZX2nYemCqRpjsqjaY4NgbdWINWkr/yPMfZeRx0W0ys/ddqwuA6K6fXTYno+oKkCafPzCAqPkl9UxsGKExVIh8aGkdJ0aijBvkGI7hHcckYt59zal51+Gwk443tm/K+evlIi9ppFPXpBn5S229WUt10Wo2w/7P/Kfr9DS6HR9vIYzjz1n/+M23Q4oBvG3HVtBOjreP3IeYTzn7UKe3/FHad+hcelXA83LvLoV2jSV/4nNMr+ih/edpu66hYbhgOtl8IATrk3sdVeR97YpuUkVsfTtW2q6xo4VFHLwfIaDlbUcaiihrLqE3//yB4h9Imy0SfSRu+oUPpE9yA8pOXF4tOMp7110k006SvVmpCwjovpKZ8WBiQ5Xk2OVtc130OwyXEfwbfbT9zh3jcq9KTHVdorkHavhy9p0ldKKRf1DAvh/GFxnO9UgbS8pp5vnLqPbj5QxsfbDjafbYqPtJ30uMrURGsrkGrSV0qpTohqowLpN985PaXsQDn/bKUCaZpTmYn+vbqmAqkmfaWUcrNwWxBjkmIY00oF0hNHBOW84FSBNLpHMDeO7s9/XZXs0dg06SulVBdoqwLp9u8rHPcQlJPQ0/OVbDXpK6WURUKDAxk5oCcjB/TsuLGbaHk6pZTyI5r0lVLKj2jSV0opP6JJXyml/IgmfaWU8iOa9JVSyo9o0ldKKT+iSV8ppfxIt3uIiogUA3s7MYs4oMRN4biTxnV6NK7To3GdHl+Ma5AxJr6jRt0u6XeWiOS58vSYrqZxnR6N6/RoXKfHn+PS0ztKKeVHNOkrpZQf8cWk/4LVAbRB4zo9Gtfp0bhOj9/G5XPn9JVSSrXNF/f0lVJKtcFrkr6IXC4i20WkQEQebGW8TURWOMavEZEkp3EPOYZvF5Efd3FcPxORb0Rkk4h8LCKDnMY1ishGx+udLo4rR0SKnb7/NqdxM0Rkp+M1o4vjesopph0ictRpnCeXV66IHBKR/DbGi4g87Yh7k4hkOo3z5PLqKK5bHPFsEpEvRGSk07g9IrLZsbzyujiui0SkzOnv9YjTuHbXAQ/Hdb9TTPmOdSrGMc6Ty2uAiKwWka0iskVEftpKm65Zx4wx3f4FBAK7gCFACPA1kNyizV3A8473k4EVjvfJjvY2YLBjPoFdGNfFQJjj/Z1NcTk+V1q4vHKAZ1qZNgbY7fi3l+N9r66Kq0X7nwC5nl5ejnmPAzKB/DbGTwDeBwQ4F1jj6eXlYlznNX0fcEVTXI7Pe4A4i5bXRcDfOrsOuDuuFm2vBj7pouXVD8h0vI8EdrTyf7JL1jFv2dPPBgqMMbuNMXXAcmBiizYTgSWO9yuB8SIijuHLjTG1xphvgQLH/LokLmPMamNMtePjV0B/N313p+Jqx4+BvxtjDhtjjgB/By63KK4pwKtu+u52GWM+BQ6302QisNTYfQX0FJF+eHZ5dRiXMeYLx/dC161friyvtnRm3XR3XF25fn1njNngeF8BbAUSWzTrknXMW5J+IrDf6XMhpy6w5jbGmAagDIh1cVpPxuVsNvYteZNQEckTka9E5Fo3xXQ6cd3gOIxcKSIDTnNaT8aF4zTYYOATp8GeWl6uaCt2Ty6v09Vy/TLAhyKyXkTmWBDPD0TkaxF5X0RSHMO6xfISkTDsifMvToO7ZHmJ/dTzKGBNi1Fdso55yzNypZVhLbsdtdXGlWnPlMvzFpFbgSzgQqfBA40xRSIyBPhERDYbY3Z1UVx/BV41xtSKyFzsR0mXuDitJ+NqMhlYaYxpdBrmqeXlCivWL5eJyMXYk/4FToPPdyyv3sDfRWSbY0+4K2zAXhagUkQmAG8BZ9FNlhf2UzufG2Ocjwo8vrxEJAL7huY/jTHlLUe3Monb1zFv2dMvBAY4fe4PFLXVRkSCgGjsh3muTOvJuBCRS4FfAdcYY2qbhhtjihz/7gb+gX3r3yVxGWNKnWJ5ERjt6rSejMvJZFocentwebmirdg9ubxcIiLpwEvARGNMadNwp+V1CHgT953W7JAxptwYU+l4/x4QLCJxdIPl5dDe+uWR5SUiwdgT/jJjzButNOmadcwTFy3c/cJ+RLIb++F+08WflBZt/oOTL+S+5nifwskXcnfjvgu5rsQ1CvuFq7NaDO8F2Bzv44CduOmClotx9XN6fx3wlTlx0ehbR3y9HO9juiouR7vh2C+qSVcsL6fvSKLtC5NXcvJFtrWeXl4uxjUQ+3Wq81oMDwcind5/AVzehXH1bfr7YU+e+xzLzqV1wFNxOcY37RCGd9Xycvz2pcCCdtp0yTrmtgXt6Rf2K9s7sCfQXzmGzcO+9wwQCrzu+A+wFhjiNO2vHNNtB67o4rg+Ag4CGx2vdxzDzwM2O1b6zcDsLo7rt8AWx/evBs5xmnaWYzkWADO7Mi7H58eA37WYztPL61XgO6Ae+57VbGAuMNcxXoBnHXFvBrK6aHl1FNdLwBGn9SvPMXyIY1l97fg7/6qL47rbaf36CqeNUmvrQFfF5WiTg71zh/N0nl5eF2A/JbPJ6W81wYp1TO/IVUopP+It5/SVUkq5gSZ9pZTyI5r0lVLKj2jSV0opP6JJXyml/IgmfaWU8iOa9JVSyo9o0ldKKT/y/wGW2pVLT+rsIwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(history3.history['loss'], label=\"Loss\")\n",
    "plt.plot(history3.history['val_loss'], label=\"Validation Loss\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation Precision: [0.81209964412811386, 0.86330935251798557, 0.0, 0.75497702909647779, 0.6875],\n",
      "\n",
      "Validation Recall: [0.78581267217630857, 0.73891625615763545, 0.0, 0.661744966442953, 0.18803418803418803]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\insuf\\AppData\\Local\\conda\\conda\\envs\\python352\\lib\\site-packages\\sklearn\\metrics\\classification.py:1135: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 due to no predicted samples.\n",
      "  'precision', 'predicted', average, warn_for)\n"
     ]
    }
   ],
   "source": [
    "val_predict3 = (np.asarray(model3.predict([X_val], batch_size=512))).round()\n",
    "\n",
    "val_precision3 = []\n",
    "val_recall3 = []\n",
    "for i in range(5):\n",
    "    val_precision3.append(metrics.precision_score(val_target[:,i], val_predict3[:,i]))\n",
    "    val_recall3.append(metrics.recall_score(val_target[:,i], val_predict3[:,i]))\n",
    "\n",
    "print(\"Validation Precision: {},\\n\\nValidation Recall: {}\".format(val_precision3, val_recall3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.bar(np.arange(5) - 0.3/2,val_precision,0.3,label=\"Baseline Validation Precision\", tick_label=names)\n",
    "plt.bar(np.arange(5) + 0.3/2,val_precision3,0.3,label=\"GoogleNews Validation Precision\", tick_label=names)\n",
    "plt.legend(loc='right', bbox_to_anchor=(1.6,0.5))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.bar(np.arange(5) - 0.3/2,val_recall,0.3,label=\"Baseline Validation Recall\", tick_label=names)\n",
    "plt.bar(np.arange(5) + 0.3/2,val_recall3,0.3,label=\"GoogleNews Validation Recall\", tick_label=names)\n",
    "plt.legend(loc='right', bbox_to_anchor=(1.55,0.5))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Glove Twitter 27B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from gensim.scripts.glove2word2vec import glove2word2vec\n",
    "# glove2word2vec(r\"C:\\Users\\insuf\\Desktop\\glove.twitter.27B.25d.txt\", r\"C:\\Users\\insuf\\Desktop\\glove.twitter.27B.25d.w2v.txt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\insuf\\AppData\\Local\\conda\\conda\\envs\\python352\\lib\\site-packages\\ipykernel_launcher.py:5: DeprecationWarning: Call to deprecated `wv` (Attribute will be removed in 4.0.0, use self instead).\n",
      "  \"\"\"\n",
      "C:\\Users\\insuf\\AppData\\Local\\conda\\conda\\envs\\python352\\lib\\site-packages\\ipykernel_launcher.py:6: DeprecationWarning: Call to deprecated `wv` (Attribute will be removed in 4.0.0, use self instead).\n",
      "  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded 1193515 word vectors.\n",
      "total embedded: 18569 common words\n"
     ]
    }
   ],
   "source": [
    "glove = gensim.models.keyedvectors.KeyedVectors.load_word2vec_format(r\"C:\\Users\\insuf\\Desktop\\glove.twitter.27B.25d.w2v.txt\")\n",
    "\n",
    "embed_size = 25\n",
    "embeddings_index = dict()\n",
    "for word in glove.wv.vocab:\n",
    "    embeddings_index[word] = glove.wv[word]\n",
    "print('Loaded %s word vectors.' % len(embeddings_index))\n",
    "\n",
    "nb_words = min(max_features, len(tokenizer.word_index))\n",
    "embedding_matrix = np.zeros((nb_words, embed_size))\n",
    "\n",
    "embeddedCount = 0\n",
    "for word, i in tokenizer.word_index.items():\n",
    "    if i >= max_features: continue\n",
    "    embedding_vector = embeddings_index.get(word)\n",
    "    if embedding_vector is not None:\n",
    "        # words not found in embedding index will be all-zeros.\n",
    "        embedding_matrix[i] = embedding_vector\n",
    "        embeddedCount += 1\n",
    "print('total embedded:',embeddedCount,'common words')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "embedding_4 (Embedding)      (None, 100, 25)           500000    \n",
      "_________________________________________________________________\n",
      "bidirectional_4 (Bidirection (None, 200)               100800    \n",
      "_________________________________________________________________\n",
      "dense_7 (Dense)              (None, 50)                10050     \n",
      "_________________________________________________________________\n",
      "dropout_4 (Dropout)          (None, 50)                0         \n",
      "_________________________________________________________________\n",
      "dense_8 (Dense)              (None, 5)                 255       \n",
      "=================================================================\n",
      "Total params: 611,105\n",
      "Trainable params: 611,105\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model4 = Sequential()\n",
    "model4.add(Embedding(max_features,embed_size,weights=[embedding_matrix],input_length=maxlen))\n",
    "model4.add(Bidirectional(LSTM(100,dropout=0.1,recurrent_dropout=0.1)))\n",
    "model4.add(Dense(50, activation=\"relu\"))\n",
    "model4.add(Dropout(0.1))\n",
    "model4.add(Dense(5, activation=\"sigmoid\"))\n",
    "model4.compile(loss='binary_crossentropy',optimizer='adam',metrics=[auc])\n",
    "model4.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 143613 samples, validate on 15958 samples\n",
      "Epoch 1/10\n",
      "143613/143613 [==============================] - 155s 1ms/step - loss: 0.1022 - auc: 0.8204 - val_loss: 0.0560 - val_auc: 0.9273\n",
      "Epoch 2/10\n",
      "143613/143613 [==============================] - 149s 1ms/step - loss: 0.0609 - auc: 0.9451 - val_loss: 0.0512 - val_auc: 0.9552\n",
      "Epoch 3/10\n",
      "143613/143613 [==============================] - 147s 1ms/step - loss: 0.0562 - auc: 0.9605 - val_loss: 0.0507 - val_auc: 0.9641\n",
      "Epoch 4/10\n",
      "143613/143613 [==============================] - 150s 1ms/step - loss: 0.0533 - auc: 0.9668 - val_loss: 0.0488 - val_auc: 0.9689\n",
      "Epoch 5/10\n",
      "143613/143613 [==============================] - 151s 1ms/step - loss: 0.0509 - auc: 0.9707 - val_loss: 0.0476 - val_auc: 0.9722\n",
      "Epoch 6/10\n",
      "143613/143613 [==============================] - 150s 1ms/step - loss: 0.0486 - auc: 0.9735 - val_loss: 0.0472 - val_auc: 0.9745\n",
      "Epoch 7/10\n",
      "143613/143613 [==============================] - 151s 1ms/step - loss: 0.0468 - auc: 0.9755 - val_loss: 0.0474 - val_auc: 0.9764\n"
     ]
    }
   ],
   "source": [
    "with tf.device('/gpu:0'):\n",
    "    history4 = model4.fit(X_train,y_train,batch_size=256,epochs=10,validation_data=(X_val, y_val), callbacks=[early])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(history4.history['auc'], label=\"AUC\")\n",
    "plt.plot(history4.history['val_auc'], label=\"Validation AUC\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(history4.history['loss'], label=\"Loss\")\n",
    "plt.plot(history4.history['val_loss'], label=\"Validation Loss\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation Precision: [0.85836575875486376, 0.82170542635658916, 0.0, 0.74891146589259794, 0.68000000000000005],\n",
      "\n",
      "Validation Recall: [0.75964187327823696, 0.78325123152709364, 0.0, 0.69261744966442951, 0.14529914529914531]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\insuf\\AppData\\Local\\conda\\conda\\envs\\python352\\lib\\site-packages\\sklearn\\metrics\\classification.py:1135: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 due to no predicted samples.\n",
      "  'precision', 'predicted', average, warn_for)\n"
     ]
    }
   ],
   "source": [
    "val_predict4 = (np.asarray(model4.predict([X_val], batch_size=512))).round()\n",
    "\n",
    "val_precision4 = []\n",
    "val_recall4 = []\n",
    "for i in range(5):\n",
    "    val_precision4.append(metrics.precision_score(val_target[:,i], val_predict4[:,i]))\n",
    "    val_recall4.append(metrics.recall_score(val_target[:,i], val_predict4[:,i]))\n",
    "\n",
    "print(\"Validation Precision: {},\\n\\nValidation Recall: {}\".format(val_precision4, val_recall4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.bar(np.arange(5) - 0.3/2,val_precision,0.3,label=\"Baseline Validation Precision\", tick_label=names)\n",
    "plt.bar(np.arange(5) + 0.3/2,val_precision4,0.3,label=\"GloVe Validation Precision\", tick_label=names)\n",
    "plt.legend(loc='right', bbox_to_anchor=(1.6,0.5))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.bar(np.arange(5) - 0.3/2,val_recall,0.3,label=\"Baseline Validation Recall\", tick_label=names)\n",
    "plt.bar(np.arange(5) + 0.3/2,val_recall4,0.3,label=\"GloVe Validation Recall\", tick_label=names)\n",
    "plt.legend(loc='right', bbox_to_anchor=(1.55,0.5))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# add more LSTM nodes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "embedding_5 (Embedding)      (None, 100, 25)           500000    \n",
      "_________________________________________________________________\n",
      "bidirectional_5 (Bidirection (None, 400)               361600    \n",
      "_________________________________________________________________\n",
      "dense_9 (Dense)              (None, 100)               40100     \n",
      "_________________________________________________________________\n",
      "dropout_5 (Dropout)          (None, 100)               0         \n",
      "_________________________________________________________________\n",
      "dense_10 (Dense)             (None, 5)                 505       \n",
      "=================================================================\n",
      "Total params: 902,205\n",
      "Trainable params: 902,205\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model9 = Sequential()\n",
    "model9.add(Embedding(max_features,embed_size,weights=[embedding_matrix],input_length=maxlen))\n",
    "model9.add(Bidirectional(LSTM(200,dropout=0.1,recurrent_dropout=0.1)))\n",
    "model9.add(Dense(100, activation=\"relu\"))\n",
    "model9.add(Dropout(0.1))\n",
    "model9.add(Dense(5, activation=\"sigmoid\"))\n",
    "model9.compile(loss='binary_crossentropy',optimizer='adam',metrics=[auc])\n",
    "model9.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 143613 samples, validate on 15958 samples\n",
      "Epoch 1/10\n",
      "143613/143613 [==============================] - 152s 1ms/step - loss: 0.0929 - auc: 0.8498 - val_loss: 0.0550 - val_auc: 0.9403\n",
      "Epoch 2/10\n",
      "143613/143613 [==============================] - 147s 1ms/step - loss: 0.0592 - auc: 0.9534 - val_loss: 0.0519 - val_auc: 0.9609\n",
      "Epoch 3/10\n",
      "143613/143613 [==============================] - 155s 1ms/step - loss: 0.0549 - auc: 0.9652 - val_loss: 0.0500 - val_auc: 0.9681\n",
      "Epoch 4/10\n",
      "143613/143613 [==============================] - 162s 1ms/step - loss: 0.0517 - auc: 0.9703 - val_loss: 0.0473 - val_auc: 0.9721\n",
      "Epoch 5/10\n",
      "143613/143613 [==============================] - 146s 1ms/step - loss: 0.0491 - auc: 0.9736 - val_loss: 0.0469 - val_auc: 0.9749\n",
      "Epoch 6/10\n",
      "143613/143613 [==============================] - 146s 1ms/step - loss: 0.0469 - auc: 0.9760 - val_loss: 0.0468 - val_auc: 0.9769\n",
      "Epoch 7/10\n",
      "143613/143613 [==============================] - 145s 1ms/step - loss: 0.0449 - auc: 0.9778 - val_loss: 0.0473 - val_auc: 0.9785\n"
     ]
    }
   ],
   "source": [
    "with tf.device('/gpu:0'):\n",
    "    history9 = model9.fit(X_train,y_train,batch_size=256,epochs=10,validation_data=(X_val, y_val), callbacks=[early])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation Precision: [0.85225505443234839, 0.85402455661664389, 0.0, 0.76453055141579729, 0.59154929577464788],\n",
      "\n",
      "Validation Recall: [0.75482093663911842, 0.77093596059113301, 0.0, 0.68859060402684569, 0.35897435897435898]\n"
     ]
    }
   ],
   "source": [
    "val_predict9 = (np.asarray(model9.predict([X_val], batch_size=512))).round()\n",
    "\n",
    "val_precision9 = []\n",
    "val_recall9 = []\n",
    "for i in range(5):\n",
    "    val_precision9.append(metrics.precision_score(val_target[:,i], val_predict9[:,i]))\n",
    "    val_recall9.append(metrics.recall_score(val_target[:,i], val_predict9[:,i]))\n",
    "\n",
    "print(\"Validation Precision: {},\\n\\nValidation Recall: {}\".format(val_precision9, val_recall9))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.bar(np.arange(5)-0.3/2, val_precision9, 0.3, label=\"Baseline Validation Precision\", tick_label=names)\n",
    "plt.bar(np.arange(5)+0.3/2, val_recall9, 0.3, label=\"Baseline Validation Recall\", tick_label=names)\n",
    "\n",
    "plt.legend(loc='right', bbox_to_anchor=(1.6,0.5))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.bar(np.arange(5)-0.3/2, val_precision, 0.3, label=\"Baseline 100 Validation Precision\", tick_label=names)\n",
    "plt.bar(np.arange(5)+0.3/2, val_precision9, 0.3, label=\"Baseline 200 Validation Precision\", tick_label=names)\n",
    "\n",
    "plt.legend(loc='right', bbox_to_anchor=(1.65,0.5))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.bar(np.arange(5)-0.3/2, val_recall, 0.3, label=\"Baseline 100 Validation Recall\", tick_label=names)\n",
    "plt.bar(np.arange(5)+0.3/2, val_recall9, 0.3, label=\"Baseline 200 Validation Recall\", tick_label=names)\n",
    "\n",
    "plt.legend(loc='right', bbox_to_anchor=(1.6,0.5))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Penalizing loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "embedding_12 (Embedding)     (None, 100, 25)           500000    \n",
      "_________________________________________________________________\n",
      "bidirectional_12 (Bidirectio (None, 200)               100800    \n",
      "_________________________________________________________________\n",
      "dense_23 (Dense)             (None, 50)                10050     \n",
      "_________________________________________________________________\n",
      "dropout_12 (Dropout)         (None, 50)                0         \n",
      "_________________________________________________________________\n",
      "dense_24 (Dense)             (None, 5)                 255       \n",
      "=================================================================\n",
      "Total params: 611,105\n",
      "Trainable params: 611,105\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model5 = Sequential()\n",
    "model5.add(Embedding(max_features,embed_size,weights=[embedding_matrix],input_length=maxlen))\n",
    "model5.add(Bidirectional(LSTM(100,dropout=0.1,recurrent_dropout=0.1)))\n",
    "model5.add(Dense(50, activation=\"relu\"))\n",
    "model5.add(Dropout(0.1))\n",
    "model5.add(Dense(5, activation=\"sigmoid\"))\n",
    "model5.compile(loss='binary_crossentropy',optimizer='adam',metrics=[auc])\n",
    "model5.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [],
   "source": [
    "early = EarlyStopping(monitor=\"val_loss\", mode=\"min\", patience=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "# cw = {0:1, 1:10, 2:17, 3:300, 4:18, 5:102}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "def create_class_weight(labels_dict,mu=0.15):\n",
    "    total = sum(labels_dict.values())\n",
    "    keys = labels_dict.keys()\n",
    "    class_weight = dict()\n",
    "\n",
    "    for key in keys:\n",
    "        score = math.log(mu*total/float(labels_dict[key]))\n",
    "        class_weight[key] = score if score > 1.0 else 1.0\n",
    "\n",
    "    return class_weight\n",
    "\n",
    "labels_dict = {0: 143346, 1: 15294, 2: 8449, 3: 478, 4: 7877, 5: 1405}\n",
    "cw = create_class_weight(labels_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 143613 samples, validate on 15958 samples\n",
      "Epoch 1/100\n",
      "143613/143613 [==============================] - 176s 1ms/step - loss: 0.1085 - auc: 0.8128 - val_loss: 0.0602 - val_auc: 0.9276\n",
      "Epoch 2/100\n",
      "143613/143613 [==============================] - 167s 1ms/step - loss: 0.0657 - auc: 0.9452 - val_loss: 0.0516 - val_auc: 0.9554\n",
      "Epoch 3/100\n",
      "143613/143613 [==============================] - 161s 1ms/step - loss: 0.0610 - auc: 0.9607 - val_loss: 0.0505 - val_auc: 0.9644\n",
      "Epoch 4/100\n",
      "143613/143613 [==============================] - 168s 1ms/step - loss: 0.0579 - auc: 0.9671 - val_loss: 0.0487 - val_auc: 0.9692\n",
      "Epoch 5/100\n",
      "143613/143613 [==============================] - 168s 1ms/step - loss: 0.0554 - auc: 0.9709 - val_loss: 0.0475 - val_auc: 0.9724\n",
      "Epoch 6/100\n",
      "143613/143613 [==============================] - 160s 1ms/step - loss: 0.0529 - auc: 0.9736 - val_loss: 0.0471 - val_auc: 0.9748\n",
      "Epoch 7/100\n",
      "143613/143613 [==============================] - 163s 1ms/step - loss: 0.0509 - auc: 0.9757 - val_loss: 0.0472 - val_auc: 0.9766\n",
      "Epoch 8/100\n",
      "143613/143613 [==============================] - 166s 1ms/step - loss: 0.0489 - auc: 0.9774 - val_loss: 0.0476 - val_auc: 0.9781\n",
      "Epoch 9/100\n",
      "143613/143613 [==============================] - 170s 1ms/step - loss: 0.0468 - auc: 0.9788 - val_loss: 0.0479 - val_auc: 0.9794\n"
     ]
    }
   ],
   "source": [
    "with tf.device('/gpu:0'):\n",
    "    history = model5.fit(X_train,y_train,\n",
    "                        validation_data=(X_val, y_val),\n",
    "                        batch_size=256,\n",
    "                        epochs=100,\n",
    "                        class_weight=cw,\n",
    "                        callbacks=[early])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation Precision: [0.88314987298899239, 0.80519480519480524, 0.20000000000000001, 0.72037283621837545, 0.61764705882352944],\n",
      "\n",
      "Validation Recall: [0.7183195592286501, 0.83990147783251234, 0.022222222222222223, 0.72617449664429534, 0.35897435897435898]\n"
     ]
    }
   ],
   "source": [
    "val_predict5 = (np.asarray(model5.predict([X_val], batch_size=512))).round()\n",
    "\n",
    "val_precision5 = []\n",
    "val_recall5 = []\n",
    "for i in range(5):\n",
    "    val_precision5.append(metrics.precision_score(val_target[:,i], val_predict5[:,i]))\n",
    "    val_recall5.append(metrics.recall_score(val_target[:,i], val_predict5[:,i]))\n",
    "\n",
    "print(\"Validation Precision: {},\\n\\nValidation Recall: {}\".format(val_precision5, val_recall5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.bar(np.arange(5) - 0.3/2,val_precision5,0.3,label=\"CW Validation Precision\", tick_label=names)\n",
    "plt.bar(np.arange(5) + 0.3/2,val_recall5,0.3,label=\"CW Validation Recall\", tick_label=names)\n",
    "plt.legend(loc='right', bbox_to_anchor=(1.6,0.5))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Undersample"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "embedding_10 (Embedding)     (None, 100, 25)           500000    \n",
      "_________________________________________________________________\n",
      "bidirectional_10 (Bidirectio (None, 200)               100800    \n",
      "_________________________________________________________________\n",
      "dense_19 (Dense)             (None, 50)                10050     \n",
      "_________________________________________________________________\n",
      "dropout_10 (Dropout)         (None, 50)                0         \n",
      "_________________________________________________________________\n",
      "dense_20 (Dense)             (None, 5)                 255       \n",
      "=================================================================\n",
      "Total params: 611,105\n",
      "Trainable params: 611,105\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model6 = Sequential()\n",
    "model6.add(Embedding(max_features,embed_size,weights=[embedding_matrix],input_length=maxlen))\n",
    "model6.add(Bidirectional(LSTM(100,dropout=0.1,recurrent_dropout=0.1)))\n",
    "model6.add(Dense(50, activation=\"relu\"))\n",
    "model6.add(Dropout(0.1))\n",
    "model6.add(Dense(5, activation=\"sigmoid\"))\n",
    "model6.compile(loss='binary_crossentropy',optimizer='adam',metrics=[auc])\n",
    "model6.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 34s 1ms/step - loss: 0.3800 - auc: 0.7741 - val_loss: 0.1359 - val_auc: 0.8691\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 36s 1ms/step - loss: 0.2784 - auc: 0.8937 - val_loss: 0.0811 - val_auc: 0.9092\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 39s 1ms/step - loss: 0.2432 - auc: 0.9196 - val_loss: 0.0891 - val_auc: 0.9266\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 38s 1ms/step - loss: 0.2262 - auc: 0.9318 - val_loss: 0.0760 - val_auc: 0.9362\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 33s 1ms/step - loss: 0.2151 - auc: 0.9398 - val_loss: 0.0731 - val_auc: 0.9427\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 38s 1ms/step - loss: 0.2070 - auc: 0.9453 - val_loss: 0.0811 - val_auc: 0.9473\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 37s 1ms/step - loss: 0.2010 - auc: 0.9491 - val_loss: 0.0691 - val_auc: 0.9508\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 39s 1ms/step - loss: 0.1962 - auc: 0.9524 - val_loss: 0.0683 - val_auc: 0.9538\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 39s 1ms/step - loss: 0.1903 - auc: 0.9551 - val_loss: 0.0717 - val_auc: 0.9562\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 37s 1ms/step - loss: 0.1863 - auc: 0.9573 - val_loss: 0.0584 - val_auc: 0.9583\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 41s 1ms/step - loss: 0.1827 - auc: 0.9593 - val_loss: 0.0644 - val_auc: 0.9602\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 36s 1ms/step - loss: 0.1774 - auc: 0.9610 - val_loss: 0.0642 - val_auc: 0.9618\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 41s 1ms/step - loss: 0.1740 - auc: 0.9626 - val_loss: 0.0642 - val_auc: 0.9632\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 40s 1ms/step - loss: 0.1705 - auc: 0.9639 - val_loss: 0.0702 - val_auc: 0.9645\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 40s 1ms/step - loss: 0.1679 - auc: 0.9651 - val_loss: 0.0662 - val_auc: 0.9656\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 38s 1ms/step - loss: 0.1644 - auc: 0.9661 - val_loss: 0.0608 - val_auc: 0.9666\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 37s 1ms/step - loss: 0.1619 - auc: 0.9671 - val_loss: 0.0592 - val_auc: 0.9676\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 37s 1ms/step - loss: 0.1583 - auc: 0.9681 - val_loss: 0.0615 - val_auc: 0.9685\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 39s 1ms/step - loss: 0.1557 - auc: 0.9689 - val_loss: 0.0651 - val_auc: 0.9693\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 40s 1ms/step - loss: 0.1534 - auc: 0.9697 - val_loss: 0.0620 - val_auc: 0.9701\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 37s 1ms/step - loss: 0.1505 - auc: 0.9705 - val_loss: 0.0640 - val_auc: 0.9708\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 32s 1ms/step - loss: 0.1480 - auc: 0.9712 - val_loss: 0.0643 - val_auc: 0.9715\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 31s 1ms/step - loss: 0.1464 - auc: 0.9718 - val_loss: 0.0599 - val_auc: 0.9721\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 33s 1ms/step - loss: 0.1431 - auc: 0.9724 - val_loss: 0.0623 - val_auc: 0.9727\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 32s 1ms/step - loss: 0.1387 - auc: 0.9730 - val_loss: 0.0618 - val_auc: 0.9733\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 35s 1ms/step - loss: 0.1383 - auc: 0.9736 - val_loss: 0.0646 - val_auc: 0.9738\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 39s 1ms/step - loss: 0.1351 - auc: 0.9741 - val_loss: 0.0643 - val_auc: 0.9743\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 33s 1ms/step - loss: 0.1319 - auc: 0.9746 - val_loss: 0.0663 - val_auc: 0.9748\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 30s 1ms/step - loss: 0.1311 - auc: 0.9751 - val_loss: 0.0637 - val_auc: 0.9753\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 30s 1ms/step - loss: 0.1275 - auc: 0.9755 - val_loss: 0.0629 - val_auc: 0.9757\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 31s 1ms/step - loss: 0.1245 - auc: 0.9760 - val_loss: 0.0618 - val_auc: 0.9762\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 30s 1ms/step - loss: 0.1226 - auc: 0.9764 - val_loss: 0.0684 - val_auc: 0.9766\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 30s 1ms/step - loss: 0.1200 - auc: 0.9768 - val_loss: 0.0629 - val_auc: 0.9770\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 31s 1ms/step - loss: 0.1174 - auc: 0.9772 - val_loss: 0.0676 - val_auc: 0.9774\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 31s 1ms/step - loss: 0.1145 - auc: 0.9776 - val_loss: 0.0689 - val_auc: 0.9777\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 31s 1ms/step - loss: 0.1124 - auc: 0.9779 - val_loss: 0.0681 - val_auc: 0.9781\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 31s 1ms/step - loss: 0.1106 - auc: 0.9783 - val_loss: 0.0714 - val_auc: 0.9784\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 31s 1ms/step - loss: 0.1085 - auc: 0.9786 - val_loss: 0.0659 - val_auc: 0.9788\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 31s 1ms/step - loss: 0.1050 - auc: 0.9789 - val_loss: 0.0714 - val_auc: 0.9791\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 30s 1ms/step - loss: 0.1034 - auc: 0.9793 - val_loss: 0.0703 - val_auc: 0.9794\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 30s 1ms/step - loss: 0.1011 - auc: 0.9796 - val_loss: 0.0761 - val_auc: 0.9797\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 31s 1ms/step - loss: 0.1002 - auc: 0.9798 - val_loss: 0.0722 - val_auc: 0.9800\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 30s 1ms/step - loss: 0.0982 - auc: 0.9801 - val_loss: 0.0730 - val_auc: 0.9803\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 30s 1ms/step - loss: 0.0947 - auc: 0.9804 - val_loss: 0.0728 - val_auc: 0.9805\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "27593/27593 [==============================] - 30s 1ms/step - loss: 0.0941 - auc: 0.9807 - val_loss: 0.0761 - val_auc: 0.9808\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 31s 1ms/step - loss: 0.0909 - auc: 0.9809 - val_loss: 0.0749 - val_auc: 0.9810\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 30s 1ms/step - loss: 0.0887 - auc: 0.9812 - val_loss: 0.0768 - val_auc: 0.9813\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 30s 1ms/step - loss: 0.0879 - auc: 0.9814 - val_loss: 0.0800 - val_auc: 0.9815\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 30s 1ms/step - loss: 0.0854 - auc: 0.9816 - val_loss: 0.0788 - val_auc: 0.9817\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 31s 1ms/step - loss: 0.0840 - auc: 0.9819 - val_loss: 0.0788 - val_auc: 0.9820\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 30s 1ms/step - loss: 0.0829 - auc: 0.9821 - val_loss: 0.0776 - val_auc: 0.9822\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 37s 1ms/step - loss: 0.0812 - auc: 0.9823 - val_loss: 0.0807 - val_auc: 0.9824\n",
      "Train on 27593 samples, validate on 15958 samples\n",
      "Epoch 1/1\n",
      "27593/27593 [==============================] - 38s 1ms/step - loss: 0.0794 - auc: 0.9825 - val_loss: 0.0813 - val_auc: 0.9826\n"
     ]
    }
   ],
   "source": [
    "y_majority_index = np.where(np.sum(y_train, axis=1)==0)[0]\n",
    "y_minority_index = np.where(np.sum(y_train, axis=1)!=0)[0]\n",
    "n_undersample = y_majority_index.shape[0]*0.1\n",
    "\n",
    "rauc = []\n",
    "rval_auc = []\n",
    "rloss = []\n",
    "rval_loss = []\n",
    "\n",
    "while True:\n",
    "    index_undersample = np.random.choice(y_majority_index,int(n_undersample),replace=False)\n",
    "    new_index_undersample = np.concatenate([y_minority_index, index_undersample])\n",
    "    x_train_new = X_train[new_index_undersample,:]\n",
    "    y_train_new = y_train[new_index_undersample,:]\n",
    "    with tf.device('/gpu:0'):\n",
    "        hist = model6.fit(x_train_new,y_train_new,validation_data=(X_val, y_val),batch_size=256,epochs=1)\n",
    "    rauc.append(hist.history[\"auc\"])\n",
    "    rval_auc.append(hist.history[\"val_auc\"])\n",
    "    rloss.append(hist.history[\"loss\"])\n",
    "    rval_loss.append(hist.history[\"val_loss\"])\n",
    "    if rval_loss[-1] > rloss[-1]:\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation Precision: [0.60338345864661658, 0.74263038548752835, 0.31428571428571428, 0.642018779342723, 0.34838709677419355],\n",
      "\n",
      "Validation Recall: [0.88429752066115708, 0.80665024630541871, 0.24444444444444444, 0.73422818791946309, 0.46153846153846156]\n"
     ]
    }
   ],
   "source": [
    "val_predict6 = (np.asarray(model6.predict([X_val], batch_size=512))).round()\n",
    "\n",
    "val_precision6 = []\n",
    "val_recall6 = []\n",
    "for i in range(5):\n",
    "    val_precision6.append(metrics.precision_score(val_target[:,i], val_predict6[:,i]))\n",
    "    val_recall6.append(metrics.recall_score(val_target[:,i], val_predict6[:,i]))\n",
    "\n",
    "print(\"Validation Precision: {},\\n\\nValidation Recall: {}\".format(val_precision6, val_recall6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.bar(np.arange(5) - 0.3/2,val_precision6,0.3,label=\"Baseline Validation Precision\", tick_label=names)\n",
    "plt.bar(np.arange(5) + 0.3/2,val_recall6,0.3,label=\"Undersample Validation Precision\", tick_label=names)\n",
    "plt.legend(loc='right', bbox_to_anchor=(1.65,0.5))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}