sms_spam_classifier_ (1).ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "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.7.4"
    },
    "colab": {
      "name": "udacity_spam_classifier_.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "IcmdePW3WQIG",
        "A1o8L3JqWQIZ",
        "pAZsFKWgWQIb",
        "i2wXDFrlWQIg",
        "pFXo9QVyWQIv",
        "gb2Dh_fdWQJA",
        "JiHr_26LWQJM",
        "eXtSQDMXWQJS"
      ]
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lWQPLlKXWQHv",
        "colab_type": "text"
      },
      "source": [
        "## Our Mission ##\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GCvvSWldWQHw",
        "colab_type": "text"
      },
      "source": [
        "### Step 0: Introduction to the Naive Bayes Theorem ###\n",
        "\n",
        "Bayes Theorem is one of the earliest probabilistic inference algorithms. It was developed by Reverend Bayes (which he used to try and infer the existence of God no less), and still performs extremely well for certain use cases. \n",
        "\n",
        "It's best to understand this theorem using an example. Let's say you are a member of the Secret Service and you have been deployed to protect the Democratic presidential nominee during one of his/her campaign speeches. Being a public event that is open to all, your job is not easy and you have to be on the constant lookout for threats. So one place to start is to put a certain threat-factor for each person. So based on the features of an individual, like the age, sex, and other smaller factors like whether the person is carrying a bag, looks nervous, etc., you can make a judgment call as to whether that person is a viable threat. \n",
        "\n",
        "If an individual ticks all the boxes up to a level where it crosses a threshold of doubt in your mind, you can take action and remove that person from the vicinity. Bayes Theorem works in the same way, as we are computing the probability of an event (a person being a threat) based on the probabilities of certain related events (age, sex, presence of bag or not, nervousness of the person, etc.). \n",
        "\n",
        "One thing to consider is the independence of these features amongst each other. For example if a child looks nervous at the event then the likelihood of that person being a threat is not as much as say if it was a grown man who was nervous. To break this down a bit further, here there are two features we are considering, age AND nervousness. Say we look at these features individually, we could design a model that flags ALL persons that are nervous as potential threats. However, it is likely that we will have a lot of false positives as there is a strong chance that minors present at the event will be nervous. Hence by considering the age of a person along with the 'nervousness' feature we would definitely get a more accurate result as to who are potential threats and who aren't. \n",
        "\n",
        "This is the 'Naive' bit of the theorem where it considers each feature to be independent of each other which may not always be the case and hence that can affect the final judgement.\n",
        "\n",
        "In short, Bayes Theorem calculates the probability of a certain event happening (in our case, a message being spam) based on the joint probabilistic distributions of certain other events (in our case, the appearance of certain words in a message). We will dive into the workings of Bayes Theorem later in the mission, but first, let us understand the data we are going to work with."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5jHcCynQWQHw",
        "colab_type": "text"
      },
      "source": [
        "### Step 1.1: Understanding our dataset ### \n",
        "\n",
        "\n",
        "We will be using a dataset originally compiled and posted on the UCI Machine Learning repository which has a very good collection of datasets for experimental research purposes. If you're interested, you can review the [abstract](https://archive.ics.uci.edu/ml/datasets/SMS+Spam+Collection) and the original [compressed data file](https://archive.ics.uci.edu/ml/machine-learning-databases/00228/) on the UCI site. For this exercise, however, we've gone ahead and downloaded the data for you.\n",
        "\n",
        "\n",
        " ** Here's a preview of the data: ** \n",
        "\n",
        "<img src=\"images/dqnb.png\" height=\"1242\" width=\"1242\">\n",
        "\n",
        "The columns in the data set are currently not named and as you can see, there are 2 columns. \n",
        "\n",
        "The first column takes two values, 'ham' which signifies that the message is not spam, and 'spam' which signifies that the message is spam. \n",
        "\n",
        "The second column is the text content of the SMS message that is being classified."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": true,
        "id": "S-WYa50OWQHx",
        "colab_type": "text"
      },
      "source": [
        ">**Instructions:**\n",
        "* Import the dataset into a pandas dataframe using the **read_table** method. The file has already been downloaded, and you can access it using the filepath 'smsspamcollection/SMSSpamCollection'. Because this is a tab separated dataset we will be using '\\\\t' as the value for the 'sep' argument which specifies this format. \n",
        "* Also, rename the column names by specifying a list ['label, 'sms_message'] to the 'names' argument of read_table().\n",
        "* Print the first five values of the dataframe with the new column names."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "amkiFHNSWQHx",
        "colab_type": "code",
        "colab": {},
        "outputId": "c475ec08-4f9e-41c6-ba3d-8d7405a8d9d0"
      },
      "source": [
        "'''\n",
        "Solution\n",
        "'''\n",
        "import pandas as pd\n",
        "# Dataset available using filepath 'smsspamcollection/SMSSpamCollection'\n",
        "df = pd.read_table('smsspamcollection/SMSSpamCollection',\n",
        "                   sep='\\t', \n",
        "                   header=None, \n",
        "                   names=['label', 'sms_message'])\n",
        "\n",
        "# Output printing out first 5 rows\n",
        "df.head()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>label</th>\n",
              "      <th>sms_message</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>ham</td>\n",
              "      <td>Go until jurong point, crazy.. Available only ...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>ham</td>\n",
              "      <td>Ok lar... Joking wif u oni...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>spam</td>\n",
              "      <td>Free entry in 2 a wkly comp to win FA Cup fina...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>ham</td>\n",
              "      <td>U dun say so early hor... U c already then say...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>ham</td>\n",
              "      <td>Nah I don't think he goes to usf, he lives aro...</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "  label                                        sms_message\n",
              "0   ham  Go until jurong point, crazy.. Available only ...\n",
              "1   ham                      Ok lar... Joking wif u oni...\n",
              "2  spam  Free entry in 2 a wkly comp to win FA Cup fina...\n",
              "3   ham  U dun say so early hor... U c already then say...\n",
              "4   ham  Nah I don't think he goes to usf, he lives aro..."
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "24Jjf2bDWQH1",
        "colab_type": "text"
      },
      "source": [
        "### Step 1.2: Data Preprocessing ###\n",
        "\n",
        "Now that we have a basic understanding of what our dataset looks like, lets convert our labels to binary variables, 0 to represent 'ham'(i.e. not spam) and 1 to represent 'spam' for ease of computation. \n",
        "\n",
        "You might be wondering why do we need to do this step? The answer to this lies in how scikit-learn handles inputs. Scikit-learn only deals with numerical values and hence if we were to leave our label values as strings, scikit-learn would do the conversion internally(more specifically, the string labels will be cast to unknown float values). \n",
        "\n",
        "Our model would still be able to make predictions if we left our labels as strings but we could have issues later when calculating performance metrics, for example when calculating our precision and recall scores. Hence, to avoid unexpected 'gotchas' later, it is good practice to have our categorical values be fed into our model as integers. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": true,
        "id": "tytimyRdWQH1",
        "colab_type": "text"
      },
      "source": [
        ">**Instructions:**\n",
        "* Convert the values in the 'label' colum to numerical values using map method as follows:\n",
        "{'ham':0, 'spam':1} This maps the 'ham' value to 0 and the 'spam' value to 1.\n",
        "* Also, to get an idea of the size of the dataset we are dealing with, print out number of rows and columns using \n",
        "'shape'."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kpO8I4lJWQH2",
        "colab_type": "code",
        "colab": {},
        "outputId": "b935b501-2984-4e9d-e5d0-7f8650751bb7"
      },
      "source": [
        "'''\n",
        "Solution\n",
        "'''\n",
        "df['label'] = df.label.map({'ham':0, 'spam':1})\n",
        "print(df.shape)\n",
        "df.head() # returns (rows, columns)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(5572, 2)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>label</th>\n",
              "      <th>sms_message</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>0</td>\n",
              "      <td>Go until jurong point, crazy.. Available only ...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>0</td>\n",
              "      <td>Ok lar... Joking wif u oni...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>1</td>\n",
              "      <td>Free entry in 2 a wkly comp to win FA Cup fina...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>0</td>\n",
              "      <td>U dun say so early hor... U c already then say...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>0</td>\n",
              "      <td>Nah I don't think he goes to usf, he lives aro...</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "   label                                        sms_message\n",
              "0      0  Go until jurong point, crazy.. Available only ...\n",
              "1      0                      Ok lar... Joking wif u oni...\n",
              "2      1  Free entry in 2 a wkly comp to win FA Cup fina...\n",
              "3      0  U dun say so early hor... U c already then say...\n",
              "4      0  Nah I don't think he goes to usf, he lives aro..."
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f7Zf6W1dWQH4",
        "colab_type": "text"
      },
      "source": [
        "### Step 2.1: Bag of words ###\n",
        "\n",
        "What we have here in our data set is a large collection of text data (5,572 rows of data). Most ML algorithms rely on numerical data to be fed into them as input, and email/sms messages are usually text heavy. \n",
        "\n",
        "Here we'd like to introduce the Bag of Words(BoW) concept which is a term used to specify the problems that have a 'bag of words' or a collection of text data that needs to be worked with. The basic idea of BoW is to take a piece of text and count the frequency of the words in that text. It is important to note that the BoW concept treats each word individually and the order in which the words occur does not matter. \n",
        "\n",
        "Using a process which we will go through now, we can covert a collection of documents to a matrix, with each document being a row and each word(token) being the column, and the corresponding (row,column) values being the frequency of occurrance of each word or token in that document.\n",
        "\n",
        "For example: \n",
        "\n",
        "Lets say we have 4 documents as follows:\n",
        "\n",
        "`['Hello, how are you!',\n",
        "'Win money, win from home.',\n",
        "'Call me now',\n",
        "'Hello, Call you tomorrow?']`\n",
        "\n",
        "Our objective here is to convert this set of text to a frequency distribution matrix, as follows:\n",
        "\n",
        "<img src=\"images/countvectorizer.png\" height=\"542\" width=\"542\">\n",
        "\n",
        "Here as we can see, the documents are numbered in the rows, and each word is a column name, with the corresponding value being the frequency of that word in the document.\n",
        "\n",
        "Lets break this down and see how we can do this conversion using a small set of documents.\n",
        "\n",
        "To handle this, we will be using sklearns \n",
        "[count vectorizer](http://scikit-learn.org/stable/modules/generated/sklearn.feature_extraction.text.CountVectorizer.html#sklearn.feature_extraction.text.CountVectorizer) method which does the following:\n",
        "\n",
        "* It tokenizes the string(separates the string into individual words) and gives an integer ID to each token.\n",
        "* It counts the occurrance of each of those tokens.\n",
        "\n",
        "**Please Note:** \n",
        "\n",
        "* The CountVectorizer method automatically converts all tokenized words to their lower case form so that it does not treat words like 'He' and 'he' differently. It does this using the `lowercase` parameter which is by default set to `True`.\n",
        "\n",
        "* It also ignores all punctuation so that words followed by a punctuation mark (for example: 'hello!') are not treated differently than the same words not prefixed or suffixed by a punctuation mark (for example: 'hello'). It does this using the `token_pattern` parameter which has a default regular expression which selects tokens of 2 or more alphanumeric characters.\n",
        "\n",
        "* The third parameter to take note of is the `stop_words` parameter. Stop words refer to the most commonly used words in a language. They include words like 'am', 'an', 'and', 'the' etc. By setting this parameter value to `english`, CountVectorizer will automatically ignore all words(from our input text) that are found in the built in list of english stop words in scikit-learn. This is extremely helpful as stop words can skew our calculations when we are trying to find certain key words that are indicative of spam.\n",
        "\n",
        "We will dive into the application of each of these into our model in a later step, but for now it is important to be aware of such preprocessing techniques available to us when dealing with textual data."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r9l9Z3LXWQH4",
        "colab_type": "text"
      },
      "source": [
        "### Step 2.2: Implementing Bag of Words from scratch ###\n",
        "\n",
        "Before we dive into scikit-learn's Bag of Words(BoW) library to do the dirty work for us, let's implement it ourselves first so that we can understand what's happening behind the scenes. \n",
        "\n",
        "**Step 1: Convert all strings to their lower case form.**\n",
        "\n",
        "Let's say we have a document set:\n",
        "\n",
        "```\n",
        "documents = ['Hello, how are you!',\n",
        "             'Win money, win from home.',\n",
        "             'Call me now.',\n",
        "             'Hello, Call hello you tomorrow?']\n",
        "```\n",
        ">>**Instructions:**\n",
        "* Convert all the strings in the documents set to their lower case. Save them into a list called 'lower_case_documents'. You can convert strings to their lower case in python by using the lower() method.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YKzy8_ZXWQH5",
        "colab_type": "code",
        "colab": {},
        "outputId": "f0d289cf-a7ab-442b-f2f3-be4a3ef74011"
      },
      "source": [
        "'''\n",
        "Solution:\n",
        "'''\n",
        "documents = ['Hello, how are you!',\n",
        "             'Win money, win from home.',\n",
        "             'Call me now.',\n",
        "             'Hello, Call hello you tomorrow?']\n",
        "\n",
        "lower_case_documents = []\n",
        "for i in documents:\n",
        "    lower_case_documents.append(i.lower())\n",
        "print(lower_case_documents)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['hello, how are you!', 'win money, win from home.', 'call me now.', 'hello, call hello you tomorrow?']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YQS0v4O8WQH7",
        "colab_type": "text"
      },
      "source": [
        "**Step 2: Removing all punctuation**\n",
        "\n",
        ">>**Instructions:**\n",
        "Remove all punctuation from the strings in the document set. Save them into a list called \n",
        "'sans_punctuation_documents'. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n8cOVnbhWQH8",
        "colab_type": "code",
        "colab": {},
        "outputId": "ba410db5-adb9-4d9a-c96e-4de9bb634a99"
      },
      "source": [
        "'''\n",
        "Solution:\n",
        "'''\n",
        "sans_punctuation_documents = []\n",
        "import string\n",
        "\n",
        "for i in lower_case_documents:\n",
        "    sans_punctuation_documents.append(i.translate(str.maketrans('', '', string.punctuation)))\n",
        "print(sans_punctuation_documents)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['hello how are you', 'win money win from home', 'call me now', 'hello call hello you tomorrow']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5Z5V8_ELWQH-",
        "colab_type": "text"
      },
      "source": [
        "**Step 3: Tokenization**\n",
        "\n",
        "Tokenizing a sentence in a document set means splitting up a sentence into individual words using a delimiter. The delimiter specifies what character we will use to identify the beginning and the end of a word(for example we could use a single space as the delimiter for identifying words in our document set.)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": true,
        "id": "DRnlHz1XWQH_",
        "colab_type": "text"
      },
      "source": [
        ">>**Instructions:**\n",
        "Tokenize the strings stored in 'sans_punctuation_documents' using the split() method. Store the final document set \n",
        "in a list called 'preprocessed_documents'.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vcvFRW79WQH_",
        "colab_type": "code",
        "colab": {},
        "outputId": "28d83373-0dbf-4d77-dcad-177c47f762f7"
      },
      "source": [
        "'''\n",
        "Solution:\n",
        "'''\n",
        "preprocessed_documents = []\n",
        "for i in sans_punctuation_documents:\n",
        "    preprocessed_documents.append(i.split(' '))\n",
        "print(preprocessed_documents)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[['hello', 'how', 'are', 'you'], ['win', 'money', 'win', 'from', 'home'], ['call', 'me', 'now'], ['hello', 'call', 'hello', 'you', 'tomorrow']]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ns3fUgfIWQIC",
        "colab_type": "text"
      },
      "source": [
        "**Step 4: Count frequencies**\n",
        "\n",
        "Now that we have our document set in the required format, we can proceed to counting the occurrence of each word in each document of the document set. We will use the `Counter` method from the Python `collections` library for this purpose. \n",
        "\n",
        "`Counter` counts the occurrence of each item in the list and returns a dictionary with the key as the item being counted and the corresponding value being the count of that item in the list. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": true,
        "id": "0AbE9v6_WQID",
        "colab_type": "text"
      },
      "source": [
        ">>**Instructions:**\n",
        "Using the Counter() method and preprocessed_documents as the input, create a dictionary with the keys being each word in each document and the corresponding values being the frequncy of occurrence of that word. Save each Counter dictionary as an item in a list called 'frequency_list'.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Fy0yFb-AWQID",
        "colab_type": "code",
        "colab": {},
        "outputId": "d57efa74-c11d-47f0-83ac-695031d02f1d"
      },
      "source": [
        "'''\n",
        "Solution\n",
        "'''\n",
        "frequency_list = []\n",
        "import pprint\n",
        "from collections import Counter\n",
        "\n",
        "for i in preprocessed_documents:\n",
        "    frequency_counts = Counter(i)\n",
        "    frequency_list.append(frequency_counts)\n",
        "pprint.pprint(frequency_list)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[Counter({'hello': 1, 'how': 1, 'are': 1, 'you': 1}),\n",
            " Counter({'win': 2, 'money': 1, 'from': 1, 'home': 1}),\n",
            " Counter({'call': 1, 'me': 1, 'now': 1}),\n",
            " Counter({'hello': 2, 'call': 1, 'you': 1, 'tomorrow': 1})]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c4FcIQc4WQIF",
        "colab_type": "text"
      },
      "source": [
        "Congratulations! You have implemented the Bag of Words process from scratch! As we can see in our previous output, we have a frequency distribution dictionary which gives a clear view of the text that we are dealing with.\n",
        "\n",
        "We should now have a solid understanding of what is happening behind the scenes in the `sklearn.feature_extraction.text.CountVectorizer` method of scikit-learn. \n",
        "\n",
        "We will now implement `sklearn.feature_extraction.text.CountVectorizer` method in the next step."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IcmdePW3WQIG",
        "colab_type": "text"
      },
      "source": [
        "### Step 2.3: Implementing Bag of Words in scikit-learn ###\n",
        "\n",
        "Now that we have implemented the BoW concept from scratch, let's go ahead and use scikit-learn to do this process in a clean and succinct way. We will use the same document set as we used in the previous step. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "npgkWtkDWQIG",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "'''\n",
        "Here we will look to create a frequency matrix on a smaller document set to make sure we understand how the \n",
        "document-term matrix generation happens. We have created a sample document set 'documents'.\n",
        "'''\n",
        "documents = ['Hello, how are you!',\n",
        "                'Win money, win from home.',\n",
        "                'Call me now.',\n",
        "                'Hello, Call hello you tomorrow?']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dEKrRU4-WQII",
        "colab_type": "text"
      },
      "source": [
        ">>**Instructions:**\n",
        "Import the sklearn.feature_extraction.text.CountVectorizer method and create an instance of it called 'count_vector'. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L1lEiskhWQIJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "'''\n",
        "Solution\n",
        "'''\n",
        "from sklearn.feature_extraction.text import CountVectorizer\n",
        "count_vector = CountVectorizer()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2aqZMb9fWQIM",
        "colab_type": "text"
      },
      "source": [
        "** Data preprocessing with CountVectorizer() **\n",
        "\n",
        "In Step 2.2, we implemented a version of the CountVectorizer() method from scratch that entailed cleaning our data first. This cleaning involved converting all of our data to lower case and removing all punctuation marks. CountVectorizer() has certain parameters which take care of these steps for us. They are:\n",
        "\n",
        "* `lowercase = True`\n",
        "    \n",
        "    The `lowercase` parameter has a default value of `True` which converts all of our text to its lower case form.\n",
        "\n",
        "\n",
        "* `token_pattern = (?u)\\\\b\\\\w\\\\w+\\\\b`\n",
        "    \n",
        "    The `token_pattern` parameter has a default regular expression value of `(?u)\\\\b\\\\w\\\\w+\\\\b` which ignores all punctuation marks and treats them as delimiters, while accepting alphanumeric strings of length greater than or equal to 2, as individual tokens or words.\n",
        "\n",
        "\n",
        "* `stop_words`\n",
        "\n",
        "    The `stop_words` parameter, if set to `english` will remove all words from our document set that match a list of English stop words which is defined in scikit-learn. Considering the size of our dataset and the fact that we are dealing with SMS messages and not larger text sources like e-mail, we will not be setting this parameter value.\n",
        "\n",
        "You can take a look at all the parameter values of your `count_vector` object by simply printing out the object as follows:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MpVZOlhmWQIN",
        "colab_type": "code",
        "colab": {},
        "outputId": "f7958003-6c9f-41e0-9573-3dc1de47aa4b"
      },
      "source": [
        "'''\n",
        "Practice node:\n",
        "Print the 'count_vector' object which is an instance of 'CountVectorizer()'\n",
        "'''\n",
        "print(count_vector)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "CountVectorizer(analyzer='word', binary=False, decode_error='strict',\n",
            "        dtype=<class 'numpy.int64'>, encoding='utf-8', input='content',\n",
            "        lowercase=True, max_df=1.0, max_features=None, min_df=1,\n",
            "        ngram_range=(1, 1), preprocessor=None, stop_words=None,\n",
            "        strip_accents=None, token_pattern='(?u)\\\\b\\\\w\\\\w+\\\\b',\n",
            "        tokenizer=None, vocabulary=None)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": true,
        "id": "QU4wQXKnWQIP",
        "colab_type": "text"
      },
      "source": [
        ">>**Instructions:**\n",
        "Fit your document dataset to the CountVectorizer object you have created using fit(), and get the list of words \n",
        "which have been categorized as features using the get_feature_names() method."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Nr8SKiDaWQIP",
        "colab_type": "code",
        "colab": {},
        "outputId": "74043887-0f60-4f4d-8e3b-01a8b7aa83f3"
      },
      "source": [
        "'''\n",
        "Solution:\n",
        "'''\n",
        "count_vector.fit(documents)\n",
        "count_vector.get_feature_names()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['are',\n",
              " 'call',\n",
              " 'from',\n",
              " 'hello',\n",
              " 'home',\n",
              " 'how',\n",
              " 'me',\n",
              " 'money',\n",
              " 'now',\n",
              " 'tomorrow',\n",
              " 'win',\n",
              " 'you']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C772zVCAWQIR",
        "colab_type": "text"
      },
      "source": [
        "The `get_feature_names()` method returns our feature names for this dataset, which is the set of words that make up our vocabulary for 'documents'."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I779mW6ZWQIS",
        "colab_type": "text"
      },
      "source": [
        ">>**\n",
        "Instructions:**\n",
        "Create a matrix with the rows being each of the 4 documents, and the columns being each word. \n",
        "The corresponding (row, column) value is the frequency of occurrance of that word(in the column) in a particular\n",
        "document(in the row). You can do this using the transform() method and passing in the document data set as the \n",
        "argument. The transform() method returns a matrix of numpy integers, you can convert this to an array using\n",
        "toarray(). Call the array 'doc_array'\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "smz9mmt1WQIS",
        "colab_type": "code",
        "colab": {},
        "outputId": "b78858d0-d55b-4b7e-e150-61a726488492"
      },
      "source": [
        "'''\n",
        "Solution\n",
        "'''\n",
        "doc_array = count_vector.transform(documents).toarray()\n",
        "doc_array"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1],\n",
              "       [0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 2, 0],\n",
              "       [0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0],\n",
              "       [0, 1, 0, 2, 0, 0, 0, 0, 0, 1, 0, 1]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SAP0KQyxWQIU",
        "colab_type": "text"
      },
      "source": [
        "Now we have a clean representation of the documents in terms of the frequency distribution of the words in them. To make it easier to understand our next step is to convert this array into a dataframe and name the columns appropriately."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uOPiFAsrWQIV",
        "colab_type": "text"
      },
      "source": [
        ">>**Instructions:**\n",
        "Convert the array we obtained, loaded into 'doc_array', into a dataframe and set the column names to \n",
        "the word names(which you computed earlier using get_feature_names(). Call the dataframe 'frequency_matrix'.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nY2ldN7RWQIV",
        "colab_type": "code",
        "colab": {},
        "outputId": "1502a8ee-f31b-4591-91bf-cd5d3917a7a9"
      },
      "source": [
        "'''\n",
        "Solution\n",
        "'''\n",
        "frequency_matrix = pd.DataFrame(doc_array, \n",
        "                                columns = count_vector.get_feature_names())\n",
        "frequency_matrix"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>are</th>\n",
              "      <th>call</th>\n",
              "      <th>from</th>\n",
              "      <th>hello</th>\n",
              "      <th>home</th>\n",
              "      <th>how</th>\n",
              "      <th>me</th>\n",
              "      <th>money</th>\n",
              "      <th>now</th>\n",
              "      <th>tomorrow</th>\n",
              "      <th>win</th>\n",
              "      <th>you</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>2</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>2</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "   are  call  from  hello  home  how  me  money  now  tomorrow  win  you\n",
              "0    1     0     0      1     0    1   0      0    0         0    0    1\n",
              "1    0     0     1      0     1    0   0      1    0         0    2    0\n",
              "2    0     1     0      0     0    0   1      0    1         0    0    0\n",
              "3    0     1     0      2     0    0   0      0    0         1    0    1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Gyfd7VxcWQIX",
        "colab_type": "text"
      },
      "source": [
        "Congratulations! You have successfully implemented a Bag of Words problem for a document dataset that we created. \n",
        "\n",
        "One potential issue that can arise from using this method out of the box is the fact that if our dataset of text is extremely large(say if we have a large collection of news articles or email data), there will be certain values that are more common that others simply due to the structure of the language itself. So for example words like 'is', 'the', 'an', pronouns, grammatical contructs etc could skew our matrix and affect our analyis. \n",
        "\n",
        "There are a couple of ways to mitigate this. One way is to use the `stop_words` parameter and set its value to `english`. This will automatically ignore all words(from our input text) that are found in a built in list of English stop words in scikit-learn.\n",
        "\n",
        "Another way of mitigating this is by using the [tfidf](http://scikit-learn.org/stable/modules/generated/sklearn.feature_extraction.text.TfidfVectorizer.html#sklearn.feature_extraction.text.TfidfVectorizer) method. This method is out of scope for the context of this lesson."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A1o8L3JqWQIZ",
        "colab_type": "text"
      },
      "source": [
        "### Step 3.1: Training and testing sets ###\n",
        "\n",
        "Now that we have understood how to deal with the Bag of Words problem we can get back to our dataset and proceed with our analysis. Our first step in this regard would be to split our dataset into a training and testing set so we can test our model later. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vE6SzGWWWQIZ",
        "colab_type": "text"
      },
      "source": [
        "\n",
        ">>**Instructions:**\n",
        "Split the dataset into a training and testing set by using the train_test_split method in sklearn. Split the data\n",
        "using the following variables:\n",
        "* `X_train` is our training data for the 'sms_message' column.\n",
        "* `y_train` is our training data for the 'label' column\n",
        "* `X_test` is our testing data for the 'sms_message' column.\n",
        "* `y_test` is our testing data for the 'label' column\n",
        "Print out the number of rows we have in each our training and testing data.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qbq4YfHbWQIa",
        "colab_type": "code",
        "colab": {},
        "outputId": "658f364e-ff88-4ff6-994e-ac494b67c2b4"
      },
      "source": [
        "'''\n",
        "Solution\n",
        "\n",
        "NOTE: sklearn.cross_validation will be deprecated soon to sklearn.model_selection \n",
        "'''\n",
        "# split into training and testing sets\n",
        "\n",
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "X_train, X_test, y_train, y_test = train_test_split(df['sms_message'], \n",
        "                                                    df['label'], \n",
        "                                                    random_state=1)\n",
        "\n",
        "print('Number of rows in the total set: {}'.format(df.shape[0]))\n",
        "print('Number of rows in the training set: {}'.format(X_train.shape[0]))\n",
        "print('Number of rows in the test set: {}'.format(X_test.shape[0]))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Number of rows in the total set: 5572\n",
            "Number of rows in the training set: 4179\n",
            "Number of rows in the test set: 1393\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pAZsFKWgWQIb",
        "colab_type": "text"
      },
      "source": [
        "### Step 3.2: Applying Bag of Words processing to our dataset. ###\n",
        "\n",
        "Now that we have split the data, our next objective is to follow the steps from Step 2: Bag of words and convert our data into the desired matrix format. To do this we will be using CountVectorizer() as we did before. There are two  steps to consider here:\n",
        "\n",
        "* Firstly, we have to fit our training data (`X_train`) into `CountVectorizer()` and return the matrix.\n",
        "* Secondly, we have to transform our testing data (`X_test`) to return the matrix. \n",
        "\n",
        "Note that `X_train` is our training data for the 'sms_message' column in our dataset and we will be using this to train our model. \n",
        "\n",
        "`X_test` is our testing data for the 'sms_message' column and this is the data we will be using(after transformation to a matrix) to make predictions on. We will then compare those predictions with `y_test` in a later step. \n",
        "\n",
        "For now, we have provided the code that does the matrix transformations for you!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nqDVlYMMWQIc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "'''\n",
        "[Practice Node]\n",
        "\n",
        "The code for this segment is in 2 parts. Firstly, we are learning a vocabulary dictionary for the training data \n",
        "and then transforming the data into a document-term matrix; secondly, for the testing data we are only \n",
        "transforming the data into a document-term matrix.\n",
        "\n",
        "This is similar to the process we followed in Step 2.3\n",
        "\n",
        "We will provide the transformed data to students in the variables 'training_data' and 'testing_data'.\n",
        "'''"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Cn_aOWZ2WQIf",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "'''\n",
        "Solution\n",
        "'''\n",
        "# Instantiate the CountVectorizer method\n",
        "count_vector = CountVectorizer()\n",
        "\n",
        "# Fit the training data and then return the matrix\n",
        "training_data = count_vector.fit_transform(X_train)\n",
        "\n",
        "# Transform testing data and return the matrix. Note we are not fitting the testing data into the CountVectorizer()\n",
        "testing_data = count_vector.transform(X_test)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i2wXDFrlWQIg",
        "colab_type": "text"
      },
      "source": [
        "### Step 4.1: Bayes Theorem implementation from scratch ###\n",
        "\n",
        "Now that we have our dataset in the format that we need, we can move onto the next portion of our mission which is the  algorithm we will use to make our predictions to classify a message as spam or not spam. Remember that at the start of the mission we briefly discussed the Bayes theorem but now we shall go into a little more detail. In layman's terms, the Bayes theorem calculates the probability of an event occurring, based on certain other probabilities that are related to the event in question. It is  composed of a  prior(the probabilities that we are aware of or that is given to us) and the posterior(the probabilities we are looking to compute using the priors). \n",
        "\n",
        "Let us implement the Bayes Theorem from scratch using a simple example. Let's say we are trying to find the odds of an individual having diabetes, given that he or she was tested for it and got a positive result. \n",
        "In the medical field, such probabilies play a very important role as it usually deals with life and death situatuations. \n",
        "\n",
        "We assume the following:\n",
        "\n",
        "`P(D)` is the probability of a person having Diabetes. It's value is `0.01` or in other words, 1% of the general population has diabetes(Disclaimer: these values are assumptions and are not reflective of any medical study).\n",
        "\n",
        "`P(Pos)` is the probability of getting a positive test result.\n",
        "\n",
        "`P(Neg)` is the probability of getting a negative test result.\n",
        "\n",
        "`P(Pos|D)` is the probability of getting a positive result on a test done for detecting diabetes, given that you have diabetes. This has a value `0.9`. In other words the test is correct 90% of the time. This is also called the Sensitivity or True Positive Rate.\n",
        "\n",
        "`P(Neg|~D)` is the probability of getting a negative result on a test done for detecting diabetes, given that you do not have diabetes. This also has a value of `0.9` and is therefore correct, 90% of the time. This is also called the Specificity or True Negative Rate.\n",
        "\n",
        "The Bayes formula is as follows:\n",
        "\n",
        "<img src=\"images/bayes_formula.png\" height=\"242\" width=\"242\">\n",
        "\n",
        "* `P(A)` is the prior probability of A occuring independantly. In our example this is `P(D)`. This value is given to us.\n",
        "\n",
        "* `P(B)` is the prior probability of B occuring independantly. In our example this is `P(Pos)`.\n",
        "\n",
        "* `P(A|B)` is the posterior probability that A occurs given B. In our example this is `P(D|Pos)`. That is, **the probability of an individual having diabetes, given that, that individual got a positive test result. This is the value that we are looking to calculate.**\n",
        "\n",
        "* `P(B|A)` is the likelihood probability of B occuring, given A. In our example this is `P(Pos|D)`. This value is given to us."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xw52szbMWQIh",
        "colab_type": "text"
      },
      "source": [
        "Putting our values into the formula for Bayes theorem we get:\n",
        "\n",
        "`P(D|Pos) = (P(D) * P(Pos|D) / P(Pos)`\n",
        "\n",
        "The probability of getting a positive test result `P(Pos)` can be calulated using the Sensitivity and Specificity as follows:\n",
        "\n",
        "`P(Pos) = [P(D) * Sensitivity] + [P(~D) * (1-Specificity))]`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GKO4sYT1WQIh",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "'''\n",
        "Instructions:\n",
        "Calculate probability of getting a positive test result, P(Pos)\n",
        "'''"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Nm8TTIRnWQIj",
        "colab_type": "code",
        "colab": {},
        "outputId": "f1dedde4-bd1a-40f9-c566-0b86cebe07fd"
      },
      "source": [
        "'''\n",
        "Solution (skeleton code will be provided)\n",
        "'''\n",
        "# P(D)\n",
        "p_diabetes = 0.01\n",
        "\n",
        "# P(~D)\n",
        "p_no_diabetes = 0.99\n",
        "\n",
        "# Sensitivity or P(Pos|D)\n",
        "p_pos_diabetes = 0.9\n",
        "\n",
        "# Specificity or P(Neg/~D)\n",
        "p_neg_no_diabetes = 0.9\n",
        "\n",
        "# P(Pos)\n",
        "p_pos = (p_diabetes * p_pos_diabetes) + (p_no_diabetes * (1 - p_neg_no_diabetes))\n",
        "print('The probability of getting a positive test result P(Pos) is: {}',format(p_pos))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The probability of getting a positive test result P(Pos) is: {} 0.10799999999999998\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HcUYAL1wWQIl",
        "colab_type": "text"
      },
      "source": [
        "** Using all of this information we can calculate our posteriors as follows: **\n",
        "    \n",
        "The probability of an individual having diabetes, given that, that individual got a positive test result:\n",
        "\n",
        "`P(D/Pos) = (P(D) * Sensitivity)) / P(Pos)`\n",
        "\n",
        "The probability of an individual not having diabetes, given that, that individual got a positive test result:\n",
        "\n",
        "`P(~D/Pos) = (P(~D) * (1-Specificity)) / P(Pos)`\n",
        "\n",
        "The sum of our posteriors will always equal `1`. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7NFgprhqWQIl",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "'''\n",
        "Instructions:\n",
        "Compute the probability of an individual having diabetes, given that, that individual got a positive test result.\n",
        "In other words, compute P(D|Pos).\n",
        "\n",
        "The formula is: P(D|Pos) = (P(D) * P(Pos|D) / P(Pos)\n",
        "'''"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TICiYLtnWQIo",
        "colab_type": "code",
        "colab": {},
        "outputId": "ec89a053-f94a-4d27-9e5d-a0e0da0d9ff2"
      },
      "source": [
        "'''\n",
        "Solution\n",
        "'''\n",
        "# P(D|Pos)\n",
        "p_diabetes_pos = (p_diabetes * p_pos_diabetes) / p_pos\n",
        "print('Probability of an individual having diabetes, given that that individual got a positive test result is:\\\n",
        "',format(p_diabetes_pos)) "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Probability of an individual having diabetes, given that that individual got a positive test result is: 0.08333333333333336\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ABqN8DySWQIq",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "'''\n",
        "Instructions:\n",
        "Compute the probability of an individual not having diabetes, given that, that individual got a positive test result.\n",
        "In other words, compute P(~D|Pos).\n",
        "\n",
        "The formula is: P(~D|Pos) = (P(~D) * P(Pos|~D) / P(Pos)\n",
        "\n",
        "Note that P(Pos/~D) can be computed as 1 - P(Neg/~D). \n",
        "\n",
        "Therefore:\n",
        "P(Pos/~D) = p_pos_no_diabetes = 1 - 0.9 = 0.1\n",
        "'''"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UERniiYtWQIs",
        "colab_type": "code",
        "colab": {},
        "outputId": "ba15ccd9-3b4c-4cbb-d63a-df72403eb084"
      },
      "source": [
        "'''\n",
        "Solution\n",
        "'''\n",
        "# P(Pos/~D)\n",
        "p_pos_no_diabetes = 0.1\n",
        "\n",
        "# P(~D|Pos)\n",
        "p_no_diabetes_pos = (p_no_diabetes * p_pos_no_diabetes) / p_pos\n",
        "print 'Probability of an individual not having diabetes, given that that individual got a positive test result is:'\\\n",
        ",p_no_diabetes_pos"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Probability of an individual not having diabetes, given that that individual got a positive test result is: 0.916666666667\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hNU-Gxa8WQIu",
        "colab_type": "text"
      },
      "source": [
        "Congratulations! You have implemented Bayes theorem from scratch. Your analysis shows that even if you get a positive test result, there is only a 8.3% chance that you actually have diabetes and a 91.67% chance that you do not have diabetes. This is of course assuming that only 1% of the entire population has diabetes which of course is only an assumption."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H5YNrYBqWQIu",
        "colab_type": "text"
      },
      "source": [
        "** What does the term 'Naive' in 'Naive Bayes' mean ? ** \n",
        "\n",
        "The term 'Naive' in Naive Bayes comes from the fact that the algorithm considers the features that it is using to make the predictions to be independent of each other, which may not always be the case. So in our Diabetes example, we are considering only one feature, that is the test result. Say we added another feature, 'exercise'. Let's say this feature has a binary value of `0` and `1`, where the former signifies that the individual exercises less than or equal to 2 days a week and the latter signifies that the individual exercises greater than or equal to 3 days a week. If we had to use both of these features, namely the test result and the value of the 'exercise' feature, to compute our final probabilities, Bayes' theorem would fail. Naive Bayes' is an extension of Bayes' theorem that assumes that all the features are independent of each other. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pFXo9QVyWQIv",
        "colab_type": "text"
      },
      "source": [
        "### Step 4.2: Naive Bayes implementation from scratch ###\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H4-Qe6_oWQIv",
        "colab_type": "text"
      },
      "source": [
        "Now that you have understood the ins and outs of Bayes Theorem, we will extend it to consider cases where we have more than feature. \n",
        "\n",
        "Let's say that we have two political parties' candidates, 'Jill Stein' of the Green Party and 'Gary Johnson' of the Libertarian Party and we have the probabilities of each of these candidates saying the words 'freedom', 'immigration' and 'environment' when they give a speech:\n",
        "\n",
        "* Probability that Jill Stein says 'freedom': 0.1 ---------> `P(F|J)`\n",
        "* Probability that Jill Stein says 'immigration': 0.1 -----> `P(I|J)`\n",
        "* Probability that Jill Stein says 'environment': 0.8 -----> `P(E|J)`\n",
        "\n",
        "\n",
        "* Probability that Gary Johnson says 'freedom': 0.7 -------> `P(F|G)`\n",
        "* Probability that Gary Johnson says 'immigration': 0.2 ---> `P(I|G)`\n",
        "* Probability that Gary Johnson says 'environment': 0.1 ---> `P(E|G)`\n",
        "\n",
        "\n",
        "And let us also assume that the probablility of Jill Stein giving a speech, `P(J)` is `0.5` and the same for Gary Johnson, `P(G) = 0.5`. \n",
        "\n",
        "\n",
        "Given this, what if we had to find the probabilities of Jill Stein saying the words 'freedom' and 'immigration'? This is where the Naive Bayes'theorem comes into play as we are considering two features, 'freedom' and 'immigration'.\n",
        "\n",
        "Now we are at a place where we can define the formula for the Naive Bayes' theorem:\n",
        "\n",
        "<img src=\"images/naivebayes.png\" height=\"342\" width=\"342\">\n",
        "\n",
        "Here, `y` is the class variable or in our case the name of the candidate and `x1` through `xn` are the feature vectors or in our case the individual words. The theorem makes the assumption that each of the feature vectors or words (`xi`) are independent of each other."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oWbHl6jZWQIv",
        "colab_type": "text"
      },
      "source": [
        "To break this down, we have to compute the following posterior probabilities:\n",
        "\n",
        "* `P(J|F,I)`: Probability of Jill Stein saying the words Freedom and Immigration. \n",
        "\n",
        "    Using the formula and our knowledge of Bayes' theorem, we can compute this as follows: `P(J|F,I)` = `(P(J) * P(F|J) * P(I|J)) / P(F,I)`. Here `P(F,I)` is the probability of the words 'freedom' and 'immigration' being said in a speech.\n",
        "    \n",
        "\n",
        "* `P(G|F,I)`: Probability of Gary Johnson saying the words Freedom and Immigration.  \n",
        "    \n",
        "    Using the formula, we can compute this as follows: `P(G|F,I)` = `(P(G) * P(F|G) * P(I|G)) / P(F,I)`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bO_ky8j0WQIw",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "'''\n",
        "Instructions: Compute the probability of the words 'freedom' and 'immigration' being said in a speech, or\n",
        "P(F,I).\n",
        "\n",
        "The first step is multiplying the probabilities of Jill Stein giving a speech with her individual \n",
        "probabilities of saying the words 'freedom' and 'immigration'. Store this in a variable called p_j_text\n",
        "\n",
        "The second step is multiplying the probabilities of Gary Johnson giving a speech with his individual \n",
        "probabilities of saying the words 'freedom' and 'immigration'. Store this in a variable called p_g_text\n",
        "\n",
        "The third step is to add both of these probabilities and you will get P(F,I).\n",
        "'''"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Osn71d19WQIy",
        "colab_type": "code",
        "colab": {},
        "outputId": "323ee2f6-06f5-4332-90b1-cfde7e8e1042"
      },
      "source": [
        "'''\n",
        "Solution: Step 1\n",
        "'''\n",
        "# P(J)\n",
        "p_j = 0.5\n",
        "\n",
        "# P(F/J)\n",
        "p_j_f = 0.1\n",
        "\n",
        "# P(I/J)\n",
        "p_j_i = 0.1\n",
        "\n",
        "p_j_text = p_j * p_j_f * p_j_i\n",
        "print(p_j_text)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.005000000000000001\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uPSe5UFGWQI0",
        "colab_type": "code",
        "colab": {},
        "outputId": "4a864360-ee36-41dc-ef6c-d32256f50eb3"
      },
      "source": [
        "'''\n",
        "Solution: Step 2\n",
        "'''\n",
        "# P(G)\n",
        "p_g = 0.5\n",
        "\n",
        "# P(F/G)\n",
        "p_g_f = 0.7\n",
        "\n",
        "# P(I/G)\n",
        "p_g_i = 0.2\n",
        "\n",
        "p_g_text = p_g * p_g_f * p_g_i\n",
        "print(p_g_text)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.06999999999999999\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QWowHK_8WQI2",
        "colab_type": "code",
        "colab": {},
        "outputId": "f71e8767-ecd7-4b66-a778-dc90ed1db877"
      },
      "source": [
        "'''\n",
        "Solution: Step 3: Compute P(F,I) and store in p_f_i\n",
        "'''\n",
        "p_f_i = p_j_text + p_g_text\n",
        "print('Probability of words freedom and immigration being said are: ', format(p_f_i))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Probability of words freedom and immigration being said are:  0.075\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Vq1PU5nCWQI4",
        "colab_type": "text"
      },
      "source": [
        "Now we can compute the probability of `P(J|F,I)`, that is the probability of Jill Stein saying the words Freedom and Immigration and `P(G|F,I)`, that is the probability of Gary Johnson saying the words Freedom and Immigration."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sZdR08I5WQI4",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "'''\n",
        "Instructions:\n",
        "Compute P(J|F,I) using the formula P(J|F,I) = (P(J) * P(F|J) * P(I|J)) / P(F,I) and store it in a variable p_j_fi\n",
        "'''"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3LBMfWPBWQI6",
        "colab_type": "code",
        "colab": {},
        "outputId": "f4e281a8-e857-482a-b16e-ee74de923521"
      },
      "source": [
        "'''\n",
        "Solution\n",
        "'''\n",
        "p_j_fi = p_j_text / p_f_i\n",
        "print('The probability of Jill Stein saying the words Freedom and Immigration: ', format(p_j_fi))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The probability of Jill Stein saying the words Freedom and Immigration:  0.06666666666666668\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gF9J93ZuWQI8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "'''\n",
        "Instructions:\n",
        "Compute P(G|F,I) using the formula P(G|F,I) = (P(G) * P(F|G) * P(I|G)) / P(F,I) and store it in a variable p_g_fi\n",
        "'''"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8U62UJwMWQI9",
        "colab_type": "code",
        "colab": {},
        "outputId": "0b6faa9c-19c6-4e66-a373-63b4593eaf0a"
      },
      "source": [
        "'''\n",
        "Solution\n",
        "'''\n",
        "p_g_fi = p_g_text / p_f_i\n",
        "print('The probability of Gary Johnson saying the words Freedom and Immigration: ', format(p_g_fi))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The probability of Gary Johnson saying the words Freedom and Immigration:  0.9333333333333332\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5KC_OY0bWQJA",
        "colab_type": "text"
      },
      "source": [
        "And as we can see, just like in the Bayes' theorem case, the sum of our posteriors is equal to 1. Congratulations! You have implemented the Naive Bayes' theorem from scratch. Our analysis shows that there is only a 6.6% chance that Jill Stein of the Green Party uses the words 'freedom' and 'immigration' in her speech as compard the the 93.3% chance for Gary Johnson of the Libertarian party."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qCY3kJNaWQJA",
        "colab_type": "text"
      },
      "source": [
        "Another more generic example of Naive Bayes' in action is as when we search for the term 'Sacramento Kings' in a search engine. In order for us to get the results pertaining to the Scramento Kings NBA basketball team, the search engine needs to be able to associate the two words together and not treat them individually, in which case we would get results of images tagged with 'Sacramento' like pictures of city landscapes and images of 'Kings' which could be pictures of crowns or kings from history when what we are looking to get are images of the basketball team. This is a classic case of the search engine treating the words as independant entities and hence being 'naive' in its approach. \n",
        "\n",
        "\n",
        "Applying this to our problem of classifying messages as spam, the Naive Bayes algorithm *looks at each word individually and not as associated entities* with any kind of link between them. In the case of spam detectors, this usually works as there are certain red flag words which can almost guarantee its classification as spam, for example emails with words like 'viagra' are usually classified as spam."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gb2Dh_fdWQJA",
        "colab_type": "text"
      },
      "source": [
        "### Step 5: Naive Bayes implementation using scikit-learn ###\n",
        "\n",
        "Thankfully, sklearn has several Naive Bayes implementations that we can use and so we do not have to do the math from scratch. We will be using sklearns `sklearn.naive_bayes` method to make predictions on our dataset. \n",
        "\n",
        "Specifically, we will be using the multinomial Naive Bayes implementation. This particular classifier is suitable for classification with discrete features (such as in our case, word counts for text classification). It takes in integer word counts as its input. On the other hand Gaussian Naive Bayes is better suited for continuous data as it assumes that the input data has a Gaussian(normal) distribution."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mXpMq0PHWQJB",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "'''\n",
        "Instructions:\n",
        "\n",
        "We have loaded the training data into the variable 'training_data' and the testing data into the \n",
        "variable 'testing_data'.\n",
        "\n",
        "Import the MultinomialNB classifier and fit the training data into the classifier using fit(). Name your classifier\n",
        "'naive_bayes'. You will be training the classifier using 'training_data' and y_train' from our split earlier. \n",
        "'''"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "31UdGYTYWQJD",
        "colab_type": "code",
        "colab": {},
        "outputId": "460537ad-969f-41bb-bf6a-63a057d04584"
      },
      "source": [
        "'''\n",
        "Solution\n",
        "'''\n",
        "from sklearn.naive_bayes import MultinomialNB\n",
        "naive_bayes = MultinomialNB()\n",
        "naive_bayes.fit(training_data, y_train)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "MultinomialNB(alpha=1.0, class_prior=None, fit_prior=True)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 53
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HgY71RfrWQJF",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "'''\n",
        "Instructions:\n",
        "Now that our algorithm has been trained using the training data set we can now make some predictions on the test data\n",
        "stored in 'testing_data' using predict(). Save your predictions into the 'predictions' variable.\n",
        "'''"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "szeH57m5WQJI",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "'''\n",
        "Solution\n",
        "'''\n",
        "predictions = naive_bayes.predict(testing_data)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iJeNz-tcWQJL",
        "colab_type": "text"
      },
      "source": [
        "Now that predictions have been made on our test set, we need to check the accuracy of our predictions."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JiHr_26LWQJM",
        "colab_type": "text"
      },
      "source": [
        "### Step 6: Evaluating our model ###\n",
        "\n",
        "Now that we have made predictions on our test set, our next goal is to evaluate how well our model is doing. There are various mechanisms for doing so, but first let's do quick recap of them.\n",
        "\n",
        "** Accuracy ** measures how often the classifier makes the correct prediction. It’s the ratio of the number of correct predictions to the total number of predictions (the number of test data points).\n",
        "\n",
        "** Precision ** tells us what proportion of messages we classified as spam, actually were spam.\n",
        "It is a ratio of true positives(words classified as spam, and which are actually spam) to all positives(all words classified as spam, irrespective of whether that was the correct classification), in other words it is the ratio of\n",
        "\n",
        "`[True Positives/(True Positives + False Positives)]`\n",
        "\n",
        "** Recall(sensitivity)** tells us what proportion of messages that actually were spam were classified by us as spam.\n",
        "It is a ratio of true positives(words classified as spam, and which are actually spam) to all the words that were actually spam, in other words it is the ratio of\n",
        "\n",
        "`[True Positives/(True Positives + False Negatives)]`\n",
        "\n",
        "For classification problems that are skewed in their classification distributions like in our case, for example if we had a 100 text messages and only 2 were spam and the rest 98 weren't, accuracy by itself is not a very good metric. We could classify 90 messages as not spam(including the 2 that were spam but we classify them as not spam, hence they would be false negatives) and 10 as spam(all 10 false positives) and still get a reasonably good accuracy score. For such cases, precision and recall come in very handy. These two metrics can be combined to get the F1 score, which is weighted average of the precision and recall scores. This score can range from 0 to 1, with 1 being the best possible F1 score."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vhVrgoWtWQJM",
        "colab_type": "text"
      },
      "source": [
        "We will be using all 4 metrics to make sure our model does well. For all 4 metrics whose values can range from 0 to 1, having a score as close to 1 as possible is a good indicator of how well our model is doing."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gkuhuE5YWQJN",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "'''\n",
        "Instructions:\n",
        "Compute the accuracy, precision, recall and F1 scores of your model using your test data 'y_test' and the predictions\n",
        "you made earlier stored in the 'predictions' variable.\n",
        "'''"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uqCa344VWQJQ",
        "colab_type": "code",
        "colab": {},
        "outputId": "04c13982-9548-4539-ee17-b5cbee04d2bc"
      },
      "source": [
        "'''\n",
        "Solution\n",
        "'''\n",
        "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score\n",
        "print('Accuracy score: ', format(accuracy_score(y_test, predictions)))\n",
        "print('Precision score: ', format(precision_score(y_test, predictions)))\n",
        "print('Recall score: ', format(recall_score(y_test, predictions)))\n",
        "print('F1 score: ', format(f1_score(y_test, predictions)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Accuracy score:  0.9885139985642498\n",
            "Precision score:  0.9720670391061452\n",
            "Recall score:  0.9405405405405406\n",
            "F1 score:  0.9560439560439562\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": true,
        "id": "eXtSQDMXWQJS",
        "colab_type": "text"
      },
      "source": [
        "### Step 7: Conclusion ###\n",
        "\n",
        "One of the major advantages that Naive Bayes has over other classification algorithms is its ability to handle an extremely large number of features. In our case, each word is treated as a feature and there are thousands of different words. Also, it performs well even with the presence of irrelevant features and is relatively unaffected by them. The other major advantage it has is its relative simplicity. Naive Bayes' works well right out of the box and tuning it's parameters is rarely ever necessary, except usually in cases where the distribution of the data is known. \n",
        "It rarely ever overfits the data. Another important advantage is that its model training and prediction times are very fast for the amount of data it can handle. All in all, Naive Bayes' really is a gem of an algorithm!\n",
        "\n",
        "Congratulations! You have succesfully designed a model that can efficiently predict if an SMS message is spam or not!\n",
        "\n",
        "Thank you for learning with us!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ttzNhGz6WQJT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}