Baseline test.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sentiment Analysis\n",
    "\n",
    "#### WEI Chen, Pierre-Yves Casanova"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Baseline 1\n",
    "## SentiWordNet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import IMDb dataset for baseline test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd       \n",
    "data = pd.read_csv(\"imdb_data/train_binary_sent.csv\", header=0, delimiter=\",\")\n",
    "\n",
    "X_train = data[\"sentence\"]\n",
    "y_train = data[\"label\"]\n",
    "\n",
    "data = pd.read_csv(\"imdb_data/test_binary_sent.csv\", header=0, delimiter=\",\")\n",
    "\n",
    "X_test = data[\"sentence\"]\n",
    "y_test = data[\"label\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nltk.stem import WordNetLemmatizer\n",
    "from nltk.corpus import wordnet as wn\n",
    "from nltk.corpus import sentiwordnet as swn\n",
    "from nltk import sent_tokenize, word_tokenize, pos_tag\n",
    "# from nltk.sentiment.util import mark_negation\n",
    " \n",
    " \n",
    "lemmatizer = WordNetLemmatizer()\n",
    "\n",
    "def mark_negation(document, double_neg_flip=False, shallow=False):\n",
    "    \n",
    "    NEGATION = r\"\"\"\n",
    "        (?:\n",
    "            ^(?:never|no|nothing|nowhere|noone|none|not|\n",
    "                havent|hasnt|hadnt|cant|couldnt|shouldnt|\n",
    "                wont|wouldnt|dont|doesnt|didnt|isnt|arent|aint|\n",
    "                neither|nor|hardly|seldom|fail\n",
    "            )$\n",
    "        )\n",
    "        |\n",
    "        n't\"\"\"\n",
    "\n",
    "    NEGATION_RE = re.compile(NEGATION, re.VERBOSE)\n",
    "\n",
    "    CLAUSE_PUNCT = r'^[,.:;!?]$'\n",
    "    CLAUSE_PUNCT_RE = re.compile(CLAUSE_PUNCT)\n",
    "    \n",
    "    \n",
    "    neg_scope = False\n",
    "    for i, word in enumerate(document):\n",
    "        if NEGATION_RE.search(word[0]):\n",
    "            if not neg_scope:\n",
    "                neg_scope = not neg_scope\n",
    "                continue\n",
    "            else:\n",
    "                document[i] = (document[i][0]+'_NEG',document[i][1])           \n",
    "        elif neg_scope and CLAUSE_PUNCT_RE.search(word[0]):\n",
    "            neg_scope = not neg_scope\n",
    "        elif neg_scope and not CLAUSE_PUNCT_RE.search(word[0]):\n",
    "            document[i] = (document[i][0]+'_NEG',document[i][1])\n",
    "\n",
    "    return document\n",
    "\n",
    "def penn_to_wn(tag):\n",
    "    \"\"\"\n",
    "    Convert between the PennTreebank tags to simple Wordnet tags\n",
    "    \"\"\"\n",
    "    if tag.startswith('J'):\n",
    "        return wn.ADJ\n",
    "    elif tag.startswith('N'):\n",
    "        return wn.NOUN\n",
    "    elif tag.startswith('R'):\n",
    "        return wn.ADV\n",
    "    elif tag.startswith('V'):\n",
    "        return wn.VERB\n",
    "    return None\n",
    " \n",
    "def swn_polarity(text):\n",
    "    \"\"\"\n",
    "    Return a sentiment polarity: 0 = negative, 1 = positive\n",
    "    \"\"\"\n",
    " \n",
    "    sentiment = 0.0\n",
    "    tokens_count = 0\n",
    " \n",
    "#     text = clean_text(text)\n",
    " \n",
    "    raw_sentences = sent_tokenize(text) #split document into sentences\n",
    "    for raw_sentence in raw_sentences:\n",
    "        tagged_sentence = mark_negation(pos_tag(word_tokenize(raw_sentence))) #split sentences into words, and attach pos tag to each word\n",
    "#         print(tagged_sentence)\n",
    "        for word, tag in tagged_sentence:\n",
    "            wn_tag = penn_to_wn(tag)\n",
    "            try:\n",
    "                word, neg = word.split(\"_\")\n",
    "            except:\n",
    "                neg = None\n",
    "#             print(\"tag:\",wn_tag)  \n",
    "            if wn_tag not in (wn.NOUN, wn.ADJ, wn.ADV, wn.VERB):\n",
    "                continue\n",
    "              \n",
    "            lemma = lemmatizer.lemmatize(word, pos=wn_tag) #find stem word\n",
    "            if not lemma:\n",
    "                continue\n",
    "#             print(\"lemma:\",lemma)\n",
    "            synsets = wn.synsets(lemma, pos=wn_tag) #find the synonym\n",
    "            if not synsets:\n",
    "                continue\n",
    "#             print(synsets)\n",
    "            # Take the first sense, the most common\n",
    "            synset = synsets[0]\n",
    "            swn_synset = swn.senti_synset(synset.name()) #search in the sentiwordnet dictionary\n",
    "#             print(\"swn_synset:\",swn_synset)\n",
    "            if neg == \"NEG\":\n",
    "                sentiment += -swn_synset.pos_score() + swn_synset.neg_score()\n",
    "            else:\n",
    "                sentiment += swn_synset.pos_score() - swn_synset.neg_score()\n",
    "            tokens_count += 1\n",
    " \n",
    "    # judgment call ? Default to positive or negative\n",
    "    if not tokens_count:\n",
    "        return 0\n",
    "#         return -1\n",
    "#     print(sentiment)\n",
    "    # sum greater than 0 => positive sentiment\n",
    "    if sentiment >= 0:\n",
    "        return 1\n",
    " \n",
    "    # negative sentiment\n",
    "    return 0\n",
    "#     return -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "pred_y = [swn_polarity(text) for text in X_test.values]\n",
    "\n",
    "print (accuracy_score(y_test.values, pred_y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Baseline 2\n",
    "## n-gram + sklearn LinearSVC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nltk import word_tokenize\n",
    "from nltk.sentiment.util import mark_negation\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.svm import LinearSVC, SVC\n",
    "from sklearn.base import TransformerMixin \n",
    "from sklearn.model_selection import train_test_split, cross_val_score\n",
    "import re\n",
    "\n",
    "# X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    " \n",
    "clf = Pipeline([\n",
    "    ('vectorizer', CountVectorizer(analyzer=\"word\",\n",
    "#                                    tokenizer=word_tokenize,         # ! Comment line to include mark_negation and uncomment next line\n",
    "                                   tokenizer=lambda text: mark_negation(word_tokenize(text)), \n",
    "#                                    preprocessor=lambda text: text.replace(\"<br />\", \" \"),\n",
    "#                                    preprocessor=lambda text: ' '.join(re.sub(\"(@[A-Za-z0-9]+)|([^0-9A-Za-z \\t])|(\\w+:\\/\\/\\S+)\",\" \",text).split()),\n",
    "                                   ngram_range=(1, 2),\n",
    "                                   stop_words = 'english',\n",
    "#                                    min_df = 10,\n",
    "                                   max_features=None) ),\n",
    "    ('classifier', LinearSVC())\n",
    "])\n",
    " \n",
    "clf.fit(X_train.values, y_train.values)\n",
    "clf.score(X_test.values, y_test.values)\n",
    "\n",
    "# print(np.mean(cross_val_score(clf, trX, trY, cv=4)))"
   ]
  }
 ],
 "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
}