Web_Mining_CSE3024/Naive_Bayes_Lab_3/NB_Classifier.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Naive Bayes Classifier based on Term Frequencies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Load the Given data into a CSV File\n",
    "\n",
    "To be done only once, later the data can be loaded on from the CSV file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a Pandas dataframe and store the data\n",
    "\n",
    "df = pd.DataFrame(columns=['TDP', 'Nifty', 'Sidhu', 'BJP', 'Sensex', 'Sixer', 'Congress', 'Century', 'Category'])\n",
    "num_entries = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The Given Data\n",
    "\n",
    "data = [\n",
    "    [4,0,3,5,1,0,6,0,'Politics'],\n",
    "    [0,5,0,2,6,0,1,0,'Business'],\n",
    "    [0,0,6,1,0,4,1,2,'Sports'],\n",
    "    [4,1,0,1,1,0,6,0,'Politics'],\n",
    "    [0,0,0,0,0,5,0,6,'Sports'],\n",
    "    [0,4,0,2,6,0,0,1,'Business'],\n",
    "    [5,0,0,3,0,0,5,0,'Politics']\n",
    "]\n",
    "query_data = [0,3,0,2,6,0,2,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the data into a Pandas dataframe and store it into a CSV File\n",
    "\n",
    "for i in range(len(data)) :\n",
    "    df.loc[num_entries] = data[i]\n",
    "    num_entries += 1\n",
    "\n",
    "df.to_csv('Data.csv', index=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Loading the dataset and getting the Queryset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv('Data.csv')\n",
    "query_data = [0,3,0,2,6,0,2,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the output labels\n",
    "output_labels = df['Category'].unique()\n",
    "\n",
    "# Get the list of all words taken into consideration from the documents\n",
    "words = list(df.columns)[:-1]\n",
    "\n",
    "# Get the number of documents in the whole dataset\n",
    "num_train_documents = df.shape[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Calculating the Required Probabilities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A dictionary to store the conditional probabilities\n",
    "# Format : conditional_probability[(a, b)] = P(a/b) => Probability of occurance of event `a` given that the event `b` has occured\n",
    "conditional_probability = {}\n",
    "\n",
    "# A dictionary to store the probabilities\n",
    "# Format : probablity[a] = P(a) => Probablity of occurance of event `a`\n",
    "probability = {}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1 Calculate the Probability of occurance of the output labels (classes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "for output_class in output_labels :\n",
    "    temp_df = df.loc[df['Category'] == output_class]\n",
    "    probability[output_class] = (temp_df.shape[0] / num_train_documents)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Politics': 0.42857142857142855,\n",
       " 'Business': 0.2857142857142857,\n",
       " 'Sports': 0.2857142857142857}"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Display the Probability of each output class\n",
    "\n",
    "probability"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 Calculate the Conditional Probabilities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set parameter for smoothing\n",
    "\n",
    "# ALPHA = 0 for no smoothing\n",
    "ALPHA = 0\n",
    "\n",
    "# ALPHA = 1 for Laplace Smoothing\n",
    "#ALPHA = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "for output_class in output_labels :\n",
    "    temp_df = df.loc[df['Category'] == output_class]\n",
    "    \n",
    "    # Find the total number of words in that category\n",
    "    total_word_count_in_category = 0\n",
    "    for i in range(temp_df.shape[0]) :\n",
    "        for word in words :\n",
    "            total_word_count_in_category += temp_df.iloc[i][word]\n",
    "    \n",
    "    # For each word find the number of times it occurs in the current category output\n",
    "    for word in words :\n",
    "        current_word_count_in_category = 0\n",
    "        for i in range(temp_df.shape[0]) :\n",
    "            current_word_count_in_category += temp_df.iloc[i][word]\n",
    "            \n",
    "        # Store the conditional probability\n",
    "        cur_prob = (current_word_count_in_category + ALPHA) / (total_word_count_in_category + (ALPHA * len(words)))\n",
    "        conditional_probability[(word, output_class)] = cur_prob"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Conditional Probabilities without applying any smoothing : \n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{('TDP', 'Politics'): 0.28888888888888886,\n",
       " ('Nifty', 'Politics'): 0.022222222222222223,\n",
       " ('Sidhu', 'Politics'): 0.06666666666666667,\n",
       " ('BJP', 'Politics'): 0.2,\n",
       " ('Sensex', 'Politics'): 0.044444444444444446,\n",
       " ('Sixer', 'Politics'): 0.0,\n",
       " ('Congress', 'Politics'): 0.37777777777777777,\n",
       " ('Century', 'Politics'): 0.0,\n",
       " ('TDP', 'Business'): 0.0,\n",
       " ('Nifty', 'Business'): 0.3333333333333333,\n",
       " ('Sidhu', 'Business'): 0.0,\n",
       " ('BJP', 'Business'): 0.14814814814814814,\n",
       " ('Sensex', 'Business'): 0.4444444444444444,\n",
       " ('Sixer', 'Business'): 0.0,\n",
       " ('Congress', 'Business'): 0.037037037037037035,\n",
       " ('Century', 'Business'): 0.037037037037037035,\n",
       " ('TDP', 'Sports'): 0.0,\n",
       " ('Nifty', 'Sports'): 0.0,\n",
       " ('Sidhu', 'Sports'): 0.24,\n",
       " ('BJP', 'Sports'): 0.04,\n",
       " ('Sensex', 'Sports'): 0.0,\n",
       " ('Sixer', 'Sports'): 0.36,\n",
       " ('Congress', 'Sports'): 0.04,\n",
       " ('Century', 'Sports'): 0.32}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Without Smoothing, Some values are zero\n",
    "print(\"Conditional Probabilities without applying any smoothing : \\n\")\n",
    "conditional_probability"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Conditional Probabilities after applying smoothing : \n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{('TDP', 'Politics'): 0.2641509433962264,\n",
       " ('Nifty', 'Politics'): 0.03773584905660377,\n",
       " ('Sidhu', 'Politics'): 0.07547169811320754,\n",
       " ('BJP', 'Politics'): 0.18867924528301888,\n",
       " ('Sensex', 'Politics'): 0.05660377358490566,\n",
       " ('Sixer', 'Politics'): 0.018867924528301886,\n",
       " ('Congress', 'Politics'): 0.33962264150943394,\n",
       " ('Century', 'Politics'): 0.018867924528301886,\n",
       " ('TDP', 'Business'): 0.02857142857142857,\n",
       " ('Nifty', 'Business'): 0.2857142857142857,\n",
       " ('Sidhu', 'Business'): 0.02857142857142857,\n",
       " ('BJP', 'Business'): 0.14285714285714285,\n",
       " ('Sensex', 'Business'): 0.37142857142857144,\n",
       " ('Sixer', 'Business'): 0.02857142857142857,\n",
       " ('Congress', 'Business'): 0.05714285714285714,\n",
       " ('Century', 'Business'): 0.05714285714285714,\n",
       " ('TDP', 'Sports'): 0.030303030303030304,\n",
       " ('Nifty', 'Sports'): 0.030303030303030304,\n",
       " ('Sidhu', 'Sports'): 0.21212121212121213,\n",
       " ('BJP', 'Sports'): 0.06060606060606061,\n",
       " ('Sensex', 'Sports'): 0.030303030303030304,\n",
       " ('Sixer', 'Sports'): 0.30303030303030304,\n",
       " ('Congress', 'Sports'): 0.06060606060606061,\n",
       " ('Century', 'Sports'): 0.2727272727272727}"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# With Smoothing\n",
    "print(\"Conditional Probabilities after applying smoothing : \\n\")\n",
    "conditional_probability"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Process the Query"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert the query array into a dictionary to index with the name of the word\n",
    "\n",
    "query_dict = {}\n",
    "\n",
    "for i, word in enumerate(words) :\n",
    "    query_dict[word] = query_data[i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'TDP': 0,\n",
       " 'Nifty': 3,\n",
       " 'Sidhu': 0,\n",
       " 'BJP': 2,\n",
       " 'Sensex': 6,\n",
       " 'Sixer': 0,\n",
       " 'Congress': 2,\n",
       " 'Century': 1}"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "query_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Find the Probability of the result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "categorical_result_probability = {}\n",
    "\n",
    "for output_class in output_labels :\n",
    "    cur_prob = 1\n",
    "    \n",
    "    for word in words :\n",
    "        cur_prob *= (conditional_probability[(word, output_class)] ** query_dict[word])\n",
    "    \n",
    "    categorical_result_probability[output_class] = cur_prob"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Categorical scores without applying any smoothing : \n",
      " {'Politics': 0.0, 'Business': 3.183041412870215e-10, 'Sports': 0.0}\n"
     ]
    }
   ],
   "source": [
    "print(\"Categorical scores without applying any smoothing : \\n\", categorical_result_probability)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Categorical scores after applying Laplace smoothing : \n",
      " {'Politics': 1.369305495406134e-16, 'Business': 2.3320480184727346e-10, 'Sports': 7.928067403337872e-20}\n"
     ]
    }
   ],
   "source": [
    "print(\"Categorical scores after applying Laplace smoothing : \\n\", categorical_result_probability)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Find the maximum probability\n",
    "\n",
    "result_category = max(categorical_result_probability, key=categorical_result_probability.get)\n",
    "result_score = categorical_result_probability[result_category]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The query entered belongs to the category : Business\n"
     ]
    }
   ],
   "source": [
    "print(f\"The query entered belongs to the category : {result_category}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.3"
  },
  "toc-autonumbering": false,
  "toc-showcode": false,
  "toc-showmarkdowntxt": false,
  "toc-showtags": false
 },
 "nbformat": 4,
 "nbformat_minor": 4
}