Assignment_2_Naive_Bayes.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyMbrC7CFgCacq6QyTXLEjwK",
      "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/hussain0048/Natural-language-processing/blob/main/Assignment_2_Naive_Bayes.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "35wSWu85XcIC"
      },
      "outputs": [],
      "source": [
        "#from utils import process_tweet, lookup\n",
        "import pdb\n",
        "from nltk.corpus import stopwords, twitter_samples\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import nltk\n",
        "import string\n",
        "from nltk.tokenize import TweetTokenizer\n",
        "from os import getcwd"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "nltk.download('stopwords')\n",
        "nltk.download('twitter_samples')"
      ],
      "metadata": {
        "id": "A_M1qntdYWx-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# add folder, tmp2, from our local workspace containing pre-downloaded corpora files to nltk's data path\n",
        "filePath = f\"{getcwd()}/../tmp2/\"\n",
        "nltk.data.path.append(filePath)"
      ],
      "metadata": {
        "id": "k8IwNhokY-p2"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import re\n",
        "import string\n",
        "\n",
        "from nltk.corpus import stopwords\n",
        "from nltk.stem import PorterStemmer\n",
        "from nltk.tokenize import TweetTokenizer\n",
        "\n",
        "\n",
        "def process_tweet(tweet):\n",
        "    '''\n",
        "    Input:\n",
        "        tweet: a string containing a tweet\n",
        "    Output:\n",
        "        tweets_clean: a list of words containing the processed tweet\n",
        "    '''\n",
        "    stemmer = PorterStemmer()\n",
        "    stopwords_english = stopwords.words('english')\n",
        "    # remove stock market tickers like $GE\n",
        "    tweet = re.sub(r'\\$\\w*', '', tweet)\n",
        "    # remove old style retweet text \"RT\"\n",
        "    tweet = re.sub(r'^RT[\\s]+', '', tweet)\n",
        "    # remove hyperlinks\n",
        "    tweet = re.sub(r'https?:\\/\\/.*[\\r\\n]*', '', tweet)\n",
        "    # remove hashtags\n",
        "    # only removing the hash # sign from the word\n",
        "    tweet = re.sub(r'#', '', tweet)\n",
        "    # tokenize tweets\n",
        "    tokenizer = TweetTokenizer(preserve_case=False, strip_handles=True,\n",
        "                               reduce_len=True)\n",
        "    tweet_tokens = tokenizer.tokenize(tweet)\n",
        "\n",
        "    tweets_clean = []\n",
        "    for word in tweet_tokens:\n",
        "        if (word not in stopwords_english and  # remove stopwords\n",
        "            word not in string.punctuation):  # remove punctuation\n",
        "            # tweets_clean.append(word)\n",
        "            stem_word = stemmer.stem(word)  # stemming word\n",
        "            tweets_clean.append(stem_word)\n",
        "\n",
        "    return tweets_clean\n",
        "\n",
        "\n",
        "def test_lookup(func):\n",
        "    freqs = {('sad', 0): 4,\n",
        "             ('happy', 1): 12,\n",
        "             ('oppressed', 0): 7}\n",
        "    word = 'happy'\n",
        "    label = 1\n",
        "    if func(freqs, word, label) == 12:\n",
        "        return 'SUCCESS!!'\n",
        "    return 'Failed Sanity Check!'\n",
        "\n",
        "\n",
        "def lookup(freqs, word, label):\n",
        "    '''\n",
        "    Input:\n",
        "        freqs: a dictionary with the frequency of each pair (or tuple)\n",
        "        word: the word to look up\n",
        "        label: the label corresponding to the word\n",
        "    Output:\n",
        "        n: the number of times the word with its corresponding label appears.\n",
        "    '''\n",
        "    n = 0  # freqs.get((word, label), 0)\n",
        "\n",
        "    pair = (word, label)\n",
        "    if (pair in freqs):\n",
        "        n = freqs[pair]\n",
        "\n",
        "    return n"
      ],
      "metadata": {
        "id": "8biQsNzEY6K8"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# get the sets of positive and negative tweets\n",
        "all_positive_tweets = twitter_samples.strings('positive_tweets.json')\n",
        "all_negative_tweets = twitter_samples.strings('negative_tweets.json')\n",
        "\n",
        "# split the data into two pieces, one for training and one for testing (validation set)\n",
        "test_pos = all_positive_tweets[4000:]\n",
        "train_pos = all_positive_tweets[:4000]\n",
        "test_neg = all_negative_tweets[4000:]\n",
        "train_neg = all_negative_tweets[:4000]\n",
        "\n",
        "train_x = train_pos + train_neg\n",
        "test_x = test_pos + test_neg\n",
        "\n",
        "# avoid assumptions about the length of all_positive_tweets\n",
        "train_y = np.append(np.ones(len(train_pos)), np.zeros(len(train_neg)))\n",
        "test_y = np.append(np.ones(len(test_pos)), np.zeros(len(test_neg)))"
      ],
      "metadata": {
        "id": "AKgUPQFJZVMj"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Part 1: Process the Data**"
      ],
      "metadata": {
        "id": "eXD4aAY8Zkc9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "custom_tweet = \"RT @Twitter @chapagain Hello There! Have a great day. :) #good #morning http://chapagain.com.np\"\n",
        "\n",
        "# print cleaned tweet\n",
        "print(process_tweet(custom_tweet))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rHmx_URYZxUC",
        "outputId": "599c0c00-c7ce-455d-8017-821a7a90d5bb"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['hello', 'great', 'day', ':)', 'good', 'morn']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Part 1.1 Implementing your helper functions**"
      ],
      "metadata": {
        "id": "XXE8CQMiaFSl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# UNQ_C1 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n",
        "def count_tweets(result, tweets, ys):\n",
        "    '''\n",
        "    Input:\n",
        "        result: a dictionary that will be used to map each pair to its frequency\n",
        "        tweets: a list of tweets\n",
        "        ys: a list corresponding to the sentiment of each tweet (either 0 or 1)\n",
        "    Output:\n",
        "        result: a dictionary mapping each pair to its frequency\n",
        "    '''\n",
        "\n",
        "    ### START CODE HERE (REPLACE INSTANCES OF 'None' with your code) ###\n",
        "    for y, tweet in zip(ys, tweets):\n",
        "        for word in process_tweet(tweet):\n",
        "            # define the key, which is the word and label tuple\n",
        "            pair = (word,y)\n",
        "\n",
        "            # if the key exists in the dictionary, increment the count\n",
        "            if pair in result:\n",
        "                result[pair] += 1\n",
        "\n",
        "            # else, if the key is new, add it to the dictionary and set the count to 1\n",
        "            else:\n",
        "                result[pair] = 1\n",
        "    ### END CODE HERE ###\n",
        "\n",
        "    return result"
      ],
      "metadata": {
        "id": "xj4dtbZtc3xZ"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Testing your function\n",
        "\n",
        "\n",
        "result = {}\n",
        "tweets = ['i am happy', 'i am tricked', 'i am sad', 'i am tired', 'i am tired']\n",
        "ys = [1, 0, 0, 0, 0]\n",
        "count_tweets(result, tweets, ys)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Xdq_lEMPc7pX",
        "outputId": "c2d0d341-ac06-4f91-ac93-d7a5c69e4005"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{('happi', 1): 1, ('trick', 0): 1, ('sad', 0): 1, ('tire', 0): 2}"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Part 2: Train your model using Naive Bayes**"
      ],
      "metadata": {
        "id": "eKx-GeyHe6Ij"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Build the freqs dictionary for later uses\n",
        "\n",
        "freqs = count_tweets({}, train_x, train_y)"
      ],
      "metadata": {
        "id": "8DVzJOXWf95d"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# UNQ_C2 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n",
        "def train_naive_bayes(freqs, train_x, train_y):\n",
        "    '''\n",
        "    Input:\n",
        "        freqs: dictionary from (word, label) to how often the word appears\n",
        "        train_x: a list of tweets\n",
        "        train_y: a list of labels correponding to the tweets (0,1)\n",
        "    Output:\n",
        "        logprior: the log prior. (equation 3 above)\n",
        "        loglikelihood: the log likelihood of you Naive bayes equation. (equation 6 above)\n",
        "    '''\n",
        "    loglikelihood = {}\n",
        "    logprior = 0\n",
        "\n",
        "    ### START CODE HERE (REPLACE INSTANCES OF 'None' with your code) ###\n",
        "\n",
        "    # calculate V, the number of unique words in the vocabulary\n",
        "    vocab = set([pair[0] for pair in freqs.keys()])\n",
        "    V = len(vocab)\n",
        "\n",
        "    # calculate N_pos, N_neg, V_pos, V_neg\n",
        "    N_pos = N_neg = V_pos = V_neg = 0\n",
        "    for pair in freqs.keys():\n",
        "        # if the label is positive (greater than zero)\n",
        "        if pair[1] > 0:\n",
        "            # increment the count of unique positive words by 1\n",
        "            V_pos += 1\n",
        "\n",
        "            # Increment the number of positive words by the count for this (word, label) pair\n",
        "            N_pos += freqs[pair]\n",
        "\n",
        "        # else, the label is negative\n",
        "        else:\n",
        "            # increment the count of unique negative words by 1\n",
        "            V_neg += 1\n",
        "\n",
        "            # increment the number of negative words by the count for this (word,label) pair\n",
        "            N_neg += freqs[pair]\n",
        "\n",
        "    # Calculate D, the number of documents\n",
        "    D = len(train_y)\n",
        "\n",
        "    # Calculate D_pos, the number of positive documents\n",
        "    D_pos = (len(list(filter(lambda x: x > 0, train_y))))\n",
        "\n",
        "    # Calculate D_neg, the number of negative documents\n",
        "    D_neg = (len(list(filter(lambda x: x <= 0, train_y))))\n",
        "\n",
        "    # Calculate logprior\n",
        "    logprior = np.log(D_pos) - np.log(D_neg)\n",
        "\n",
        "    # For each word in the vocabulary...\n",
        "    for word in vocab:\n",
        "        # get the positive and negative frequency of the word\n",
        "        freq_pos = lookup(freqs,word,1)\n",
        "        freq_neg = lookup(freqs,word,0)\n",
        "\n",
        "        # calculate the probability that each word is positive, and negative\n",
        "        p_w_pos = (freq_pos + 1) / (N_pos + V)\n",
        "        p_w_neg = (freq_neg + 1) / (N_neg + V)\n",
        "\n",
        "        # calculate the log likelihood of the word\n",
        "        loglikelihood[word] = np.log(p_w_pos/p_w_neg)\n",
        "\n",
        "    ### END CODE HERE ###\n",
        "\n",
        "    return logprior, loglikelihood"
      ],
      "metadata": {
        "id": "Y607lpLYgiPS"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# UNQ_C3 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n",
        "# You do not have to input any code in this cell, but it is relevant to grading, so please do not change anything\n",
        "logprior, loglikelihood = train_naive_bayes(freqs, train_x, train_y)\n",
        "print(logprior)\n",
        "print(len(loglikelihood))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "soUDpQoXgqET",
        "outputId": "93bafda7-faef-4272-95cd-306e396e0a7f"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.0\n",
            "9086\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Part 3: Test your naive bayes**"
      ],
      "metadata": {
        "id": "IeiJhO7fhBDQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# UNQ_C4 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n",
        "def naive_bayes_predict(tweet, logprior, loglikelihood):\n",
        "    '''\n",
        "    Input:\n",
        "        tweet: a string\n",
        "        logprior: a number\n",
        "        loglikelihood: a dictionary of words mapping to numbers\n",
        "    Output:\n",
        "        p: the sum of all the logliklihoods of each word in the tweet (if found in the dictionary) + logprior (a number)\n",
        "\n",
        "    '''\n",
        "    ### START CODE HERE (REPLACE INSTANCES OF 'None' with your code) ###\n",
        "    # process the tweet to get a list of words\n",
        "    word_l = process_tweet(tweet)\n",
        "\n",
        "    # initialize probability to zero\n",
        "    p = 0\n",
        "\n",
        "    # add the logprior\n",
        "    p += logprior\n",
        "\n",
        "    for word in word_l:\n",
        "\n",
        "        # check if the word exists in the loglikelihood dictionary\n",
        "        if word in loglikelihood:\n",
        "            # add the log likelihood of that word to the probability\n",
        "            p += loglikelihood[word]\n",
        "\n",
        "    ### END CODE HERE ###\n",
        "\n",
        "    return p"
      ],
      "metadata": {
        "id": "fvfNPjbFnfoe"
      },
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# UNQ_C5 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n",
        "# You do not have to input any code in this cell, but it is relevant to grading, so please do not change anything\n",
        "\n",
        "# Experiment with your own tweet.\n",
        "my_tweet = 'She smiled.'\n",
        "p = naive_bayes_predict(my_tweet, logprior, loglikelihood)\n",
        "print('The expected output is', p)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Q8Ss8ZXmnmCs",
        "outputId": "14c3b3df-f88b-4351-a6a7-c7c60c13972d"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The expected output is 1.5736965101941158\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Implement test_naive_bayes**"
      ],
      "metadata": {
        "id": "MImsJ57-ok3v"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# UNQ_C6 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n",
        "def test_naive_bayes(test_x, test_y, logprior, loglikelihood):\n",
        "    \"\"\"\n",
        "    Input:\n",
        "        test_x: A list of tweets\n",
        "        test_y: the corresponding labels for the list of tweets\n",
        "        logprior: the logprior\n",
        "        loglikelihood: a dictionary with the loglikelihoods for each word\n",
        "    Output:\n",
        "        accuracy: (# of tweets classified correctly)/(total # of tweets)\n",
        "    \"\"\"\n",
        "    accuracy = 0  # return this properly\n",
        "\n",
        "    ### START CODE HERE (REPLACE INSTANCES OF 'None' with your code) ###\n",
        "    y_hats = []\n",
        "    for tweet in test_x:\n",
        "        # if the prediction is > 0\n",
        "        if naive_bayes_predict(tweet, logprior, loglikelihood) > 0:\n",
        "            # the predicted class is 1\n",
        "            y_hat_i = 1\n",
        "        else:\n",
        "            # otherwise the predicted class is 0\n",
        "            y_hat_i = 0\n",
        "\n",
        "        # append the predicted class to the list y_hats\n",
        "        y_hats.append(y_hat_i)\n",
        "\n",
        "    # error is the average of the absolute values of the differences between y_hats and test_y\n",
        "    error = np.mean(np.absolute(y_hats-test_y))\n",
        "\n",
        "    # Accuracy is 1 minus the error\n",
        "    accuracy = 1-error\n",
        "\n",
        "    ### END CODE HERE ###\n",
        "\n",
        "    return accuracy"
      ],
      "metadata": {
        "id": "wIGDAymSor_5"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Naive Bayes accuracy = %0.4f\" %\n",
        "      (test_naive_bayes(test_x, test_y, logprior, loglikelihood)))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Gxfx20I7owI-",
        "outputId": "8e40cb8e-0575-4180-b772-48b4388dcb0e"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Naive Bayes accuracy = 0.9940\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# UNQ_C7 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n",
        "# You do not have to input any code in this cell, but it is relevant to grading, so please do not change anything\n",
        "\n",
        "# Run this cell to test your function\n",
        "for tweet in ['I am happy', 'I am bad', 'this movie should have been great.', 'great', 'great great', 'great great great', 'great great great great']:\n",
        "    # print( '%s -> %f' % (tweet, naive_bayes_predict(tweet, logprior, loglikelihood)))\n",
        "    p = naive_bayes_predict(tweet, logprior, loglikelihood)\n",
        "#     print(f'{tweet} -> {p:.2f} ({p_category})')\n",
        "    print(f'{tweet} -> {p:.2f}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HBBj_ZO4o3Lu",
        "outputId": "4d5a92e1-edca-4aa8-bb84-9bc9f30b204a"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "I am happy -> 2.15\n",
            "I am bad -> -1.29\n",
            "this movie should have been great. -> 2.14\n",
            "great -> 2.14\n",
            "great great -> 4.28\n",
            "great great great -> 6.41\n",
            "great great great great -> 8.55\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Feel free to check the sentiment of your own tweet below\n",
        "my_tweet = 'you are bad :('\n",
        "naive_bayes_predict(my_tweet, logprior, loglikelihood)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1poURLSgo72F",
        "outputId": "8c591ab9-4178-476b-88a9-11901d3ebe45"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "-8.802285344803796"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Part 4: Filter words by Ratio of positive to negative counts**¶\n"
      ],
      "metadata": {
        "id": "I1RqcgdUZ4z2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# UNQ_C8 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n",
        "def get_ratio(freqs, word):\n",
        "    '''\n",
        "    Input:\n",
        "        freqs: dictionary containing the words\n",
        "\n",
        "    Output: a dictionary with keys 'positive', 'negative', and 'ratio'.\n",
        "        Example: {'positive': 10, 'negative': 20, 'ratio': 0.5}\n",
        "    '''\n",
        "    pos_neg_ratio = {'positive': 0, 'negative': 0, 'ratio': 0.0}\n",
        "    ### START CODE HERE (REPLACE INSTANCES OF 'None' with your code) ###\n",
        "    # use lookup() to find positive counts for the word (denoted by the integer 1)\n",
        "    pos_neg_ratio['positive'] = lookup(freqs,word,1)\n",
        "\n",
        "    # use lookup() to find negative counts for the word (denoted by integer 0)\n",
        "    pos_neg_ratio['negative'] = lookup(freqs,word,0)\n",
        "\n",
        "    # calculate the ratio of positive to negative counts for the word\n",
        "    pos_neg_ratio['ratio'] = (pos_neg_ratio['positive'] + 1)/(pos_neg_ratio['negative'] + 1)\n",
        "    ### END CODE HERE ###\n",
        "    return pos_neg_ratio"
      ],
      "metadata": {
        "id": "iviJ1cHEZ_nx"
      },
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "get_ratio(freqs, 'happi')\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DwPq3mbyaC18",
        "outputId": "ca42f8f5-2874-4dfb-cdc1-a161860b96cd"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'positive': 161, 'negative': 18, 'ratio': 8.526315789473685}"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# UNQ_C9 (UNIQUE CELL IDENTIFIER, DO NOT EDIT)\n",
        "def get_words_by_threshold(freqs, label, threshold):\n",
        "    '''\n",
        "    Input:\n",
        "        freqs: dictionary of words\n",
        "        pos_neg_ratio: dictionary of positive counts, negative counts, and ratio of positive / negative counts.\n",
        "        label: 1 for positive, 0 for negative\n",
        "        threshold: ratio that will be used as the cutoff for including a word in the returned dictionary\n",
        "    Output:\n",
        "        word_set: dictionary containing the word and information on its positive count, negative count, and ratio of positive to negative counts.\n",
        "        example of a key value pair:\n",
        "        {'happi':\n",
        "            {'positive': 10, 'negative': 20, 'ratio': 0.5}\n",
        "        }\n",
        "    '''\n",
        "    word_list = {}\n",
        "\n",
        "    ### START CODE HERE (REPLACE INSTANCES OF 'None' with your code) ###\n",
        "    for key in freqs.keys():\n",
        "        word, _ = key\n",
        "\n",
        "        # get the positive/negative ratio for a word\n",
        "        pos_neg_ratio = get_ratio(freqs, word)\n",
        "\n",
        "        # if the label is 1 and the ratio is greater than or equal to the threshold...\n",
        "        if label == 1 and pos_neg_ratio['ratio'] >= threshold :\n",
        "\n",
        "            # Add the pos_neg_ratio to the dictionary\n",
        "            word_list[word] = pos_neg_ratio\n",
        "\n",
        "        # If the label is 0 and the pos_neg_ratio is less than or equal to the threshold...\n",
        "        elif label == 0 and pos_neg_ratio['ratio'] <= threshold:\n",
        "            # Add the pos_neg_ratio to the dictionary\n",
        "            word_list[word] = pos_neg_ratio\n",
        "\n",
        "        # otherwise, do not include this word in the list (do nothing)\n",
        "\n",
        "    ### END CODE HERE ###\n",
        "    return word_list"
      ],
      "metadata": {
        "id": "14zS1E9QaPTz"
      },
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Test your function: find negative words at or below a threshold\n",
        "get_words_by_threshold(freqs, label=0, threshold=0.05)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OQEwhGH2aTGd",
        "outputId": "f6ca79ab-5d84-46b3-d20c-1307df047c2f"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{':(': {'positive': 1, 'negative': 3663, 'ratio': 0.0005458515283842794},\n",
              " ':-(': {'positive': 0, 'negative': 378, 'ratio': 0.002638522427440633},\n",
              " 'zayniscomingbackonjuli': {'positive': 0, 'negative': 19, 'ratio': 0.05},\n",
              " '26': {'positive': 0, 'negative': 20, 'ratio': 0.047619047619047616},\n",
              " '>:(': {'positive': 0, 'negative': 43, 'ratio': 0.022727272727272728},\n",
              " 'lost': {'positive': 0, 'negative': 19, 'ratio': 0.05},\n",
              " '♛': {'positive': 0, 'negative': 210, 'ratio': 0.004739336492890996},\n",
              " '》': {'positive': 0, 'negative': 210, 'ratio': 0.004739336492890996},\n",
              " 'beli̇ev': {'positive': 0, 'negative': 35, 'ratio': 0.027777777777777776},\n",
              " 'wi̇ll': {'positive': 0, 'negative': 35, 'ratio': 0.027777777777777776},\n",
              " 'justi̇n': {'positive': 0, 'negative': 35, 'ratio': 0.027777777777777776},\n",
              " 'ｓｅｅ': {'positive': 0, 'negative': 35, 'ratio': 0.027777777777777776},\n",
              " 'ｍｅ': {'positive': 0, 'negative': 35, 'ratio': 0.027777777777777776}}"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Test your function; find positive words at or above a threshold\n",
        "get_words_by_threshold(freqs, label=1, threshold=10)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GNtq25pKa3tr",
        "outputId": "1907d1f2-277c-42f5-adc4-e5f3dad9edb6"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'followfriday': {'positive': 23, 'negative': 0, 'ratio': 24.0},\n",
              " 'commun': {'positive': 27, 'negative': 1, 'ratio': 14.0},\n",
              " ':)': {'positive': 2847, 'negative': 2, 'ratio': 949.3333333333334},\n",
              " 'flipkartfashionfriday': {'positive': 16, 'negative': 0, 'ratio': 17.0},\n",
              " ':d': {'positive': 498, 'negative': 0, 'ratio': 499.0},\n",
              " ':p': {'positive': 104, 'negative': 0, 'ratio': 105.0},\n",
              " 'influenc': {'positive': 16, 'negative': 0, 'ratio': 17.0},\n",
              " ':-)': {'positive': 543, 'negative': 0, 'ratio': 544.0},\n",
              " \"here'\": {'positive': 20, 'negative': 0, 'ratio': 21.0},\n",
              " 'youth': {'positive': 14, 'negative': 0, 'ratio': 15.0},\n",
              " 'bam': {'positive': 44, 'negative': 0, 'ratio': 45.0},\n",
              " 'warsaw': {'positive': 44, 'negative': 0, 'ratio': 45.0},\n",
              " 'shout': {'positive': 11, 'negative': 0, 'ratio': 12.0},\n",
              " ';)': {'positive': 22, 'negative': 0, 'ratio': 23.0},\n",
              " 'stat': {'positive': 51, 'negative': 0, 'ratio': 52.0},\n",
              " 'arriv': {'positive': 57, 'negative': 4, 'ratio': 11.6},\n",
              " 'via': {'positive': 60, 'negative': 1, 'ratio': 30.5},\n",
              " 'glad': {'positive': 41, 'negative': 2, 'ratio': 14.0},\n",
              " 'blog': {'positive': 27, 'negative': 0, 'ratio': 28.0},\n",
              " 'fav': {'positive': 11, 'negative': 0, 'ratio': 12.0},\n",
              " 'fback': {'positive': 26, 'negative': 0, 'ratio': 27.0},\n",
              " 'pleasur': {'positive': 10, 'negative': 0, 'ratio': 11.0}}"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Part 5: Error Analysis**"
      ],
      "metadata": {
        "id": "--X3O-y8a8VT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Some error analysis done for you\n",
        "print('Truth Predicted Tweet')\n",
        "for x, y in zip(test_x, test_y):\n",
        "    y_hat = naive_bayes_predict(x, logprior, loglikelihood)\n",
        "    if y != (np.sign(y_hat) > 0):\n",
        "        print('%d\\t%0.2f\\t%s' % (y, np.sign(y_hat) > 0, ' '.join(\n",
        "            process_tweet(x)).encode('ascii', 'ignore')))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0duNhNvrbD8M",
        "outputId": "f3bbe4d7-c11a-4d3b-efe3-01e868f2ab8b"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Truth Predicted Tweet\n",
            "1\t0.00\tb''\n",
            "1\t0.00\tb'truli later move know queen bee upward bound movingonup'\n",
            "1\t0.00\tb'new report talk burn calori cold work harder warm feel better weather :p'\n",
            "1\t0.00\tb'harri niall 94 harri born ik stupid wanna chang :d'\n",
            "1\t0.00\tb''\n",
            "1\t0.00\tb''\n",
            "1\t0.00\tb'park get sunlight'\n",
            "1\t0.00\tb'uff itna miss karhi thi ap :p'\n",
            "0\t1.00\tb'hello info possibl interest jonatha close join beti :( great'\n",
            "0\t1.00\tb'u prob fun david'\n",
            "0\t1.00\tb'pat jay'\n",
            "0\t1.00\tb'whatev stil l young >:-('\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Part 6: Predict with your own tweet**\n"
      ],
      "metadata": {
        "id": "7HXuofPmbpoy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Test with your own tweet - feel free to modify `my_tweet`\n",
        "my_tweet = 'I am happy because I am learning :)'\n",
        "\n",
        "p = naive_bayes_predict(my_tweet, logprior, loglikelihood)\n",
        "print(p)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mIE2EL1nbqk3",
        "outputId": "3a7e9c18-da1a-4613-c082-b1fcb51151cf"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "9.573774904705935\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **References**"
      ],
      "metadata": {
        "id": "jmM6-GCVp_Lm"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "[1-Assignment 2: Naive Bayes](https://nbviewer.org/github/amanchadha/coursera-natural-language-processing-specialization/blob/master/1%20-%20Natural%20Language%20Processing%20with%20Classification%20and%20Vector%20Spaces/Week%202/C1W2_A1_Naive%20Bayes.ipynb)"
      ],
      "metadata": {
        "id": "vgMFYPLrqENL"
      }
    }
  ]
}