Bayesian Network.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Bayesian Network"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Setup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 Import Required Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from pgmpy.models import BayesianModel\n",
    "from pgmpy.inference import VariableElimination\n",
    "from pgmpy.factors.discrete import TabularCPD\n",
    "from sklearn.preprocessing import normalize"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 Prepare and read the labels histogram file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>label</th>\n",
       "      <th>positive</th>\n",
       "      <th>negative</th>\n",
       "      <th>neutral</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>gown</td>\n",
       "      <td>33</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>dance</td>\n",
       "      <td>13</td>\n",
       "      <td>0</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>air force</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>bull</td>\n",
       "      <td>0</td>\n",
       "      <td>25</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>bear</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       label  positive  negative  neutral\n",
       "0       gown        33         0        2\n",
       "1      dance        13         0       11\n",
       "2  air force         0         1        1\n",
       "3       bull         0        25        0\n",
       "4       bear         0         1        0"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Assign the file to a variable\n",
    "labels_histogram = 'labels_histogram.xlsx'\n",
    "\n",
    "# Read the file using pandas' as a dataframe\n",
    "# sheet_name specifies the sheet to read\n",
    "# header = 0 tells pandas to consider the first line as the header\n",
    "df = pd.read_excel(labels_histogram, sheet_name=\"labels_histogram\", header=0)\n",
    "\n",
    "# print the first 5 rows of the dataframe\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Prepare data for the Bayesian Network"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 List of labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# first column of the dataframe\n",
    "# skip last row i.e. \"total\"\n",
    "labels_list = df['label'][:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 Count total Positive, Negative and Neutral emotions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get the value of the last row in the positive column of the dataframe\n",
    "total_positive_labels = df['positive'].iloc[-1]\n",
    "\n",
    "# get the value of the last row in the neutral column of the dataframe\n",
    "total_neutral_labels = df['neutral'].iloc[-1]\n",
    "\n",
    "# get the value of the last row in the negative column of the dataframe\n",
    "total_negative_labels = df['negative'].iloc[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3 Frequencies of Positive, Negative and Neutral emotions for each label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get the column with the name \"positive\" as a numpy array\n",
    "# skip last row\n",
    "positive_ndarray = np.array(df['positive'][:-1])\n",
    "\n",
    "# get the column with the name \"neutral\" as a numpy array\n",
    "# skip last row\n",
    "neutral_ndarray = np.array(df['neutral'][:-1])\n",
    "\n",
    "# get the column with the name \"negative\" as a numpy array\n",
    "# skip last row\n",
    "negative_ndarray = np.array(df['negative'][:-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1 Define the edges for the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# edge from Emotion node to each label node i.e. 809 edges\n",
    "edges_list = [(\"Emotion\", label) for label in labels_list]\n",
    "# edge from Emotion node to CNN node\n",
    "edges_list.append((\"Emotion\", \"CNN\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 Define the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = BayesianModel()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3 Add nodes and edges to the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add all the labels from labels_list as nodes\n",
    "model.add_nodes_from(labels_list)\n",
    "# Add all the edges from edges_list\n",
    "model.add_edges_from(edges_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.4 Create the Conditional Probability Distribution Table for the Emotion node"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Name of the node is \"Emotion\"\n",
    "# Total variables = 3 i.e. 1 for each emotion\n",
    "# Since, each emotion is equally likely so each will have 1/3 probability\n",
    "emotion_cpd = TabularCPD(\"Emotion\", 3, values=[[1./3,1./3,1./3]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "╒═══════════╤══════════╕\n",
      "│ Emotion_0 │ 0.333333 │\n",
      "├───────────┼──────────┤\n",
      "│ Emotion_1 │ 0.333333 │\n",
      "├───────────┼──────────┤\n",
      "│ Emotion_2 │ 0.333333 │\n",
      "╘═══════════╧══════════╛\n"
     ]
    }
   ],
   "source": [
    "print(emotion_cpd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.5 Create the Conditional Probability Distribution Table for the CNN node"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.5.1 Calculate the conditional probability values using the confusion matrix obtained from the CNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Store the confusion matrix obtained from CNN as a numpy array\n",
    "cnn_confusion_matrix = np.array([[470.0,92.0,198.0],\n",
    "                                [38.0, 336.0, 130.0],\n",
    "                                [46.0, 201.0, 418.0]])\n",
    "# Normalize the confusion matrix\n",
    "cnn_confusion_matrix = normalize(cnn_confusion_matrix, axis=1, norm=\"l1\")\n",
    "# CNN CPD values will be the transpose of the confusion matrix\n",
    "cnn_values = cnn_confusion_matrix.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Name of the node is \"CNN\"\n",
    "# Total variables = 3 i.e. 1 for each emotion\n",
    "# Set the Emotion node as the evidence\n",
    "cnn_cpd = TabularCPD(\"CNN\", 3, evidence=['Emotion'], evidence_card=[3], values=cnn_values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "╒═════════╤═════════════════════╤═════════════════════╤═════════════════════╕\n",
      "│ Emotion │ Emotion_0           │ Emotion_1           │ Emotion_2           │\n",
      "├─────────┼─────────────────────┼─────────────────────┼─────────────────────┤\n",
      "│ CNN_0   │ 0.618421052631579   │ 0.07539682539682539 │ 0.06917293233082707 │\n",
      "├─────────┼─────────────────────┼─────────────────────┼─────────────────────┤\n",
      "│ CNN_1   │ 0.12105263157894737 │ 0.6666666666666666  │ 0.3022556390977444  │\n",
      "├─────────┼─────────────────────┼─────────────────────┼─────────────────────┤\n",
      "│ CNN_2   │ 0.26052631578947366 │ 0.25793650793650796 │ 0.6285714285714286  │\n",
      "╘═════════╧═════════════════════╧═════════════════════╧═════════════════════╛\n"
     ]
    }
   ],
   "source": [
    "print(cnn_cpd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.6 Create Conditional Probability Distribution Tables for each Label node"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a list to store each label cpd\n",
    "label_cpd_list = []\n",
    "\n",
    "for i in range(len(labels_list)):\n",
    "    # P(label=1|Emotion=Positive)\n",
    "    p_label_1_given_emo_positive = float(positive_ndarray[i]/total_positive_labels)\n",
    "    # P(label=1|Emotion=Neutral)\n",
    "    p_label_1_given_emo_neutral = float(neutral_ndarray[i]/total_neutral_labels)\n",
    "    # P(label=1|Emotion=Negative)\n",
    "    p_label_1_given_emo_negative = float(negative_ndarray[i]/total_negative_labels)\n",
    "    \n",
    "    # if P(label=1|Emotion=Positive) is 0, set it to 0.0001 to fix the error\n",
    "    if p_label_1_given_emo_positive == 0.0:\n",
    "        p_label_1_given_emo_positive = 0.0001\n",
    "\n",
    "    # if P(label=1|Emotion=Neutral) is 0, set it to 0.0001 to fix the error\n",
    "    if p_label_1_given_emo_neutral == 0.0:\n",
    "        p_label_1_given_emo_neutral = 0.0001\n",
    "\n",
    "    # if P(label=1|Emotion=Negative) is 0, set it to 0.0001 to fix the error  \n",
    "    if p_label_1_given_emo_negative == 0.0:\n",
    "        p_label_1_given_emo_negative = 0.0001\n",
    "    \n",
    "    # P(label=0|Emotion=Positive)\n",
    "    p_label_0_given_emo_positive = 1.0 - p_label_1_given_emo_positive\n",
    "    # P(label=0|Emotion=Neutal)\n",
    "    p_label_0_given_emo_neutral = 1.0 - p_label_1_given_emo_neutral\n",
    "    # P(label=0|Emotion=Negative)\n",
    "    p_label_0_given_emo_negative = 1.0 - p_label_1_given_emo_negative\n",
    "    \n",
    "    # Condition Probability Table for the label\n",
    "    label_conditional_probability_table = [[p_label_0_given_emo_positive, p_label_0_given_emo_negative, p_label_0_given_emo_neutral], \n",
    "                                            [p_label_1_given_emo_positive, p_label_1_given_emo_negative, p_label_1_given_emo_neutral]]\n",
    "    \n",
    "    # generate the conditional probability table for that label\n",
    "    # Name of the node is the name of the label\n",
    "    # Total variables = 2 i.e. either 1 or 0\n",
    "    # Set the Emotion node as the evidence\n",
    "    label_cpd = TabularCPD(labels_list[i], 2, evidence=['Emotion'], evidence_card=[3], values=label_conditional_probability_table)\n",
    "\n",
    "#         print(cpd_label)\n",
    "#         ╒═════════╤══════════════════════╤═══════════╤═══════════════════════╕\n",
    "#         │ Emotion │ Emotion_0            │ Emotion_1 │ Emotion_2             │\n",
    "#         ├─────────┼──────────────────────┼───────────┼───────────────────────┤\n",
    "#         │ gown_0  │ 0.974076983503535    │ 1.0       │ 0.9983333333333333    │\n",
    "#         ├─────────┼──────────────────────┼───────────┼───────────────────────┤\n",
    "#         │ gown_1  │ 0.025923016496465043 │ 0.0       │ 0.0016666666666666668 │\n",
    "#         ╘═════════╧══════════════════════╧═══════════╧═══════════════════════╛\n",
    "\n",
    "    # add it to the list\n",
    "    label_cpd_list.append(label_cpd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.7 Add Conditional Probability Tables to the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add the emotion and CNN nodes to the model\n",
    "model.add_cpds(emotion_cpd, cnn_cpd)\n",
    "# Add the cpd for each label\n",
    "for label_cpd in label_cpd_list: model.add_cpds(label_cpd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.8 Check if model is valid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(model.check_model())  # returns True if the model is correct"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<TabularCPD representing P(Emotion:3) at 0x106ce22b0>,\n",
       " <TabularCPD representing P(CNN:3 | Emotion:3) at 0x1123eb588>,\n",
       " <TabularCPD representing P(gown:2 | Emotion:3) at 0x1125566d8>,\n",
       " <TabularCPD representing P(dance:2 | Emotion:3) at 0x112556710>,\n",
       " <TabularCPD representing P(air force:2 | Emotion:3) at 0x112556748>,\n",
       " <TabularCPD representing P(bull:2 | Emotion:3) at 0x112556780>,\n",
       " <TabularCPD representing P(bear:2 | Emotion:3) at 0x1125567b8>,\n",
       " <TabularCPD representing P(yellow:2 | Emotion:3) at 0x1125567f0>,\n",
       " <TabularCPD representing P(tv personality:2 | Emotion:3) at 0x112556828>,\n",
       " <TabularCPD representing P(protest:2 | Emotion:3) at 0x112556860>]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# print the first 10 cpds from the model\n",
    "model.get_cpds()[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "╒═══════════╤══════════╕\n",
      "│ Emotion_0 │ 0.333333 │\n",
      "├───────────┼──────────┤\n",
      "│ Emotion_1 │ 0.333333 │\n",
      "├───────────┼──────────┤\n",
      "│ Emotion_2 │ 0.333333 │\n",
      "╘═══════════╧══════════╛\n"
     ]
    }
   ],
   "source": [
    "# print the cpd for the emotion node\n",
    "print(model.get_cpds('Emotion'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Inference"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1 Set evidences for the nodes using results from Vision API and CNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get labels for the image from Vision API\n",
    "labels_for_image = ['people', 'friendship', 'fun', 'event', 'drinking', 'happy', 'picnic', 'recreation', 'smile', 'leisure']\n",
    "\n",
    "# if detected label is present in labels list then set that label to 1 else 0\n",
    "label_evidences = {label:(1 if label in labels_for_image else 0) for label in labels_list}\n",
    "\n",
    "# get prediction from CNN\n",
    "label_evidences['CNN'] = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.2 Initialize Variable Elimination and query"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "╒═══════════╤════════════════╕\n",
      "│ Emotion   │   phi(Emotion) │\n",
      "╞═══════════╪════════════════╡\n",
      "│ Emotion_0 │         0.9979 │\n",
      "├───────────┼────────────────┤\n",
      "│ Emotion_1 │         0.0000 │\n",
      "├───────────┼────────────────┤\n",
      "│ Emotion_2 │         0.0021 │\n",
      "╘═══════════╧════════════════╛\n"
     ]
    }
   ],
   "source": [
    "# Set the inference method\n",
    "emotion_infer = VariableElimination(model)\n",
    "\n",
    "# Compute the probability of the emotions given the detected labels list\n",
    "q = emotion_infer.query(['Emotion'], evidence=label_evidences)\n",
    "print((q['Emotion']))"
   ]
  }
 ],
 "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}