Sentiment_Analysis_Notebook.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "import nltk\n",
    "import random\n",
    "\n",
    "from nltk.classify.scikitlearn import SklearnClassifier\n",
    "from nltk.corpus import stopwords\n",
    "from nltk.tokenize import word_tokenize\n",
    "from nltk.classify import ClassifierI\n",
    "from nltk.corpus import movie_reviews\n",
    "\n",
    "from sklearn.naive_bayes import MultinomialNB, GaussianNB, BernoulliNB\n",
    "from sklearn.linear_model import LogisticRegression, SGDClassifier\n",
    "from sklearn.svm import SVC, LinearSVC, NuSVC\n",
    "\n",
    "from statistics import mode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class VoteClassifier(ClassifierI):\n",
    "    def __init__(self, *classifiers):\n",
    "        self._classifiers = classifiers\n",
    "    \n",
    "    def classify(self, features):\n",
    "        votes = []\n",
    "        for c in self._classifiers:\n",
    "            v = c.classify(features)\n",
    "            votes.append(v)\n",
    "        return mode(votes)\n",
    "    \n",
    "    def confidence(self, features):\n",
    "        votes = []\n",
    "        for c in self._classifiers:\n",
    "            v = c.classify(features)\n",
    "            votes.append(v)\n",
    "        choice_votes = votes.count(mode(votes))\n",
    "        conf = choice_votes / len(votes)\n",
    "        return conf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "short_pos = open(\"short_reviews_dataset/positive.txt\", \"r\").read()\n",
    "short_neg = open(\"short_reviews_dataset/negative.txt\", \"r\").read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "documents = []\n",
    "all_words = []\n",
    "\n",
    "# allowing only specific types of words using nltk's POS tagger\n",
    "# j is adject, r is adverb, and v is verb\n",
    "\n",
    "# allowed_word_types = [\"J\",\"R\",\"V\"]\n",
    "allowed_word_types = [\"J\"]\n",
    "\n",
    "for p in short_pos.split('\\n'):\n",
    "    documents.append( (p, \"pos\") )\n",
    "    words = word_tokenize(p)\n",
    "    pos = nltk.pos_tag(words)\n",
    "    for w in pos:\n",
    "        if w[1][0] in allowed_word_types:\n",
    "            all_words.append(w[0].lower())\n",
    "\n",
    "    \n",
    "for p in short_neg.split('\\n'):\n",
    "    documents.append( (p, \"neg\") )\n",
    "    words = word_tokenize(p)\n",
    "    pos = nltk.pos_tag(words)\n",
    "    for w in pos:\n",
    "        if w[1][0] in allowed_word_types:\n",
    "            all_words.append(w[0].lower())\n",
    "\n",
    "            \n",
    "            \n",
    "# for r in short_pos.split('\\n'):\n",
    "#     documents.append((r, \"pos\"))\n",
    "    \n",
    "# for r in short_neg.split('\\n'):\n",
    "#     documents.append((r, \"neg\"))\n",
    "\n",
    "# short_pos_words = word_tokenize(short_pos)\n",
    "# short_neg_words = word_tokenize(short_neg)\n",
    "\n",
    "# for w in short_pos_words:\n",
    "#     all_words.append(w.lower())\n",
    "    \n",
    "# for w in short_neg_words:\n",
    "#     all_words.append(w.lower())\n",
    "    \n",
    "all_words = nltk.FreqDist(all_words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "word_features = list(all_words.keys())[:5000]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_features(document):\n",
    "    words = word_tokenize(document)\n",
    "    features = {}\n",
    "    for w in word_features:\n",
    "        features[w] = (w in words)\n",
    "        \n",
    "    return features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "featuresets = [(find_features(rev), category) for (rev, category) in documents]\n",
    "\n",
    "random.shuffle(featuresets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_set = featuresets[:10000]\n",
    "testing_set = featuresets[10000:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Naive Bayes Accuracy:  70.33132530120481\n"
     ]
    }
   ],
   "source": [
    "classifier = nltk.NaiveBayesClassifier.train(training_set)\n",
    "print(\"Naive Bayes Accuracy: \", (nltk.classify.accuracy(classifier, testing_set)*100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MNB_classifier Accuracy:  71.23493975903614\n"
     ]
    }
   ],
   "source": [
    "MNB_classifier = SklearnClassifier(MultinomialNB())\n",
    "MNB_classifier.train(training_set)\n",
    "print(\"MNB_classifier Accuracy: \", (nltk.classify.accuracy(MNB_classifier, testing_set)*100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BernoulliNB_classifier Accuracy:  70.18072289156626\n"
     ]
    }
   ],
   "source": [
    "# BernoulliNB\n",
    "BernoulliNB_classifier = SklearnClassifier(BernoulliNB())\n",
    "BernoulliNB_classifier.train(training_set)\n",
    "print(\"BernoulliNB_classifier Accuracy: \", (nltk.classify.accuracy(BernoulliNB_classifier, testing_set)*100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LogisticRegression_classifier Accuracy:  70.33132530120481\n"
     ]
    }
   ],
   "source": [
    "# LogisticRegression\n",
    "LogisticRegression_classifier = SklearnClassifier(LogisticRegression())\n",
    "LogisticRegression_classifier.train(training_set)\n",
    "print(\"LogisticRegression_classifier Accuracy: \", (nltk.classify.accuracy(LogisticRegression_classifier, testing_set)*100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SGDClassifier_classifier Accuracy:  69.87951807228916\n"
     ]
    }
   ],
   "source": [
    "# SGDClassifier\n",
    "SGDClassifier_classifier = SklearnClassifier(SGDClassifier())\n",
    "SGDClassifier_classifier.train(training_set)\n",
    "print(\"SGDClassifier_classifier Accuracy: \", (nltk.classify.accuracy(SGDClassifier_classifier, testing_set)*100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SVC_classifier Accuracy:  70.48192771084338\n"
     ]
    }
   ],
   "source": [
    "# SVC\n",
    "SVC_classifier = SklearnClassifier(SVC())\n",
    "SVC_classifier.train(training_set)\n",
    "print(\"SVC_classifier Accuracy: \", (nltk.classify.accuracy(SVC_classifier, testing_set)*100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LinearSVC_classifier Accuracy:  68.22289156626506\n"
     ]
    }
   ],
   "source": [
    "# LinearSVC\n",
    "LinearSVC_classifier = SklearnClassifier(LinearSVC())\n",
    "LinearSVC_classifier.train(training_set)\n",
    "print(\"LinearSVC_classifier Accuracy: \", (nltk.classify.accuracy(LinearSVC_classifier, testing_set)*100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # NuSVC, taking way too long to train\n",
    "# NuSVC_classifier = SklearnClassifier(NuSVC())\n",
    "# NuSVC_classifier.train(training_set)\n",
    "# print(\"NuSVC_classifier Accuracy: \", (nltk.classify.accuracy(NuSVC_classifier, testing_set)*100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "voted_classifier Accuracy:  70.33132530120481\n",
      "Classification:  pos Confidence:  1.0\n"
     ]
    }
   ],
   "source": [
    "voted_classifier = VoteClassifier(classifier,\n",
    "                                  LinearSVC_classifier, \n",
    "                                  MNB_classifier, \n",
    "                                  BernoulliNB_classifier, \n",
    "                                  LogisticRegression_classifier)\n",
    "print(\"voted_classifier Accuracy: \", (nltk.classify.accuracy(voted_classifier, testing_set)*100))\n",
    "print(\"Classification: \", voted_classifier.classify(testing_set[0][0]), \"Confidence: \", voted_classifier.confidence(testing_set[0][0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pickling to make classification fast and making a module out of our classifier\n",
    "\n",
    "\n",
    "Things to pickle\n",
    "\n",
    "- documents\n",
    "- all_words\n",
    "- word_features\n",
    "- featuresets\n",
    "- all the classifiers\n",
    "\n",
    "Leave\n",
    "\n",
    "- voted_classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "p = open('pickled_files/documents.pickle', 'wb')\n",
    "pickle.dump(documents, p)\n",
    "p.close()\n",
    "\n",
    "p = open('pickled_files/all_words.pickle', 'wb')\n",
    "pickle.dump(all_words, p)\n",
    "p.close()\n",
    "\n",
    "p = open('pickled_files/word_features5k.pickle', 'wb')\n",
    "pickle.dump(word_features, p)\n",
    "p.close()\n",
    "\n",
    "p = open('pickled_files/featuresets.pickle', 'wb')\n",
    "pickle.dump(featuresets, p)\n",
    "p.close()\n",
    "\n",
    "# pickling the classifiers\n",
    "p = open('pickled_files/originalnaivebayes5k.pickle', 'wb')\n",
    "pickle.dump(classifier, p)\n",
    "p.close()\n",
    "\n",
    "p = open('pickled_files/MNB_classifier5k.pickle', 'wb')\n",
    "pickle.dump(MNB_classifier, p)\n",
    "p.close()\n",
    "\n",
    "p = open('pickled_files/BernoulliNB_classifier5k.pickle', 'wb')\n",
    "pickle.dump(BernoulliNB_classifier, p)\n",
    "p.close()\n",
    "\n",
    "p = open('pickled_files/LogisticRegression_classifier5k.pickle', 'wb')\n",
    "pickle.dump(LogisticRegression_classifier, p)\n",
    "p.close()\n",
    "\n",
    "p = open('pickled_files/LinearSVC_classifier5k.pickle', 'wb')\n",
    "pickle.dump(LinearSVC_classifier, p)\n",
    "p.close()\n",
    "\n",
    "p = open('pickled_files/SGDC_classifier5k.pickle', 'wb')\n",
    "pickle.dump(SGDClassifier_classifier, p)\n",
    "p.close()\n",
    "\n",
    "p = open('pickled_files/SVC_classifier5k.pickle', 'wb')\n",
    "pickle.dump(SVC_classifier, p)\n",
    "p.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using the information above to create a module\n",
    "\n",
    "- see \"sentiment_analysis\" python file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using the sentiment_analysis module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sentiment_analysis as s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('pos', 1.0)\n",
      "('neg', 1.0)\n"
     ]
    }
   ],
   "source": [
    "print(s.sentiment(\"This movie was awesome! The acting was great, plot was wonderful, and there were pythons...so yea!\"))\n",
    "print(s.sentiment(\"This movie was utter junk. There were absolutely 0 pythons. I don't see what the point was at all. Horrible movie, 0/10\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.7.7 64-bit ('venv_ai': venv)",
   "language": "python",
   "name": "python37764bitvenvaivenva8badbe8c74144069332606e56533bf6"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}