Class_project.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Class project.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyOTj88/5lEs1/ZZGZb3wEGY",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/manishkolla/DSCI-1302/blob/main/Class_project.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Sentiment Ananlysis"
      ],
      "metadata": {
        "id": "hWF0P8UZyJjB"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "h6qJOvfIDZvN",
        "outputId": "4831c2b6-7812-4b75-9104-a2ef72542aed"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[nltk_data] Downloading package punkt to /root/nltk_data...\n",
            "[nltk_data]   Package punkt is already up-to-date!\n",
            "[nltk_data] Downloading package stopwords to /root/nltk_data...\n",
            "[nltk_data]   Package stopwords is already up-to-date!\n",
            "[nltk_data] Downloading package wordnet to /root/nltk_data...\n",
            "[nltk_data]   Package wordnet is already up-to-date!\n",
            "[nltk_data] Downloading package averaged_perceptron_tagger to\n",
            "[nltk_data]     /root/nltk_data...\n",
            "[nltk_data]   Package averaged_perceptron_tagger is already up-to-\n",
            "[nltk_data]       date!\n",
            "                                              review  \\\n",
            "0  I called you because my food was cold and not ...   \n",
            "1  OMG, hands down the best pizza I've had from D...   \n",
            "2  This Domino's has the best pizza delivery and ...   \n",
            "3   My Sweetheart & I are very pleased to invite you   \n",
            "4  I called to place an order, The lady answered ...   \n",
            "\n",
            "                                     Cleaned Reviews  \\\n",
            "0  I called you because my food was cold and not ...   \n",
            "1  OMG hands down the best pizza I ve had from Do...   \n",
            "2  This Domino s has the best pizza delivery and ...   \n",
            "3     My Sweetheart I are very pleased to invite you   \n",
            "4   I called to place an order The lady answered No    \n",
            "\n",
            "                                          POS tagged  \n",
            "0  [(called, v), (food, n), (cold, a), (done, v),...  \n",
            "1  [(OMG, n), (hands, v), (best, a), (pizza, n), ...  \n",
            "2  [(Domino, n), (best, a), (pizza, n), (delivery...  \n",
            "3       [(Sweetheart, n), (pleased, a), (invite, v)]  \n",
            "4  [(called, v), (place, v), (order, n), (lady, n...  \n",
            "Neutral    5\n",
            "Name: Analysis, dtype: int64\n",
            "[nltk_data] Downloading package sentiwordnet to /root/nltk_data...\n",
            "[nltk_data]   Package sentiwordnet is already up-to-date!\n",
            "Positive    3\n",
            "Negative    1\n",
            "Neutral     1\n",
            "Name: Sentiment Analysis, dtype: int64\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "([<matplotlib.patches.Wedge at 0x7efeeb08add0>,\n",
              "  <matplotlib.patches.Wedge at 0x7efeeb097690>,\n",
              "  <matplotlib.patches.Wedge at 0x7efeeb097f10>],\n",
              " [Text(-0.3708204787324998, 1.1412677917792124, 'Positive'),\n",
              "  Text(-0.33991852729952715, -1.04616222202798, 'Negative'),\n",
              "  Text(0.8899188088302002, -0.6465636192133282, 'Neutral')],\n",
              " [Text(-0.21631194592729153, 0.6657395452045405, '60.0%'),\n",
              "  Text(-0.18541010579974207, -0.5706339392879891, '20.0%'),\n",
              "  Text(0.48541025936192733, -0.3526710650254517, '20.0%')])"
            ]
          },
          "metadata": {},
          "execution_count": 23
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x504 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "#importing various python libraries like natural language processing, pandas, and regular expression, and........\n",
        "\n",
        "import nltk\n",
        "import pandas as pd\n",
        "import re\n",
        "from nltk.tokenize import word_tokenize\n",
        "import textblob\n",
        "\n",
        "# Creating a pandas dataframe from reviews.txt file and converting it to csv file and printing the first 5 rows\n",
        "data = pd.read_csv('reviews.txt', sep='\\t')\n",
        "data.to_csv ('reviews.csv', index=None)\n",
        "data.head()\n",
        "\n",
        "#dropping the unnecessary data like the index numbers and printing the first 4 rows\n",
        "mydata = data.drop(\"Unnames: 0\", axis=1)\n",
        "mydata.head(4)\n",
        "\n",
        "# Defining  a function to clean the text\n",
        "def clean(text):\n",
        "# Removes all special characters and numericals leaving the alphabets and returns the text using the regular expression\n",
        "    text = re.sub('[^A-Za-z]+', ' ', text)\n",
        "    return text\n",
        "\n",
        "# Cleaning the text in the review column using the above method and printing the rows\n",
        "mydata['Cleaned Reviews'] = mydata['review'].apply(clean)\n",
        "mydata.head()\n",
        "\n",
        "\n",
        "#step 2-4\n",
        "#using natural language processing and implementing tokenizing, POS tagging, and stop word removal\n",
        "#tokenizing- Tokenization is the process of breaking the text into smaller pieces called Tokens. \n",
        "              #It can be performed at sentences(sentence tokenization) or word level(word tokenization).\n",
        "#word-level tokenization using nltk tokenize function word_tokenize() \n",
        "\n",
        "nltk.download('punkt')\n",
        "from nltk.tokenize import word_tokenize\n",
        "from nltk import pos_tag\n",
        "nltk.download('stopwords')\n",
        "from nltk.corpus import stopwords\n",
        "nltk.download('wordnet')\n",
        "from nltk.corpus import wordnet\n",
        "import nltk\n",
        "nltk.download('averaged_perceptron_tagger')\n",
        "\n",
        "# POS tagger dictionary\n",
        "#Parts of Speech (POS) tagging is a process of converting each token into a tuple having the form (word, tag).\n",
        "# POS tagging essential to preserve the context of the word and is essential for Lemmatization.\n",
        "#it can be done using the nltk post_tag() function\n",
        "pos_dict = {'J':wordnet.ADJ, 'V':wordnet.VERB, 'N':wordnet.NOUN, 'R':wordnet.ADV}\n",
        "def token_stop_pos(text):\n",
        "    tags = pos_tag(word_tokenize(text))\n",
        "    newlist = []\n",
        "    for word, tag in tags:\n",
        "        if word.lower() not in set(stopwords.words('english')):  #removing all the stopword in English using the stopword function\n",
        "          newlist.append(tuple([word, pos_dict.get(tag[0])]))\n",
        "    return newlist\n",
        "\n",
        "mydata['POS tagged'] = mydata['Cleaned Reviews'].apply(token_stop_pos)\n",
        "mydata.head()\n",
        "print(mydata)\n",
        "\n",
        "#step 5\n",
        "#A stem is a part of a word responsible for its lexical meaning. \n",
        "#The two popular techniques of obtaining the root/stem words are Stemming and Lemmatization\n",
        "from nltk.stem import WordNetLemmatizer\n",
        "wordnet_lemmatizer = WordNetLemmatizer()\n",
        "def lemmatize(pos_data):\n",
        "    lemma_rew = \" \"\n",
        "    for word, pos in pos_data:\n",
        "      if not pos:\n",
        "        lemma = word\n",
        "        lemma_rew = lemma_rew + \" \" + lemma\n",
        "    else:\n",
        "        lemma = wordnet_lemmatizer.lemmatize(word, pos=pos)\n",
        "        lemma_rew = lemma_rew + \" \" + lemma\n",
        "    return lemma_rew\n",
        "\n",
        "mydata['Lemma'] = mydata['POS tagged'].apply(lemmatize)\n",
        "mydata.head()\n",
        "mydata[['review', 'Lemma']]\n",
        "\n",
        "'''\n",
        "TextBlob is a Python library for processing textual data. \n",
        "It provides a consistent API for diving into common natural language processing (NLP) tasks such as part-of-speech tagging, noun phrase extraction, sentiment analysis, and more.\n",
        "The two measures that are used to analyze the sentiment are:\n",
        "\n",
        "Polarity – talks about how positive or negative the opinion is\n",
        "Subjectivity – talks about how subjective the opinion is\n",
        "\n",
        "'''\n",
        "from textblob import TextBlob\n",
        "# function to calculate subjectivity\n",
        "def getSubjectivity(review):\n",
        "    return TextBlob(review).sentiment.subjectivity\n",
        "\n",
        "# function to calculate polarity\n",
        "def getPolarity(review):\n",
        "  return TextBlob(review).sentiment.polarity\n",
        "\n",
        "# function to analyze the reviews\n",
        "def analysis(score):\n",
        "    if score < 0:\n",
        "        return 'Negative'\n",
        "    elif score == 0:\n",
        "        return 'Neutral'\n",
        "    else:\n",
        "        return 'Positive'\n",
        "\n",
        "#printing only the review and the Lemma columns from the table\n",
        "fin_data = pd.DataFrame(mydata[['review', 'Lemma']])\n",
        "\n",
        "# fin_data['Subjectivity'] = fin_data['Lemma'].apply(getSubjectivity) \n",
        "fin_data['Polarity'] = fin_data['Lemma'].apply(getPolarity) \n",
        "fin_data['Analysis'] = fin_data['Polarity'].apply(analysis)\n",
        "fin_data.head()\n",
        "\n",
        "tb_counts = fin_data.Analysis.value_counts()\n",
        "print(tb_counts)\n",
        "\n",
        "#graph plotting\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline\n",
        "nltk.download('sentiwordnet')\n",
        "from nltk.corpus import sentiwordnet as swn\n",
        "\n",
        "def sentiwordnetanalysis(pos_data):\n",
        "    sentiment = 0\n",
        "    tokens_count = 0\n",
        "    for word, pos in pos_data:\n",
        "        if not pos:\n",
        "            continue\n",
        "        lemma = wordnet_lemmatizer.lemmatize(word, pos=pos)\n",
        "        if not lemma:\n",
        "            continue\n",
        "        \n",
        "        synsets = wordnet.synsets(lemma, pos=pos)\n",
        "        if not synsets:\n",
        "            continue\n",
        "\n",
        "        # Take the first sense, the most common\n",
        "        synset = synsets[0]\n",
        "        swn_synset = swn.senti_synset(synset.name())\n",
        "        sentiment += swn_synset.pos_score() - swn_synset.neg_score()\n",
        "        tokens_count += 1\n",
        "        # print(swn_synset.pos_score(),swn_synset.neg_score(),swn_synset.obj_score())\n",
        "    if not tokens_count:\n",
        "        return 0\n",
        "    if sentiment>0:\n",
        "        return \"Positive\"\n",
        "    if sentiment==0:\n",
        "        return \"Neutral\"\n",
        "    else:\n",
        "        return \"Negative\"\n",
        "\n",
        "fin_data['Sentiment Analysis'] = mydata['POS tagged'].apply(sentiwordnetanalysis)\n",
        "fin_data.head()\n",
        "\n",
        "swn_counts= fin_data['Sentiment Analysis'].value_counts()\n",
        "print(swn_counts)\n",
        "\n",
        "swn_counts= fin_data['Sentiment Analysis'].value_counts()\n",
        "plt.figure(figsize=(10, 7))\n",
        "plt.pie(swn_counts.values, labels = swn_counts.index, explode = (0.1, 0, 0), autopct='%1.1f%%', shadow=False)"
      ]
    }
  ]
}