NLP Project - Categorization of Politically Influential text.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CSCI 544 Applied Natural Language Processing",
    "\n",
    "#### Categorization of politically influential text\n",
    "\n",
    "\n",
    "Authors:\n",
    "1. Ruchit Gandhi (ruchitsg@usc.edu)\n",
    "2. Saumya Dureja (sdureja@usc.edu)\n",
    "3. Gursheen Grewal (gursheeg@usc.edu)\n",
    "4. Purvak Lapsiya (lapsiya@usc.edu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\purvak\\anaconda3\\envs\\py35\\lib\\site-packages\\nltk\\twitter\\__init__.py:20: UserWarning: The twython library has not been installed. Some functionality from the twitter package will not be available.\n",
      "  warnings.warn(\"The twython library has not been installed. \"\n",
      "c:\\users\\purvak\\anaconda3\\envs\\py35\\lib\\site-packages\\gensim\\utils.py:1212: UserWarning: detected Windows; aliasing chunkize to chunkize_serial\n",
      "  warnings.warn(\"detected Windows; aliasing chunkize to chunkize_serial\")\n",
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "\n",
    "import pandas as pd\n",
    "import json\n",
    "import pprint\n",
    "import numpy as np\n",
    "\n",
    "import string\n",
    "import unicodedata\n",
    "import re\n",
    "\n",
    "import matplotlib.pyplot as plt \n",
    "\n",
    "from nltk.sentiment.vader import SentimentIntensityAnalyzer\n",
    "analyser = SentimentIntensityAnalyzer()\n",
    "\n",
    "import nltk\n",
    "from nltk.tokenize.toktok import ToktokTokenizer\n",
    "tokenizer = ToktokTokenizer()\n",
    "stopword_list = nltk.corpus.stopwords.words('english')\n",
    "\n",
    "from gensim import corpora, models\n",
    "from keras import layers, models, optimizers\n",
    "from sklearn.decomposition import LatentDirichletAllocation\n",
    "from yellowbrick.classifier import ClassificationReport\n",
    "\n",
    "pd.options.display.max_rows\n",
    "pd.set_option('display.max_colwidth', -1)\n",
    "\n",
    "#preprocessing pipeline\n",
    "#Pipeline models features like word count, tfidf, word density, word embeddings (GloVe)\n",
    "\n",
    "from sklearn import model_selection, preprocessing, linear_model, naive_bayes, metrics, svm\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer, CountVectorizer\n",
    "from sklearn import decomposition, ensemble\n",
    "from keras.preprocessing import text, sequence\n",
    "import xgboost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#reading excel/csv using pandas\n",
    "df = pd.read_csv('data.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ## Preprocessing\n",
    "\n",
    "1. Dropna for dropping null\n",
    "2. Stripping Hyperlinks\n",
    "3. Expanding english language contractions \n",
    "4. Remove Hashtags\n",
    "5. Remove special characters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Selecting subset of columns and droping rows with Null value in 'label' column\n",
    "\n",
    "df = df[['full_text', 'Label']]\n",
    "# df = df.dropna(subset=['Label'])\n",
    "df = df.dropna()\n",
    "df.columns = ['data', 'label']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def strip_links(text):\n",
    "    link_regex    = re.compile('((https?):((//)|(\\\\\\\\))+([\\w\\d:#@%/;$()~_?\\+-=\\\\\\.&](#!)?)*)', re.DOTALL)\n",
    "    links         = re.findall(link_regex, text)\n",
    "    for link in links:\n",
    "        text = text.replace(link[0], ', ')    \n",
    "    return text\n",
    "\n",
    "\n",
    "#code source is http://stackoverflow.com/questions/19790188/expanding-english-language-contractions-in-python\n",
    "\n",
    "import re\n",
    "cList = {\n",
    "  \"ain't\": \"am not\",\n",
    "  \"aren't\": \"are not\",\n",
    "  \"can't\": \"cannot\",\n",
    "  \"can't've\": \"cannot have\",\n",
    "  \"'cause\": \"because\",\n",
    "  \"could've\": \"could have\",\n",
    "  \"couldn't\": \"could not\",\n",
    "  \"couldn't've\": \"could not have\",\n",
    "  \"didn't\": \"did not\",\n",
    "  \"doesn't\": \"does not\",\n",
    "  \"don't\": \"do not\",\n",
    "  \"hadn't\": \"had not\",\n",
    "  \"hadn't've\": \"had not have\",\n",
    "  \"hasn't\": \"has not\",\n",
    "  \"haven't\": \"have not\",\n",
    "  \"he'd\": \"he would\",\n",
    "  \"he'd've\": \"he would have\",\n",
    "  \"he'll\": \"he will\",\n",
    "  \"he'll've\": \"he will have\",\n",
    "  \"he's\": \"he is\",\n",
    "  \"how'd\": \"how did\",\n",
    "  \"how'd'y\": \"how do you\",\n",
    "  \"how'll\": \"how will\",\n",
    "  \"how's\": \"how is\",\n",
    "  \"I'd\": \"I would\",\n",
    "  \"I'd've\": \"I would have\",\n",
    "  \"I'll\": \"I will\",\n",
    "  \"I'll've\": \"I will have\",\n",
    "  \"i'm\": \"i am\",\n",
    "  \"I've\": \"I have\",\n",
    "  \"isn't\": \"is not\",\n",
    "  \"it'd\": \"it had\",\n",
    "  \"it'd've\": \"it would have\",\n",
    "  \"it'll\": \"it will\",\n",
    "  \"it'll've\": \"it will have\",\n",
    "  \"it's\": \"it is\",\n",
    "  \"let's\": \"let us\",\n",
    "  \"ma'am\": \"madam\",\n",
    "  \"mayn't\": \"may not\",\n",
    "  \"might've\": \"might have\",\n",
    "  \"mightn't\": \"might not\",\n",
    "  \"mightn't've\": \"might not have\",\n",
    "  \"must've\": \"must have\",\n",
    "  \"mustn't\": \"must not\",\n",
    "  \"mustn't've\": \"must not have\",\n",
    "  \"needn't\": \"need not\",\n",
    "  \"needn't've\": \"need not have\",\n",
    "  \"o'clock\": \"of the clock\",\n",
    "  \"oughtn't\": \"ought not\",\n",
    "  \"oughtn't've\": \"ought not have\",\n",
    "  \"shan't\": \"shall not\",\n",
    "  \"sha'n't\": \"shall not\",\n",
    "  \"shan't've\": \"shall not have\",\n",
    "  \"she'd\": \"she would\",\n",
    "  \"she'd've\": \"she would have\",\n",
    "  \"she'll\": \"she will\",\n",
    "  \"she'll've\": \"she will have\",\n",
    "  \"she's\": \"she is\",\n",
    "  \"should've\": \"should have\",\n",
    "  \"shouldn't\": \"should not\",\n",
    "  \"shouldn't've\": \"should not have\",\n",
    "  \"so've\": \"so have\",\n",
    "  \"so's\": \"so is\",\n",
    "  \"that'd\": \"that would\",\n",
    "  \"that'd've\": \"that would have\",\n",
    "  \"that's\": \"that is\",\n",
    "  \"there'd\": \"there had\",\n",
    "  \"there'd've\": \"there would have\",\n",
    "  \"there's\": \"there is\",\n",
    "  \"they'd\": \"they would\",\n",
    "  \"they'd've\": \"they would have\",\n",
    "  \"they'll\": \"they will\",\n",
    "  \"they'll've\": \"they will have\",\n",
    "  \"they're\": \"they are\",\n",
    "  \"they've\": \"they have\",\n",
    "  \"to've\": \"to have\",\n",
    "  \"wasn't\": \"was not\",\n",
    "  \"we'd\": \"we had\",\n",
    "  \"we'd've\": \"we would have\",\n",
    "  \"we'll\": \"we will\",\n",
    "  \"we'll've\": \"we will have\",\n",
    "  \"we're\": \"we are\",\n",
    "  \"we've\": \"we have\",\n",
    "  \"weren't\": \"were not\",\n",
    "  \"what'll\": \"what will\",\n",
    "  \"what'll've\": \"what will have\",\n",
    "  \"what're\": \"what are\",\n",
    "  \"what's\": \"what is\",\n",
    "  \"what've\": \"what have\",\n",
    "  \"when's\": \"when is\",\n",
    "  \"when've\": \"when have\",\n",
    "  \"where'd\": \"where did\",\n",
    "  \"where's\": \"where is\",\n",
    "  \"where've\": \"where have\",\n",
    "  \"who'll\": \"who will\",\n",
    "  \"who'll've\": \"who will have\",\n",
    "  \"who's\": \"who is\",\n",
    "  \"who've\": \"who have\",\n",
    "  \"why's\": \"why is\",\n",
    "  \"why've\": \"why have\",\n",
    "  \"will've\": \"will have\",\n",
    "  \"won't\": \"will not\",\n",
    "  \"won't've\": \"will not have\",\n",
    "  \"would've\": \"would have\",\n",
    "  \"wouldn't\": \"would not\",\n",
    "  \"wouldn't've\": \"would not have\",\n",
    "  \"y'all\": \"you all\",\n",
    "  \"y'alls\": \"you alls\",\n",
    "  \"y'all'd\": \"you all would\",\n",
    "  \"y'all'd've\": \"you all would have\",\n",
    "  \"y'all're\": \"you all are\",\n",
    "  \"y'all've\": \"you all have\",\n",
    "  \"you'd\": \"you had\",\n",
    "  \"you'd've\": \"you would have\",\n",
    "  \"you'll\": \"you will\",\n",
    "  \"you'll've\": \"you will have\",\n",
    "  \"you're\": \"you are\",\n",
    "  \"you've\": \"you have\"\n",
    "}\n",
    "\n",
    "c_re = re.compile('(%s)' % '|'.join(cList.keys()))\n",
    "\n",
    "def expand_contractions(text, c_re=c_re):\n",
    "    def replace(match):\n",
    "        return cList[match.group(0)]\n",
    "    text = c_re.sub(replace, text.lower())\n",
    "    return text\n",
    "\n",
    "def strip_mentions_hashtags(text):\n",
    "    entity_prefixes = ['@','#']\n",
    "    for separator in  string.punctuation:\n",
    "        if separator not in entity_prefixes :\n",
    "            text = text.replace(separator,' ')\n",
    "    words = []\n",
    "    for word in text.split():\n",
    "        word = word.strip()\n",
    "        if word:\n",
    "            if word[0] not in entity_prefixes:\n",
    "                words.append(word)\n",
    "    return ' '.join(words)\n",
    "\n",
    "def remove_special_characters(text, remove_digits=False):\n",
    "    pattern = r'[^a-zA-z0-9\\s]' if not remove_digits else r'[^a-zA-z\\s]'\n",
    "    text = re.sub(pattern, '', text)\n",
    "    text = unicodedata.normalize('NFKD', text).encode('ascii', 'ignore').decode('utf-8', 'ignore')\n",
    "    return text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# data cleaning and processing\n",
    "df['data'] = df['data'].apply(lambda x : strip_links(x))\n",
    "df['data'] = df['data'].apply(lambda x : expand_contractions(x))\n",
    "df['data'] = df['data'].apply(lambda x : strip_mentions_hashtags(x))\n",
    "df['data'] = df['data'].apply(lambda x : remove_special_characters(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Feature engineering\n",
    "\n",
    "1. Encoding output as 1/0\n",
    "2. Using count vectorizer to calculate count of word in corpus\n",
    "3. Word level tf-idf\n",
    "4. ngram (2-3) tf-idf\n",
    "5. GLoVe Vector embeddings\n",
    "6. Topic Modelling\n",
    "7. Sentiment analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#splitting dataset into train and validation set (80% - 20% default)\n",
    "\n",
    "train_x, valid_x, train_y, valid_y = model_selection.train_test_split(df['data'], df['label'])\n",
    "\n",
    "#Label Encoder converts yes and no into 1 and 0\n",
    "\n",
    "encoder = preprocessing.LabelEncoder()\n",
    "train_y = encoder.fit_transform(train_y)\n",
    "valid_y = encoder.fit_transform(valid_y)\n",
    "\n",
    "#Count vectorizer will calculate count of every word in text data and will ignore number and whitespaces\n",
    "\n",
    "count_vector = CountVectorizer(analyzer='word', token_pattern=r'\\w{1,}')\n",
    "count_vector.fit(df['data'])\n",
    "\n",
    "#using the count vector defined above, we'll transform our existing text data into train_x_count where every row will indicate \n",
    "#tweet and every column will represent count of word indexed at that loc\n",
    "\n",
    "train_x_count = count_vector.transform(train_x)\n",
    "valid_x_count = count_vector.transform(valid_x)\n",
    "\n",
    "#word level tf-idf\n",
    "\n",
    "tfidf_vect = TfidfVectorizer(analyzer='word',token_pattern=r'\\w{1,}', max_features=5000)\n",
    "tfidf_vect.fit(df['data'])\n",
    "xtrain_tfidf = tfidf_vect.transform(train_x)\n",
    "xvalid_tfidf = tfidf_vect.transform(valid_x)\n",
    "\n",
    "\n",
    "#ngram level tf-idf\n",
    "tfidf_ngram = TfidfVectorizer(analyzer='word',token_pattern=r'\\w{1,}', ngram_range=(2,3) ,max_features=5000)\n",
    "tfidf_ngram.fit(df['data'])\n",
    "xtrain_tfidf_ngram = tfidf_ngram.transform(train_x)\n",
    "xvalid_tfidf_ngram = tfidf_ngram.transform(valid_x)\n",
    "\n",
    "from keras.preprocessing import text, sequence\n",
    "token = text.Tokenizer()\n",
    "token.fit_on_texts(df['data'])\n",
    "word_index = token.word_index\n",
    "\n",
    "train_seq_x = sequence.pad_sequences(token.texts_to_sequences(train_x), maxlen=70)\n",
    "valid_seq_x = sequence.pad_sequences(token.texts_to_sequences(valid_x), maxlen=70)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#glove word_emb\n",
    "#Using code base of hw5\n",
    "\n",
    "from __future__ import division\n",
    "import sys,json,math\n",
    "import os\n",
    "import numpy as np\n",
    "\n",
    "def load_word2vec(filename):\n",
    "    # Returns a dict containing a {word: numpy array for a dense word vector} mapping.\n",
    "    # It loads everything into memory.\n",
    "    \n",
    "    w2vec={}\n",
    "    with open(filename,\"r\", encoding='utf8') as f_in:\n",
    "        for line in f_in:\n",
    "            line_split=line.replace(\"\\n\",\"\").split()\n",
    "            w=line_split[0]\n",
    "            vec=np.array([float(x) for x in line_split[1:]])\n",
    "            w2vec[w]=vec\n",
    "    return w2vec\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#word embedding extraction\n",
    "word_to_vec_dict = load_word2vec('glove.6B.300D.txt')\n",
    "\n",
    "import numpy\n",
    "emb_matrix = numpy.zeros((len(word_index)+1, 300))\n",
    "for word, i in word_index.items():\n",
    "    emb_vect = word_to_vec_dict.get(word)\n",
    "    if emb_vect is not None:\n",
    "        emb_matrix[i] = emb_vect"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dataset_train = pd.DataFrame(train_x)\n",
    "dataset_valid = pd.DataFrame(valid_x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# combined dataset for running topic modelling\n",
    "dataset_for_topic_model = pd.concat([dataset_train, dataset_valid], axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\purvak\\anaconda3\\envs\\py35\\lib\\site-packages\\sklearn\\decomposition\\online_lda.py:532: DeprecationWarning: The default value for 'learning_method' will be changed from 'online' to 'batch' in the release 0.20. This warning was introduced in 0.18.\n",
      "  DeprecationWarning)\n"
     ]
    }
   ],
   "source": [
    "# Topic Modelling\n",
    "vectorizer = TfidfVectorizer()\n",
    "X = vectorizer.fit_transform(dataset_for_topic_model['data'])\n",
    "lda = LatentDirichletAllocation(random_state=0)\n",
    "doc_topic_matrix = lda.fit_transform(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assign Sentiment scores to text\n",
    "dataset_train['comp'] = dataset_train['data'].apply(lambda x : analyser.polarity_scores(x)['compound'])\n",
    "dataset_train['pos'] = dataset_train['data'].apply(lambda x : analyser.polarity_scores(x)['pos'])\n",
    "dataset_train['neu'] = dataset_train['data'].apply(lambda x : analyser.polarity_scores(x)['neu'])\n",
    "dataset_train['neg'] = dataset_train['data'].apply(lambda x : analyser.polarity_scores(x)['neg'])\n",
    "\n",
    "dataset_valid['comp'] = dataset_valid['data'].apply(lambda x : analyser.polarity_scores(x)['compound'])\n",
    "dataset_valid['pos'] = dataset_valid['data'].apply(lambda x : analyser.polarity_scores(x)['pos'])\n",
    "dataset_valid['neu'] = dataset_valid['data'].apply(lambda x : analyser.polarity_scores(x)['neu'])\n",
    "dataset_valid['neg'] = dataset_valid['data'].apply(lambda x : analyser.polarity_scores(x)['neg'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# combine sentiment features with count vectorizer features\n",
    "train_x_count = pd.DataFrame(np.concatenate((train_x_count.toarray(), dataset_train[['comp', 'pos', 'neu', 'neg']].values, doc_topic_matrix[:len(train_x)]), axis=1))\n",
    "valid_x_count = pd.DataFrame(np.concatenate((valid_x_count.toarray(), dataset_valid[['comp', 'pos', 'neu', 'neg']].values, doc_topic_matrix[len(train_x):]), axis=1))\n",
    "\n",
    "# combine sentiment features with tf-idf features\n",
    "xtrain_tfidf = pd.DataFrame(np.concatenate((xtrain_tfidf.toarray(), dataset_train[['comp', 'pos', 'neu', 'neg']].values, doc_topic_matrix[:len(train_x)]), axis=1))\n",
    "xvalid_tfidf = pd.DataFrame(np.concatenate((xvalid_tfidf.toarray(), dataset_valid[['comp', 'pos', 'neu', 'neg']].values, doc_topic_matrix[len(train_x):]), axis=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Models\n",
    "\n",
    "1. Naive Bayes \n",
    "2. Logistic Regression\n",
    "3. Xgboost\n",
    "4. Shallow Neural Network\n",
    "5. RNN with GRU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Function to train model and evaluate based on accuracy\n",
    "def train_model(classifier, feature_vector_train,label, feature_vector_valid, is_neural_net = False):\n",
    "    classifier.fit(feature_vector_train, label)\n",
    "    prediction = classifier.predict(feature_vector_valid)\n",
    "    from sklearn.metrics import confusion_matrix\n",
    "    if not is_neural_net:\n",
    "        print(confusion_matrix(valid_y, prediction))\n",
    "    if is_neural_net:\n",
    "        prediction = prediction.argmax(axis=-1)\n",
    "    return metrics.accuracy_score(prediction, valid_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[206  45]\n",
      " [ 44  31]]\n",
      "Naive Bayes (Count Vectors) 0.726993865031\n",
      "[[251   0]\n",
      " [ 73   2]]\n",
      "Naive Bayes (TDIDF) 0.776073619632\n"
     ]
    }
   ],
   "source": [
    "count_vector = CountVectorizer(analyzer='word', token_pattern=r'\\w{1,}')\n",
    "count_vector.fit(df['data'])\n",
    "nb_train_x_count = count_vector.transform(train_x)\n",
    "nb_valid_x_count = count_vector.transform(valid_x)\n",
    "tfidf_vect = TfidfVectorizer(analyzer='word',token_pattern=r'\\w{1,}', max_features=5000)\n",
    "tfidf_vect.fit(df['data'])\n",
    "nb_xtrain_tfidf = tfidf_vect.transform(train_x)\n",
    "nb_xvalid_tfidf = tfidf_vect.transform(valid_x)\n",
    "\n",
    "\n",
    "\n",
    "clf = naive_bayes.MultinomialNB()\n",
    "accuracy = train_model(clf, nb_train_x_count, train_y, nb_valid_x_count)\n",
    "print(\"Naive Bayes (Count Vectors)\",accuracy)\n",
    "accuracy = train_model(clf, nb_xtrain_tfidf, train_y, nb_xvalid_tfidf)\n",
    "print(\"Naive Bayes (TDIDF)\", accuracy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[229  22]\n",
      " [ 45  30]]\n",
      "LR using CV 0.794478527607\n",
      "[[244   7]\n",
      " [ 54  21]]\n",
      "LR using CV 0.812883435583\n"
     ]
    }
   ],
   "source": [
    "clf = linear_model.LogisticRegression()\n",
    "accuracy = train_model(clf, train_x_count, train_y, valid_x_count)\n",
    "print(\"LR using CV\", accuracy)\n",
    "accuracy = train_model(clf, xtrain_tfidf, train_y, xvalid_tfidf)\n",
    "print(\"LR using CV\", accuracy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[230  21]\n",
      " [ 49  26]]\n",
      "xgboost using CV 0.78527607362\n",
      "[[230  21]\n",
      " [ 53  22]]\n",
      "xgboost using TFIDF 0.773006134969\n"
     ]
    }
   ],
   "source": [
    "accuracy = train_model(xgboost.XGBClassifier(), train_x_count, train_y, valid_x_count)\n",
    "print(\"xgboost using CV\", accuracy)\n",
    "accuracy = train_model(xgboost.XGBClassifier(), xtrain_tfidf, train_y, xvalid_tfidf)\n",
    "print(\"xgboost using TFIDF\", accuracy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Shallow Neural Networks\n",
    "\n",
    "def create_model_architecture(input_size):\n",
    "    # create input layer \n",
    "    input_layer = layers.Input((input_size, ), sparse=True)\n",
    "    \n",
    "    # create hidden layer\n",
    "    hidden_layer = layers.Dense(100, activation=\"relu\")(input_layer)\n",
    "    \n",
    "    # create output layer\n",
    "    output_layer = layers.Dense(1, activation=\"sigmoid\")(hidden_layer)\n",
    "\n",
    "    classifier = models.Model(inputs = input_layer, outputs = output_layer)\n",
    "    classifier.compile(optimizer=optimizers.Adam(), loss='binary_crossentropy')\n",
    "    return classifier \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/1\n",
      "976/976 [==============================] - 0s - loss: 0.6609     \n",
      "NN, Ngram Level TF IDF Vectors 0.769938650307\n"
     ]
    }
   ],
   "source": [
    "classifier = create_model_architecture(xtrain_tfidf_ngram.shape[1])\n",
    "accuracy = train_model(classifier, xtrain_tfidf_ngram, train_y, xvalid_tfidf_ngram, is_neural_net=True)\n",
    "print (\"NN, Ngram Level TF IDF Vectors\",  accuracy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/1\n",
      "976/976 [==============================] - 4s - loss: 0.5958     \n",
      "0.769938650307\n"
     ]
    }
   ],
   "source": [
    "def create_rnn_gru():\n",
    "    # Add an Input Layer\n",
    "    input_layer = layers.Input((70, ))\n",
    "\n",
    "    # Add the word embedding Layer\n",
    "    embedding_layer = layers.Embedding(len(word_index) + 1, 300, weights=[emb_matrix], trainable=False)(input_layer)\n",
    "    embedding_layer = layers.SpatialDropout1D(0.3)(embedding_layer)\n",
    "\n",
    "    # Add the GRU Layer\n",
    "    lstm_layer = layers.GRU(100)(embedding_layer)\n",
    "\n",
    "    # Add the output Layers\n",
    "    output_layer1 = layers.Dense(50, activation=\"relu\")(lstm_layer)\n",
    "    output_layer1 = layers.Dropout(0.25)(output_layer1)\n",
    "    output_layer2 = layers.Dense(1, activation=\"sigmoid\")(output_layer1)\n",
    "\n",
    "    # Compile the model\n",
    "    model = models.Model(inputs=input_layer, outputs=output_layer2)\n",
    "    model.compile(optimizer=optimizers.Adam(), loss='binary_crossentropy')\n",
    "    \n",
    "    return model\n",
    "\n",
    "classifier = create_rnn_gru()\n",
    "accuracy = train_model(classifier, train_seq_x, train_y, valid_seq_x, is_neural_net=True)\n",
    "print(accuracy)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdQAAAF/CAYAAADw/DhBAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nBApUERGREHwCdp+NGgDOy78AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x29aad067940>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "classes=['No','Yes']\n",
    "visualizer=ClassificationReport(clf,classes=classes)\n",
    "\n",
    "visualizer.fit(train_x_count, train_y)\n",
    "visualizer.score(valid_x_count, valid_y)\n",
    "visualizer.poof()"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}