whoSentMail.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from fractions import Fraction\n",
    "\n",
    "import nltk\n",
    "from nltk import FreqDist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Corpus\n",
    "Ram = ['I wish you the best', 'I hope to reach home by 6 P M', 'I wish to go home early',\n",
    "      'I do not want to buy this', 'I hope it rains today']\n",
    "Raj = ['I hope to play tennis tonight', 'I hope to win this tournament', 'I hope to buy this car in the next year',\n",
    "      'I wish to get a good score this time', 'I wish they would come']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of words in Ram:  32\n",
      "Number of words in Raj:  36\n",
      "Total words in both the corpus:  68\n"
     ]
    }
   ],
   "source": [
    "#Calculate number of words in Ram, Raj and calculate total words\n",
    "ramWords = []\n",
    "for i in range(0,len(Ram)):\n",
    "    #Split the strings based on blankspace\n",
    "    sen = Ram[i].split(' ')\n",
    "    #Extend the list by adding\n",
    "    ramWords.extend(sen)\n",
    "print(\"Number of words in Ram: \", len(ramWords))\n",
    "\n",
    "rajWords = []\n",
    "for i in range(0,len(Raj)):\n",
    "    #Split the strings based on blankspace\n",
    "    sen = Raj[i].split(' ')\n",
    "    #Extend the list by adding\n",
    "    rajWords.extend(sen)\n",
    "print(\"Number of words in Raj: \", len(rajWords))\n",
    "\n",
    "totWords = len(ramWords) + len(rajWords)\n",
    "print(\"Total words in both the corpus: \", totWords)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vocabulary of ram corpus:  23\n",
      "Vocabulary of raj corpus:  24\n",
      "Vocabulary of combined corpus:  40\n"
     ]
    }
   ],
   "source": [
    "uniqRamWords = list(set(ramWords))\n",
    "uniqRajWords = list(set(rajWords))\n",
    "UniqWords = uniqRamWords + uniqRajWords\n",
    "ttlUniqWords = set(UniqWords)\n",
    "\n",
    "print(\"Vocabulary of ram corpus: \", len(uniqRamWords))\n",
    "print(\"Vocabulary of raj corpus: \", len(uniqRajWords))\n",
    "print(\"Vocabulary of combined corpus: \", len(ttlUniqWords))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Frequency of words in Ram Corpus\n",
      " {'I': 5, 'wish': 2, 'you': 1, 'the': 1, 'best': 1, 'hope': 2, 'to': 3, 'reach': 1, 'home': 2, 'by': 1, '6': 1, 'P': 1, 'M': 1, 'go': 1, 'early': 1, 'do': 1, 'not': 1, 'want': 1, 'buy': 1, 'this': 1, 'it': 1, 'rains': 1, 'today': 1}\n",
      "Frequency of words in Raj Corpus\n",
      " {'I': 5, 'hope': 3, 'to': 4, 'play': 1, 'tennis': 1, 'tonight': 1, 'win': 1, 'this': 3, 'tournament': 1, 'buy': 1, 'car': 1, 'in': 1, 'the': 1, 'next': 1, 'year': 1, 'wish': 2, 'get': 1, 'a': 1, 'good': 1, 'score': 1, 'time': 1, 'they': 1, 'would': 1, 'come': 1}\n"
     ]
    }
   ],
   "source": [
    "#Store the frequency distribution of words in the respective corpus as a dictionary \n",
    "fDistRam = dict(nltk.FreqDist(ramWords))\n",
    "fDistRaj = dict(nltk.FreqDist(rajWords))\n",
    "print(\"Frequency of words in Ram Corpus\\n\", fDistRam)\n",
    "print(\"Frequency of words in Raj Corpus\\n\", fDistRaj)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Calculate P(X1|y) = Count(X1,y)/Count(Y)\n",
    "#y are class labels (Ram or Raj)\n",
    "#X1 are words (I, wish, hope etc.)\n",
    "#Y is the total number of words in both the corpus (ie) 68\n",
    "\n",
    "#Define a function to calculate probability and store result as a fraction\n",
    "probRam = {}\n",
    "probRaj = {}\n",
    "def probRamXY(w1):\n",
    "    probRam[w1] = 0\n",
    "    for key, value in fDistRam.items():\n",
    "        if w1 in key:\n",
    "            probRam[w1] = Fraction(value,totWords)\n",
    "    return probRam[w1]\n",
    "\n",
    "def probRajXY(w1):\n",
    "    probRaj[w1] = 0\n",
    "    for key, value in fDistRaj.items():\n",
    "        if w1 in key:\n",
    "            probRaj[w1] = Fraction(value,totWords)\n",
    "    return probRaj[w1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Fraction(3, 68)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "probRajXY('hope')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Fraction(5, 68)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "probRamXY('I')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of words in the combined corpus:  68\n",
      "\n",
      "Unique words in the combined corpus:  40\n",
      "\n",
      "Probabilities of words in Ram corpus: \n",
      " {'tennis': 0, 'by': Fraction(1, 68), 'today': Fraction(1, 68), 'home': Fraction(1, 34), 'car': 0, 'reach': Fraction(1, 68), 'best': Fraction(1, 68), 'do': Fraction(1, 68), 'come': 0, 'want': Fraction(1, 68), 'win': 0, 'tonight': 0, 'go': Fraction(1, 68), 'I': Fraction(5, 68), 'they': 0, 'next': 0, 'P': Fraction(1, 68), 'you': Fraction(1, 68), 'buy': Fraction(1, 68), 'time': 0, 'rains': Fraction(1, 68), '6': Fraction(1, 68), 'early': Fraction(1, 68), 'would': 0, 'M': Fraction(1, 68), 'this': Fraction(1, 68), 'score': 0, 'not': Fraction(1, 68), 'wish': Fraction(1, 34), 'tournament': 0, 'good': 0, 'the': Fraction(1, 68), 'year': 0, 'it': Fraction(1, 68), 'get': 0, 'hope': Fraction(1, 34), 'to': Fraction(1, 68), 'in': Fraction(1, 68), 'play': 0, 'a': Fraction(1, 68)}\n",
      "\n",
      "\n",
      "Length of words for which probability calculated in Ram corpus:  40\n",
      "\n",
      "Probabilities of words in Raj corpus: \n",
      " {'tennis': Fraction(1, 68), 'by': 0, 'today': 0, 'home': 0, 'car': Fraction(1, 68), 'reach': 0, 'best': 0, 'do': 0, 'come': Fraction(1, 68), 'want': 0, 'win': Fraction(1, 68), 'tonight': Fraction(1, 68), 'go': Fraction(1, 68), 'I': Fraction(5, 68), 'they': Fraction(1, 68), 'next': Fraction(1, 68), 'P': 0, 'you': 0, 'buy': Fraction(1, 68), 'time': Fraction(1, 68), 'rains': 0, '6': 0, 'early': 0, 'would': Fraction(1, 68), 'M': 0, 'this': Fraction(3, 68), 'score': Fraction(1, 68), 'not': 0, 'wish': Fraction(1, 34), 'tournament': Fraction(1, 68), 'good': Fraction(1, 68), 'the': Fraction(1, 68), 'year': Fraction(1, 68), 'it': 0, 'get': Fraction(1, 68), 'hope': Fraction(3, 68), 'to': Fraction(1, 68), 'in': Fraction(1, 68), 'play': Fraction(1, 68), 'a': Fraction(1, 68)}\n",
      "\n",
      "\n",
      "Length of words for which probability calculated in Raj corpus:  40\n"
     ]
    }
   ],
   "source": [
    "#Calculate P(X1|y) for all unique words in Ram and Raj corpus and store it in a list\n",
    "prRam = {}\n",
    "prRaj = {}\n",
    "allWords = ramWords + rajWords\n",
    "print(\"Total number of words in the combined corpus: \", len(allWords))\n",
    "uniqWords = set(allWords)\n",
    "print(\"\\nUnique words in the combined corpus: \", len(uniqWords))\n",
    "\n",
    "for words in uniqWords:\n",
    "    prRam[words] = probRamXY(words)\n",
    "    prRaj[words] = probRajXY(words)\n",
    "\n",
    "print(\"\\nProbabilities of words in Ram corpus: \\n\", prRam)\n",
    "print(\"\\n\\nLength of words for which probability calculated in Ram corpus: \", len(prRam))\n",
    "print(\"\\nProbabilities of words in Raj corpus: \\n\", prRaj)\n",
    "print(\"\\n\\nLength of words for which probability calculated in Raj corpus: \", len(prRaj))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prior probability : 1/2\n"
     ]
    }
   ],
   "source": [
    "#Prior probability P(y) = count(y)/count(Y). As there are only two classes it is 1/2\n",
    "PrProb = Fraction(1,2)\n",
    "print(\"Prior probability :\", PrProb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Guess who wrote the sentence \"I wish you would come\"\n",
    "#For Ram Corpus\n",
    "def bRam(w1,w2,w3,w4,w5):\n",
    "    lstVal = []\n",
    "    for key, value in prRam.items():\n",
    "        if key == w1:\n",
    "            lstVal.append(value)\n",
    "        if key == w2:\n",
    "            lstVal.append(value)\n",
    "        if key == w3:\n",
    "            lstVal.append(value)\n",
    "        if key == w4:\n",
    "            lstVal.append(value)\n",
    "        if key == w5:\n",
    "            lstVal.append(value)\n",
    "    finProb = 1\n",
    "    for i in range(len(lstVal)):\n",
    "        finProb = finProb*lstVal[i]\n",
    "    print(\"Baye's Probability from Ram Corpus is: \", PrProb*finProb)\n",
    "    \n",
    "    return lstVal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Baye's Probability from Ram Corpus is:  0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0, Fraction(5, 68), Fraction(1, 68), 0, Fraction(1, 34)]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bRam('I','wish','you','would','come')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bRaj(w1,w2,w3,w4,w5):\n",
    "    lstVal = []\n",
    "    for key, value in prRaj.items():\n",
    "        if key == w1:\n",
    "            lstVal.append(value)\n",
    "        if key == w2:\n",
    "            lstVal.append(value)\n",
    "        if key == w3:\n",
    "            lstVal.append(value)\n",
    "        if key == w4:\n",
    "            lstVal.append(value)\n",
    "        if key == w5:\n",
    "            lstVal.append(value)\n",
    "    #print(any(x == 0 for x in lstVal))\n",
    "    \n",
    "    finProb = 1\n",
    "    for i in range(len(lstVal)):\n",
    "        finProb = finProb*lstVal[i]\n",
    "    print(\"Baye's Probability from Raj Corpus is: \", PrProb*finProb)\n",
    "    \n",
    "    return lstVal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Baye's Probability from Raj Corpus is:  0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[Fraction(1, 68), Fraction(5, 68), 0, Fraction(1, 68), Fraction(1, 34)]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bRaj('I','wish','you','would','come')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Baye's Probability from revised Ram Corpus is:  9/726966784\n",
      "Baye's Probability from revised Raj Corpus is:  9/363483392\n",
      "Raj sent the mail\n"
     ]
    }
   ],
   "source": [
    "#Both probabilities are zero.\n",
    "#Hence add 1 to each of the words in the numerator only\n",
    "\n",
    "#Get the keys of Ram corpus for which the value is zero and store the keys separately\n",
    "keyRam0 = []\n",
    "keyRaj0 = []\n",
    "for k, v in prRam.items():\n",
    "    if v == 0:\n",
    "        keyRam0.append(k)\n",
    "for k, v in prRaj.items():\n",
    "    if v == 0:\n",
    "        keyRaj0.append(k)\n",
    "#print(keyRam0)\n",
    "#print(\"Number of words in combined corpus but not in Ram corpus: \", len(keyRam0))\n",
    "#print(keyRaj0)\n",
    "#print(\"Number of words in combined corpus but not in Raj corpus: \", len(keyRaj0))\n",
    "\n",
    "#Increase numerator values by 1 in the respective dictionary\n",
    "def upProbRamXY(w1):\n",
    "    probRam[w1] = Fraction(1,68)\n",
    "    for key, value in fDistRam.items():\n",
    "        if w1 in key:\n",
    "            probRam[w1] = Fraction(value+1,totWords)\n",
    "    return probRam[w1]\n",
    "\n",
    "def upProbRajXY(w1):\n",
    "    probRaj[w1] = Fraction(1,68)\n",
    "    for key, value in fDistRaj.items():\n",
    "        if w1 in key:\n",
    "            probRaj[w1] = Fraction(value+1,totWords)\n",
    "    return probRaj[w1]\n",
    "\n",
    "#print(\"Probability of missing word car in Ram corpus\", upProbRamXY('car'))\n",
    "#print(\"Probability of missing word home in Raj corpus\",upProbRajXY('home'))\n",
    "#print(\"Original Probability of present word I in Ram corpus\", probRamXY('I'))\n",
    "#print(\"Updated Probability of present word I in Ram corpus\", upProbRamXY('I'))\n",
    "#print(\"Original Probability of present word I in Raj corpus\", probRajXY('I'))\n",
    "#print(\"Updated Probability of present word I in Raj corpus\", upProbRajXY('I'))\n",
    "\n",
    "#update P(X1|y) for all unique words in Ram and Raj corpus and store it in a list\n",
    "uprRam = {}\n",
    "uprRaj = {}\n",
    "\n",
    "for words in uniqWords:\n",
    "    uprRam[words] = upProbRamXY(words)\n",
    "    uprRaj[words] = upProbRajXY(words)\n",
    "\n",
    "#print(\"\\nUpdated Probabilities of words in Ram corpus: \\n\", uprRam)\n",
    "#print(\"\\n\\nUpdated number of words for which probability calculated in Ram corpus: \", len(uprRam))\n",
    "#print(\"\\nUpdated Probabilities of words in Raj corpus: \\n\", uprRaj)\n",
    "#print(\"\\n\\nUpdated number of words for which probability calculated in Raj corpus: \", len(uprRaj))\n",
    "\n",
    "def ubRam(w1,w2,w3,w4,w5):\n",
    "    lstVal = []\n",
    "    for key, value in uprRam.items():\n",
    "        if key == w1:\n",
    "            lstVal.append(value)\n",
    "        if key == w2:\n",
    "            lstVal.append(value)\n",
    "        if key == w3:\n",
    "            lstVal.append(value)\n",
    "        if key == w4:\n",
    "            lstVal.append(value)\n",
    "        if key == w5:\n",
    "            lstVal.append(value)\n",
    "    finProb = 1\n",
    "    for i in range(len(lstVal)):\n",
    "        finProb = finProb*lstVal[i]\n",
    "    print(\"Baye's Probability from revised Ram Corpus is: \", PrProb*finProb)\n",
    "    \n",
    "    return finProb\n",
    "\n",
    "def ubRaj(w1,w2,w3,w4,w5):\n",
    "    lstVal = []\n",
    "    for key, value in uprRaj.items():\n",
    "        if key == w1:\n",
    "            lstVal.append(value)\n",
    "        if key == w2:\n",
    "            lstVal.append(value)\n",
    "        if key == w3:\n",
    "            lstVal.append(value)\n",
    "        if key == w4:\n",
    "            lstVal.append(value)\n",
    "        if key == w5:\n",
    "            lstVal.append(value)\n",
    "       \n",
    "    finProb = 1\n",
    "    for i in range(len(lstVal)):\n",
    "        finProb = finProb*lstVal[i]\n",
    "    print(\"Baye's Probability from revised Raj Corpus is: \", PrProb*finProb)\n",
    "    \n",
    "    return float(finProb)\n",
    "\n",
    "#print(bRam('I','wish','you','would','come'))\n",
    "#print(bRaj('I','wish','you','would','come'))\n",
    "valUpdatedRam = ubRam('I','wish','you','would','come')\n",
    "valUpdatedRaj = ubRaj('I','wish','you','would','come')\n",
    "print(\"Ram sent the mail\") if valUpdatedRam > valUpdatedRaj else print(\"Raj sent the mail\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             Ram   Raj\n",
      "Word                  \n",
      "motivate    0.24  0.05\n",
      "profit      0.30  0.35\n",
      "product     0.26  0.35\n",
      "leadership  0.08  0.15\n",
      "operations  0.12  0.10\n"
     ]
    }
   ],
   "source": [
    "#Find the sender of the email - Ram or Raj\n",
    "#A new mail arrives with just three words - motivate, profit and product\n",
    "#Historical information provided\n",
    "import pandas as pd\n",
    "data = [['motivate',0.24,0.05],['profit',0.3,0.35],['product',0.26,0.35],['leadership',0.08,0.15],['operations',0.12,0.10]]\n",
    "df = pd.DataFrame(data, columns = ['Word','Ram','Raj'])\n",
    "df.set_index('Word', inplace = True)\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Probability mail sent by Ram is:  0.01872\n",
      "Probability mail sent by Raj is:  0.006124999999999999\n",
      "Mail sent by Ram\n"
     ]
    }
   ],
   "source": [
    "#Create a wordlist for search words and calculate Bayesian probability for Ram and Raj\n",
    "#Max value of Bayesian product will be the sender of the email\n",
    "wordList = ['motivate', 'profit', 'product']\n",
    "probRam = 1\n",
    "probRaj = 1\n",
    "for i in wordList:\n",
    "    valRam = df.loc[i,'Ram']\n",
    "    valRaj = df.loc[i,'Raj']\n",
    "    probRam = valRam*probRam\n",
    "    probRaj = valRaj*probRaj\n",
    "print(\"Probability mail sent by Ram is: \", probRam)\n",
    "print(\"Probability mail sent by Raj is: \", probRaj)\n",
    "print(\"Mail sent by Ram\") if probRam > probRaj else print(\"Mail sent by Raj\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "          Word  Positive  Negative\n",
      "0            I      0.09      0.16\n",
      "1         love      0.07      0.06\n",
      "2           to      0.05      0.07\n",
      "3         fill      0.29      0.06\n",
      "4       credit      0.04      0.15\n",
      "5         card      0.08      0.11\n",
      "6  application      0.06      0.04\n"
     ]
    }
   ],
   "source": [
    "#Product sentiments\n",
    "#Assume the following likelihood for each word being part of positive or negative review\n",
    "#Equal prior probabilities for each class (P(positive) = 0.5 and P(negative) =0.5)\n",
    "#What class Naive Bayes classifier would assign to the sentence \"I do not like to fill in the application form\"\n",
    "data2 = [['I',0.09,0.16],['love',0.07,0.06],['to',0.05,0.07],['fill',0.29,0.06],\n",
    "        ['credit',0.04,0.15],['card',0.08,0.11],['application',0.06,0.04]]\n",
    "df2 = pd.DataFrame(data2, columns=['Word','Positive','Negative'])\n",
    "#df2.set_index('Word', inplace = True)\n",
    "print(df2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "words = ['I','do','not','like','to','fill','in','the','application','form']\n",
    "#Out of vocab words are: do, not, like, in, the, form (six words)\n",
    "\n",
    "#Create two separate empty lists and populate them with matched vocabulary and out of vocabulary words\n",
    "wordsMatch = []\n",
    "wordsNoMatch = []\n",
    "\n",
    "for i in words:\n",
    "    if (df2['Word'] == i).any():\n",
    "        wordsMatch.append(i)\n",
    "    else:\n",
    "        wordsNoMatch.append(i)\n",
    "\n",
    "#print(\"List of matched words: \", wordsMatch)\n",
    "#print(\"List of out of vocabulary words: \", wordsNoMatch)\n",
    "#print(\"Total number of words: \", len(words))\n",
    "#print(\"Number of matched words: \", len(wordsMatch))\n",
    "#print(\"Number of out of vocabulary words: \", len(wordsNoMatch))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             Positive  Negative\n",
      "Word                           \n",
      "I                0.09      0.16\n",
      "to               0.05      0.07\n",
      "fill             0.29      0.06\n",
      "application      0.06      0.04\n",
      "do               0.50      0.50\n",
      "not              0.50      0.50\n",
      "like             0.50      0.50\n",
      "in               0.50      0.50\n",
      "the              0.50      0.50\n",
      "form             0.50      0.50\n"
     ]
    }
   ],
   "source": [
    "#Subset df2 containing matched words into a new dataframe newDF\n",
    "newDF = pd.DataFrame(columns=['Word','Positive','Negative'])\n",
    "\n",
    "for i in wordsMatch:\n",
    "    if (df2['Word'].str.contains(i)).any():\n",
    "        newDF = newDF.append(df2.loc[df2['Word'] == i])\n",
    "        #print(i, \"is there\")\n",
    "\n",
    "#Create a new dataframe called oov (out of vocabulary) with words from wordsNoMatch as words and probability values 0.5\n",
    "oovDF = pd.DataFrame(columns=['Word','Positive','Negative'])\n",
    "for i in range(len(wordsNoMatch)):\n",
    "    oovDF.loc[i] = [wordsNoMatch[i]] + [0.5] + [0.5]\n",
    "\n",
    "#Concatenate newDF and oovDF into one single dataframe and set the index as Word column\n",
    "frames = [newDF, oovDF]\n",
    "merged = pd.concat(frames, ignore_index=True)\n",
    "merged.set_index('Word',inplace = True)\n",
    "print(merged)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Probability Review is positive:  1.2234374999999997e-06\n",
      "Probability Review is negative:  4.2000000000000006e-07\n",
      "Positive Review\n"
     ]
    }
   ],
   "source": [
    "#Calculate Bayesian probability for positive and negative reviews\n",
    "words = ['I','do','not','like','to','fill','in','the','application','form']\n",
    "probPos = 1\n",
    "probNeg = 1\n",
    "for i in words:\n",
    "    valPos = merged.loc[i,'Positive']\n",
    "    valNeg = merged.loc[i,'Negative']\n",
    "    probPos = valPos*probPos\n",
    "    probNeg = valNeg*probNeg\n",
    "print(\"Probability Review is positive: \", probPos)\n",
    "print(\"Probability Review is negative: \", probNeg)\n",
    "print(\"Positive Review\") if probPos > probNeg else print(\"Negative Review\")"
   ]
  },
  {
   "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}