sms_spam_filter.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After watching the film *Arrival*, I developed a deep appreciation for the field of linguistics (also my favorite movie of 2016). Human language is the most unstructured type of data, and yet we effortlessly parse and interpret it, and even generate our own. On the other hand, understanding everyday language is a significant challenge for machines; this is the focus of **natural language processing** (NLP)&mdash;the crossroads between linguistics and AI. In this post, we'll make use of some NLP concepts and combine them with machine learning to build a spam filter for SMS text messages.\n",
    "<!-- TEASER_END -->\n",
    "\n",
    "In the 1950s, Alan Turing conjectured if a machine can fool a human into believing that he/she is speaking with another human, the machine exhibits intelligence&mdash;the iconic Turing test. Recently, a machine arguably passed the Turing test [for the first time](http://www.reading.ac.uk/news-and-events/releases/PR583836.aspx); the milestone was largely attributed to advances in NLP. If you've ever wondered how Siri or Google recognizes your voice, makes sense of a semantically nebulous question, such as \"How did the Celtics do?\", and returns an accurate response, that's also NLP in action! The war on spam is another.\n",
    "\n",
    "Before Gmail implemented its incredible spam filter, I remember crafting an elaborate set of if/then rules for words typically found in spam. Not surprisingly, it was tedious and prone to mistakes. Nowadays, no one hand codes a spam filter&mdash;we train machines to do the job! But email spam is different from SMS message spam; we tend to speak more casually on our phones, using more slang, incomplete sentences, or even concocting words and phrases. Let's see what machine learning can do for SMS message spam.\n",
    "\n",
    "# Table of contents\n",
    "1. [Inspecting the dataset](#cell1)\n",
    "2. [Text preprocessing](#cell2)\n",
    "3. [Feature engineering](#cell3)\n",
    "4. [Training and evaluating a model](#cell4)\n",
    "5. [What terms are the top predictors of spam?](#cell5)\n",
    "6. [How to improve the model](#cell6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Load the required packages\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import re\n",
    "import nltk\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn import metrics, svm\n",
    "from sklearn.model_selection import (\n",
    "    train_test_split, learning_curve, StratifiedShuffleSplit, GridSearchCV,\n",
    "    cross_val_score)\n",
    "\n",
    "# Improve the readability of figures\n",
    "sns.set_context('notebook', font_scale=1.4)\n",
    "%config InlineBackend.figure_format = 'retina'\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"cell1\"></a>\n",
    "# 1. Inspecting the dataset\n",
    "\n",
    "While browsing the [UCI Machine Learning repository](https://archive.ics.uci.edu/ml/datasets/sms+spam+collection), I discovered a dataset chock-full of anonymous SMS text messages. Let's begin by loading it and taking a look around."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style>\n",
       "    .dataframe thead tr:only-child th {\n",
       "        text-align: right;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</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": [
       "      0                                                  1\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..."
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load the dataset\n",
    "df = pd.read_table('data/SMSSpamCollection.txt', header=None)\n",
    "\n",
    "# Display the first five rows\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 5572 entries, 0 to 5571\n",
      "Data columns (total 2 columns):\n",
      "0    5572 non-null object\n",
      "1    5572 non-null object\n",
      "dtypes: object(2)\n",
      "memory usage: 87.1+ KB\n"
     ]
    }
   ],
   "source": [
    "df.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have a collection of text data known as a **corpus**. Specifically, there are 5,572 SMS messages written in English, serving as training examples. The first column is the target variable containing the class labels, which tells us if the message is spam or ham (aka not spam). The second column is the SMS message itself, stored as a string. \n",
    "\n",
    "Since the target variable contains discrete values, this is a classification task. Let's start by placing the target variable in its own table and checking out how the two classes are distributed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ham     4825\n",
       "spam     747\n",
       "Name: 0, dtype: int64"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Store the target variable\n",
    "y = df[0]\n",
    "\n",
    "# Display the class distribution\n",
    "y.value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It looks like there are far fewer training examples for spam than ham&mdash;we'll take this imbalance into account in the analysis. In addition, we need to encode the class labels in the target variable as numbers to ensure compatibility with some models in Scikit-learn. Because we have binary classes, let's use `LabelEncoder` and set `'spam'` = `1` and `'ham'` = `0`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Encode the class labels as numbers\n",
    "le = LabelEncoder()\n",
    "y_enc = le.fit_transform(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, let's place the SMS message data into its own table."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Store the SMS message data\n",
    "raw_text = df[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We're sitting on a mountain of text data but it might as well be gibberish since a machine only understands numbers. How can we convert this corpus into useful numerical features so we can train a classifier? This is where NLP comes in.\n",
    "\n",
    "<a id=\"cell2\"></a>\n",
    "# 2. Text preprocessing\n",
    "\n",
    "There are many feature engineering strategies for transforming text data into features. Some involve assigning each unique word-like term to a feature and counting the number of occurrences per training example. However, if we were to perform this strategy right now, we'd end up with an absurd number of features, a result of the myriad possible terms. The classifier would take too long to train and likely overfit. As a result, **each NLP problem requires a tailored approach to determine which terms are relevant and meaningful**. \n",
    "\n",
    "For the remainder of this section, I'll walk through my preprocessing strategy, which relies heavily on [regular expressions](http://regexr.com/).\n",
    "\n",
    "## Normalization\n",
    "\n",
    "Let's begin by taking a step back and examining the terms of a hypothetical SMS message."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "example = \"\"\"  ***** CONGRATlations **** You won 2 tIckETs to Hamilton in \n",
    "NYC http://www.hamiltonbroadway.com/J?NaIOl/event   wORtH over $500.00...CALL \n",
    "555-477-8914 or send message to: hamilton@freetix.com to get ticket !! !  \"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I'd definitely deem this as spam. But clearly there's a lot going on here: phone numbers, emails, website URLs, money amounts, and gratuitous whitespace and punctuation. Some terms are randomly capitalized, others are in all-caps. Since these terms might show up in any one of the training examples in countless forms, we need a way to ensure each training example is on equal footing via a preprocessing step called **normalization**. \n",
    "\n",
    "Instead of removing the following terms, for each training example, let's replace them with a specific string.\n",
    "* Replace email addresses with `'emailaddr'`\n",
    "* Replace URLs with `'httpaddr'`\n",
    "* Replace money symbols with `'moneysymb'`\n",
    "* Replace phone numbers with `'phonenumbr'`\n",
    "* Replace numbers with `'numbr'`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Replace email addresses with 'emailaddr'\n",
    "processed = raw_text.str.replace(r'\\b[\\w\\-.]+?@\\w+?\\.\\w{2,4}\\b',\n",
    "                                 'emailaddr')\n",
    "\n",
    "# Replace URLs with 'httpaddr'\n",
    "processed = processed.str.replace(r'(http[s]?\\S+)|(\\w+\\.[A-Za-z]{2,4}\\S*)',\n",
    "                                  'httpaddr')\n",
    "\n",
    "# Replace money symbols with 'moneysymb'\n",
    "processed = processed.str.replace(r'£|\\$', 'moneysymb')\n",
    "    \n",
    "# Replace phone numbers with 'phonenumbr'\n",
    "processed = processed.str.replace(\n",
    "    r'\\b(\\+\\d{1,2}\\s)?\\d?[\\-(.]?\\d{3}\\)?[\\s.-]?\\d{3}[\\s.-]?\\d{4}\\b',\n",
    "    'phonenumbr')\n",
    "    \n",
    "# Replace numbers with 'numbr'\n",
    "processed = processed.str.replace(r'\\d+(\\.\\d+)?', 'numbr')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we'll remove all punctuation since \"today\" and \"today?\" refer to the same word. In addition, let's collapse all whitespace (spaces, line breaks, tabs) into a single space. Furthermore, we'll eliminate any leading or trailing whitespace."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Remove punctuation\n",
    "processed = processed.str.replace(r'[^\\w\\d\\s]', ' ')\n",
    "\n",
    "# Replace whitespace between terms with a single space\n",
    "processed = processed.str.replace(r'\\s+', ' ')\n",
    "\n",
    "# Remove leading and trailing whitespace\n",
    "processed = processed.str.replace(r'^\\s+|\\s+?$', '')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll also need to treat the words \"there\", \"There\" and \"ThERe\" as the same word. Therefore, let's lowercase the entire corpus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Lowercase the corpus\n",
    "processed = processed.str.lower()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Removing stop words\n",
    "\n",
    "Some words in the English language, while necessary, don't contribute much to the meaning of a phrase. These words, such as \"when\", \"had\", \"those\" or \"before\", are called **stop words** and should be filtered out. The Natural Language Toolkit (NLTK), a popular Python library for NLP, provides common stop words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Access stop words\n",
    "stop_words = nltk.corpus.stopwords.words('english')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This list of stop words is literally stored in a Python `list`. If instead we convert it to a Python `set`, iterating over the stop words will go *much* faster, and shave time off this preprocessing step."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Remove all stop words\n",
    "processed = processed.apply(lambda x: ' '.join(\n",
    "    term for term in x.split() if term not in set(stop_words))\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Stemming\n",
    "\n",
    "It's likely the corpus contains words with various suffixes such as \"distribute\", \"distributing\", \"distributor\" or \"distribution\". We can replace these four words with just \"distribut\" via a preprocessing step called **stemming**. There are numerous stemming strategies, some more aggressive than others. Instead of painstakingly building a stemmer from scratch, let's use one from NLTK called the Porter stemmer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Remove word stems using a Porter stemmer\n",
    "porter = nltk.PorterStemmer()\n",
    "processed = processed.apply(lambda x: ' '.join(\n",
    "    porter.stem(term) for term in x.split())\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because we have so many preprocessing steps, let's combine them all into a handy function that takes in a string and cleans it up."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def preprocess_text(messy_string):\n",
    "    assert(type(messy_string) == str)\n",
    "    cleaned = re.sub(r'\\b[\\w\\-.]+?@\\w+?\\.\\w{2,4}\\b', 'emailaddr', messy_string)\n",
    "    cleaned = re.sub(r'(http[s]?\\S+)|(\\w+\\.[A-Za-z]{2,4}\\S*)', 'httpaddr',\n",
    "                     cleaned)\n",
    "    cleaned = re.sub(r'£|\\$', 'moneysymb', cleaned)\n",
    "    cleaned = re.sub(\n",
    "        r'\\b(\\+\\d{1,2}\\s)?\\d?[\\-(.]?\\d{3}\\)?[\\s.-]?\\d{3}[\\s.-]?\\d{4}\\b',\n",
    "        'phonenumbr', cleaned)\n",
    "    cleaned = re.sub(r'\\d+(\\.\\d+)?', 'numbr', cleaned)\n",
    "    cleaned = re.sub(r'[^\\w\\d\\s]', ' ', cleaned)\n",
    "    cleaned = re.sub(r'\\s+', ' ', cleaned)\n",
    "    cleaned = re.sub(r'^\\s+|\\s+?$', '', cleaned.lower())\n",
    "    return ' '.join(\n",
    "        porter.stem(term) \n",
    "        for term in cleaned.split()\n",
    "        if term not in set(stop_words)\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a sanity check, let's confirm this function yields the same results as the previous series of steps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(processed == raw_text.apply(preprocess_text)).all()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Additionally, let's test `preprocess_text()` on the hypothethical SMS message from earlier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'congratl numbr ticket hamilton nyc httpaddr worth moneysymbnumbr call phonenumbr send messag emailaddr get ticket'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "preprocess_text(example)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What a change! It looks like the preprocessing strategy is working. A quick technical note before we move on: since this was the first time I encountered regular expressions, I learned the hard way that mindful usage of the lazy quantifier `?` is crucial&mdash;incorporating it reduced the total preprocessing time from 1 hour to *2 seconds!*\n",
    "\n",
    "<a id=\"cell3\"></a>\n",
    "# 3. Feature engineering\n",
    "\n",
    "Now that we've enriched the corpus for meaningful terms, we're ready to construct features. Let's begin by breaking apart the corpus into a vocabulary of unique terms&mdash;a process called **tokenization**. However, there are several ways to approach this step. \n",
    "\n",
    "## Tokenization\n",
    "\n",
    "We can tokenize individual terms and generate what's called a **bag of words model**. You may notice this model has a glaring pitfall: it fails to capture the innate structure of human language. Under this model, the following sentences have the same feature vector although they convey dramatically different meanings.\n",
    "\n",
    "* Does steak taste delicious?\n",
    "* Steak does taste delicious.\n",
    "\n",
    "Alternatively, we can tokenize every sequence of $n$ terms called $n$-grams. For example, tokenizing adjacent pairs of words yields bigrams. The **$n$-gram model** preserves word order and can potentially capture more information than the bag of words model. \n",
    "\n",
    "To get the best of both worlds, let's tokenize unigrams *and* bigrams. As an example, unigrams and bigrams for \"The quick brown fox\" are \"The\", \"quick\", \"brown\", \"fox\", \"The quick\", \"quick brown\" and \"brown fox\".\n",
    "\n",
    "## Implementing the tf-idf statistic\n",
    "\n",
    "Having selected a tokenization strategy, the next step is assign each $n$-gram to a feature and then compute the $n$-gram's frequency using some statistic. Again, we have options.\n",
    "\n",
    "One statistic called **term frequency (tf)** tallies the occurrences of each $n$-gram for every training example. However, some $n$-grams will undoubtedly show up often in any given SMS message, while others rarely appear in the overall corpus but show up frequently in certain *subsets* of messages such as spam. Therefore, to emphasize the latter, more interesting set of $n$-grams, we'll downweight the term frequency with **inverse document frequency (idf)**, which is calculated by logarithmically scaling the inverse of the fraction of training examples that contain a given term. Combining these two statistics yields the tf-idf statistic:\n",
    "\n",
    "$$\\textrm{tf-idf}(t, i) = \\textrm{tf}(t, i) \\times \\textrm{idf}(t) = \\textrm{tf}(t, i) \\times \\log\\bigg(\\frac{M}{m_t}\\bigg)$$\n",
    "\n",
    "where $\\textrm{tf}(t,i)$ is the term frequency for term $t$ in the $i$th training example, $M$ is the total number of training examples, and $m_t$ is the number of training examples that contain the term $t$. \n",
    "\n",
    "Scikit-learn has an off-the-shelf tool called `TfidfVectorizer` that performs $n$-gram tokenization and also computes the tf-idf statistic. Two technical details regarding `TfidfVectorizer`: a) the tf-idf statistic is computed [slightly differently](http://scikit-learn.org/stable/modules/feature_extraction.html#tfidf-term-weighting) to avoid division by zero, and b) the computed tf-idf values for each training example are subsequently [normalized](http://scikit-learn.org/stable/modules/feature_extraction.html#tfidf-term-weighting).\n",
    "\n",
    "**Finally, we're equipped to transform a corpus of text data into a matrix of numbers with one row per training example and one column per $n$-gram.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Construct a design matrix using an n-gram model and a tf-idf statistics\n",
    "vectorizer = TfidfVectorizer(ngram_range=(1, 2))\n",
    "X_ngrams = vectorizer.fit_transform(processed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take a look at the dimensions of the `X_ngrams` matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5572, 36348)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_ngrams.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Holy cow, that's one massive matrix! It looks like the tokenization process extracted 36,348 unigrams and bigrams from the corpus; each one defines a feature. Since each training example only makes use of a tiny fraction of the complete $n$-gram vocabulary, `X_ngrams` mostly consists of zeros and is called a **sparse matrix**. To perform linear algebra computations rapidly on such a large sparse matrix, it'd be more efficient to store only the non-zero values while maintaining the structure. Fortunately, `TfidfVectorizer` utilizes the SciPy library to do *exactly* this!\n",
    "\n",
    "<a id=\"cell4\"></a>\n",
    "# 4. Training and evaluating a model\n",
    "\n",
    "That was a lot of prep work and we haven't even done any machine learning yet, but all of it crucial for building a robust classifier. **Not only is a model only as good as the data it's trained on, but meticulous feature engineering can beat having a fancy model.** We'll be a training a state of the art classifier called **support vector machines (SVM)**. In a nutshell, this model attempts to find the hyperplane that best separates the two classes. \n",
    "\n",
    "In particular, I've elected to use SVM with a *linear kernel* because text data contains a large number of features (we have over 30,000!); using a nonlinear kernel would be [computationally expensive](http://www.csie.ntu.edu.tw/~cjlin/papers/guide/guide.pdf). In addition, text data is typically [linearly separable to begin with](https://link.springer.com/chapter/10.1007/BFb0026683). Finally, we'll use `svm.LinearSVC()` instead of `svm.SVC(kernel='linear')` because the former relies on a library whose [algorithmic complexity](https://stackoverflow.com/questions/11508788/whats-the-difference-between-libsvm-and-liblinear) is $O(n)$ instead of $O(n^2)$ or $O(n^3)$, meaning much faster. \n",
    "\n",
    "## Preliminary analysis\n",
    "\n",
    "For a rudimentary understanding of how well SVM performs on the dataset, let's start with the hold-out method: an 80/20 training and test set split. **Remember to never evaluate a model on the data used to train it!** In addition, since the classes are imbalanced, we'll incorporate stratification and use the $F_1$ score as the performance metric."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9285714285714286"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Prepare the training and test sets using an 80/20 split\n",
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "    X_ngrams,\n",
    "    y_enc,\n",
    "    test_size=0.2,\n",
    "    random_state=42,\n",
    "    stratify=y_enc\n",
    ")\n",
    "\n",
    "# Train SVM with a linear kernel on the training set\n",
    "clf = svm.LinearSVC(loss='hinge')\n",
    "clf.fit(X_train, y_train)\n",
    "\n",
    "# Evaluate the classifier on the test set\n",
    "y_pred = clf.predict(X_test)\n",
    "\n",
    "# Compute the F1 score\n",
    "metrics.f1_score(y_test, y_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Not a bad start, but we really need to run cross-validation to gauge whether this performance is consistent. While we're here, let's use a **confusion matrix** to take a peek at what types of mistakes the classifier is making. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style>\n",
       "    .dataframe thead tr:only-child th {\n",
       "        text-align: right;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th colspan=\"2\" halign=\"left\">predicted</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th>spam</th>\n",
       "      <th>ham</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">actual</th>\n",
       "      <th>spam</th>\n",
       "      <td>965</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ham</th>\n",
       "      <td>19</td>\n",
       "      <td>130</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            predicted     \n",
       "                 spam  ham\n",
       "actual spam       965    1\n",
       "       ham         19  130"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Display a confusion matrix\n",
    "pd.DataFrame(\n",
    "    metrics.confusion_matrix(y_test, y_pred),\n",
    "    index=[['actual', 'actual'], ['spam', 'ham']],\n",
    "    columns=[['predicted', 'predicted'], ['spam', 'ham']]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It looks when the classifier does make a mistake, it's typically a false positive:  flagging an SMS message as spam when it's actually not. Not exactly ideal but then again, this is just a single training/test set split.\n",
    "\n",
    "## Diagnosing the model with learning curves\n",
    "\n",
    "Because we have so many features, it's prudent to determine whether the classifier suffers from high variance and is overfitting. We can assess the situation by plotting **learning curves**. Here's the procedure:\n",
    "\n",
    "1. Split the entire dataset $k$ times into a training and validation set\n",
    "2. For each split, train the model on *subsets* of the training set, each with fewer training examples\n",
    "3. Evaluate the model on the validation set and each subset of the training set\n",
    "4. Average the model performance across the $k$ splits for both training and validation sets\n",
    "\n",
    "Specifically, we'll use 10-fold cross-validation (80/20 split) *without regularization*. For each fold, we'll train the classifier on 10 different dataset sizes, starting with 500 training examples. Fortunately, Scikit-learn has a convenient tool that computes learning curves in one go."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Select 10 different sizes of the entire dataset\n",
    "sample_space = np.linspace(500, len(raw_text) * 0.8, 10, dtype='int')\n",
    "\n",
    "# Compute learning curves without regularization for the SVM model\n",
    "train_sizes, train_scores, valid_scores = learning_curve(\n",
    "    estimator=svm.LinearSVC(loss='hinge', C=1e10),\n",
    "    X=X_ngrams,\n",
    "    y=y_enc,\n",
    "    train_sizes=sample_space,\n",
    "    cv=StratifiedShuffleSplit(n_splits=10, test_size=0.2, random_state=40),\n",
    "    scoring='f1',\n",
    "    n_jobs=-1\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I love the Seaborn library for visualization but like other high-level plotting libraries, it requires data to be in [\"tidy\" format](https://www.jstatsoft.org/article/view/v059i10) where each variable forms a column and each observation forms a row. Trust me, tidy data make data analysis and plotting *so much* easier. Let's define a function that combines `train_scores` and `valid_scores` into a single tidy table."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def make_tidy(sample_space, train_scores, valid_scores):\n",
    "    # Join train_scores and valid_scores, and label with sample_space\n",
    "    messy_format = pd.DataFrame(\n",
    "        np.stack((sample_space, train_scores.mean(axis=1),\n",
    "                  valid_scores.mean(axis=1)), axis=1),\n",
    "        columns=['# of training examples', 'Training set', 'Validation set']\n",
    "    )\n",
    "    \n",
    "    # Re-structure into into tidy format\n",
    "    return pd.melt(\n",
    "        messy_format,\n",
    "        id_vars='# of training examples',\n",
    "        value_vars=['Training set', 'Validation set'],\n",
    "        var_name='Scores',\n",
    "        value_name='F1 score'\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We're now ready to use Seaborn to plot learning curves for the classifier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6gAAALACAYAAACekV+rAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSuH/AaeGSSn9uI3eAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1ceff5fb470>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 352,
       "width": 468
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Initialize a FacetGrid object using the table of scores and facet on\n",
    "# the type of score\n",
    "g = sns.FacetGrid(\n",
    "    make_tidy(sample_space, train_scores, valid_scores), hue='Scores', size=5\n",
    ")\n",
    "\n",
    "# Plot the learning curves and add a legend\n",
    "g.map(plt.scatter, '# of training examples', 'F1 score')\n",
    "g.map(plt.plot, '# of training examples', 'F1 score').add_legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I love learning curves&mdash;they're teeming with information! Notice the performance on the training set is near perfect regardless of dataset size, which makes sense because we're evaluating the classifier on the same data used to train it. At first, it looks like the classifier is suffering from high variance and is overfitting since the validation scores never reach the same level. However, taking a closer look at the scale of the $y$-axis makes me believe this issue isn't that pronounced. \n",
    "\n",
    "Nevertheless, since the validation scores improve with more training examples, an obvious next step is to acquire more data points. In addition, we could try a smaller set of features by only using bigrams, not unigrams. Finally, it's worth tuning the regularization hyperparameter.\n",
    "\n",
    "## Using nested cross-validation to minimize information leakage\n",
    "\n",
    "To optimize hyperparameters, we can use Scikit-learn's `GridSearchCV` tool, which trains a series of candidate models using every combination of hyperparameters, evaluates each model using $k$-fold cross-validation, and then reports the \"winning\" model and its hyperparameter combination that yielded the best performance. However, we can't report this value as an unbiased estimate of the model's performance because we repeatedly reused the same data for cross-validation&mdash;we potentially \"leaked\" information across the candidate models!\n",
    "\n",
    "What we *can* do is utilize **nested cross-validation** to alleviate this issue. In this procedure, we implement $k$-fold cross-validation to train $k$ models (the outer loop). Using the *training set* of each fold, we perform `GridSearchCV` to tune the hyperparameters and select a winning model (the inner loop). Then, using the *validation set* of each fold, we evaluate the performance of the winning model developed in the inner loop. Finally, by computing the mean of this performance value across the $k$ folds, we can report a robust estimate of the model's performance. This can be a bit confusing so I recommend taking a glance at [this visual representation](https://mlr-org.github.io/mlr-tutorial/devel/html/nested_resampling/index.html) of what's going on.\n",
    "\n",
    "Using nested cross-validation, let's test a range of 20 values for the regularization hyperparameter and use 10-fold cross-validation to assess the classifier's performance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.91636364,  0.94366197,  0.95104895,  0.93661972,  0.94736842,\n",
       "        0.93286219,  0.91039427,  0.90510949,  0.9057971 ,  0.94699647])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Select a range of values to test the regularization hyperparameter\n",
    "param_grid = [{'C': np.logspace(-4, 4, 20)}]\n",
    "\n",
    "# Inner cross-validation loop to tune the hyperparameter\n",
    "grid_search = GridSearchCV(\n",
    "    estimator=svm.LinearSVC(loss='hinge'),\n",
    "    param_grid=param_grid,\n",
    "    cv=StratifiedShuffleSplit(n_splits=10, test_size=0.2, random_state=42),\n",
    "    scoring='f1',\n",
    "    n_jobs=-1\n",
    ")\n",
    "\n",
    "# Outer cross-validation loop to assess the model's performance\n",
    "scores = cross_val_score(\n",
    "    estimator=grid_search,\n",
    "    X=X_ngrams,\n",
    "    y=y_enc,\n",
    "    cv=StratifiedShuffleSplit(n_splits=10, test_size=0.2, random_state=0),\n",
    "    scoring='f1',\n",
    "    n_jobs=-1\n",
    ")\n",
    "\n",
    "scores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The scores across the 10 folds demonstrate the classifier's performance is moderately consistent&mdash;it depends on what level of variation we're comfortable with. Finally, let's compute the mean score to report an estimate of the classifier's performance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.92962222115832238"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scores.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"cell5\"></a>\n",
    "# 5. What terms are the top predictors of spam?\n",
    "\n",
    "I'm incredibly curious about which $n$-grams are the most predictive of spam. But first, we need to use the optimal regularization hyperparameter to train the classifier on the *whole* dataset in order to provide it as much information as possible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Identify the optimal regularization hyperparameter\n",
    "grid_search.fit(X_ngrams, y_enc)\n",
    "\n",
    "# Train the classifier on the entire dataset using the optimal hyperparameter\n",
    "final_clf = svm.LinearSVC(loss='hinge', C=grid_search.best_params_['C'])\n",
    "final_clf.fit(X_ngrams, y_enc);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's take a look at the top 20 $n$-grams that are most predictive of spam."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "phonenumbr         5.008632\n",
       "numbrp             2.799188\n",
       "txt                2.690817\n",
       "moneysymbnumbr     2.557430\n",
       "call phonenumbr    2.251018\n",
       "rington            2.098571\n",
       "servic             2.049272\n",
       "mobil              2.036900\n",
       "numbr              1.896237\n",
       "tone               1.831284\n",
       "repli              1.664236\n",
       "text               1.603976\n",
       "claim              1.590065\n",
       "video              1.473552\n",
       "free               1.359938\n",
       "wap                1.336547\n",
       "stop               1.310738\n",
       "credit             1.278887\n",
       "uk                 1.239139\n",
       "order              1.227617\n",
       "dtype: float64"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Display the features with the highest weights in the SVM model\n",
    "pd.Series(\n",
    "    final_clf.coef_.T.ravel(),\n",
    "    index=vectorizer.get_feature_names()\n",
    ").sort_values(ascending=False)[:20]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are a few obvious ones at the top: `phonenumbr`, `txt`, `moneysymbnumber` (money amount), `call phonenumbr`, `claim`, `video`, `free`, `stop`, `credit` and `order`. However, the [data description](https://archive.ics.uci.edu/ml/datasets/sms+spam+collection) points out the majority of the spam in this dataset originated from a British website, while the most of the ham came from Singaporean students. This is quite concerning because the lexicon in SMS messages varies dramatically across different national, cultural and age demographics. This sampling bias may adversely affect the validity of the classifier. Remember what I said earlier about the data you use to train a model?\n",
    "\n",
    "To finish up, let's write up a function that'll decide whether a string is spam or not, and apply it on the hypothetical message from earlier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def spam_filter(message):\n",
    "    if final_clf.predict(vectorizer.transform([preprocess_text(message)])):\n",
    "        return 'spam'\n",
    "    else:\n",
    "        return 'not spam'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'spam'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spam_filter(example)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The classifier decided that message was indeed spam. Do you agree? Let's try a real SMS message that I just received (spoiler: it's not spam)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'not spam'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spam_filter('Ohhh, but those are the best kind of foods')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cool! Go ahead and try your own messages!\n",
    "\n",
    "<a id=\"cell6\"></a>\n",
    "# 6. How to improve the model\n",
    "\n",
    "We can attempt to boost the classifier's performance but there's simply too many different avenues. However, I'd like to highlight some of the prominent ones.\n",
    "\n",
    "1. Text preprocessing\n",
    "    * I handcrafted the regular expressions in this post (by no means an expert!) but I'm certain we can increase their matching performance and efficiency. It may be also be worthwhile using regex to normalize other terms such as dates, times, slang, etc.\n",
    "    * I selected the Porter stemmer here but comparing the performance with the Lancaster stemmer would be interesting. However, stemming can be crude and chop off suffixes haphazhardly&mdash;a better alternative is **lemmatization**. For example, the word \"worse\" reduces to \"bad\".\n",
    "    * We ignored the innate features of each training example such as message length, average word length, distribution of the various forms of punctuation, all-caps frequency, etc. Each of these may enhance the classifier's predictive capacity.\n",
    "2. Feature engineering\n",
    "    * I discovered Scikit-learn computes term frequency by simply counting each term. Because SMS messages come in a variety of lengths, normalizing the term frequency to the message length is a good idea.\n",
    "    * You may have noticed most of the top 20 terms listed above are unigrams. This hints that bigrams aren't as useful in this problem&mdash;a bag of words model may be sufficient.\n",
    "3. Machine learning\n",
    "    * Instead of tuning just the classifier's hyperparameters, we can perform a more exhaustive `GridSearchCV` to compare the use of raw term frequencies instead of tf-idf, or perhaps only tokenizing terms that have a term frequency above/below a threshold. In fact, `TfidfVectorizer` includes many other knobs to play with. In addition, we can test other classifiers such as Naive Bayes, logistic regression or a neural net. All of these different options can be investigated simultaneously by combining `GridSearchCV` with Scikit-learn's [`Pipeline` tool](http://scikit-learn.org/stable/auto_examples/model_selection/grid_search_text_feature_extraction.html).\n",
    "    \n",
    "Of course, the biggest issue in this analysis stems from the dataset itself. We discovered the training examples weren't **independently and identically distributed**, which breaks an [important assumption](https://stats.stackexchange.com/questions/213464/on-the-importance-of-the-i-i-d-assumption-in-statistical-learning) in machine learning. Therefore, to improve the classifier, it's crucial to not only acquire *more* training examples but ensure they all come from the same distribution.\n",
    "\n",
    "You probably realized by now that each time you reported an email as spam on Gmail, you were providing Google one more training example to help improve their classifier! I hope this post presented a glimpse of what NLP offers and how it can be combined with machine learning to tackle a real world problem. I've only scratched the surface&mdash;can't wait to dive deeper into the linguistics!\n",
    "\n",
    "If you have any comments, questions or suggestions, kindly visit the [blog post](http://inmachineswetrust.com/posts/sms-spam-filter/) associated with this analysis."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}