HMM Tagger.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Project: Part of Speech Tagging with Hidden Markov Models \n",
    "---\n",
    "### Introduction\n",
    "\n",
    "Part of speech tagging is the process of determining the syntactic category of a word from the words in its surrounding context. It is often used to help disambiguate natural language phrases because it can be done quickly with high accuracy. Tagging can be used for many NLP tasks like determining correct pronunciation during speech synthesis (for example, _dis_-count as a noun vs dis-_count_ as a verb), for information retrieval, and for word sense disambiguation.\n",
    "\n",
    "In this notebook, you'll use the [Pomegranate](http://pomegranate.readthedocs.io/) library to build a hidden Markov model for part of speech tagging using a \"universal\" tagset. Hidden Markov models have been able to achieve [>96% tag accuracy with larger tagsets on realistic text corpora](http://www.coli.uni-saarland.de/~thorsten/publications/Brants-ANLP00.pdf). Hidden Markov models have also been used for speech recognition and speech generation, machine translation, gene recognition for bioinformatics, and human gesture recognition for computer vision, and more. \n",
    "\n",
    "![](_post-hmm.png)\n",
    "\n",
    "The notebook already contains some code to get you started. You only need to add some new functionality in the areas indicated to complete the project; you will not need to modify the included code beyond what is requested. Sections that begin with **'IMPLEMENTATION'** in the header indicate that you must provide code in the block that follows. Instructions will be provided for each section, and the specifics of the implementation are marked in the code block with a 'TODO' statement. Please be sure to read the instructions carefully!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "**Note:** Once you have completed all of the code implementations, you need to finalize your work by exporting the iPython Notebook as an HTML document. Before exporting the notebook to html, all of the code cells need to have been run so that reviewers can see the final implementation and output. You must then **export the notebook** by running the last cell in the notebook, or by using the menu above and navigating to **File -> Download as -> HTML (.html)** Your submissions should include both the `html` and `ipynb` files.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "**Note:** Code and Markdown cells can be executed using the `Shift + Enter` keyboard shortcut. Markdown cells can be edited by double-clicking the cell to enter edit mode.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Road Ahead\n",
    "You must complete Steps 1-3 below to pass the project. The section on Step 4 includes references & resources you can use to further explore HMM taggers.\n",
    "\n",
    "- [Step 1](#Step-1:-Read-and-preprocess-the-dataset): Review the provided interface to load and access the text corpus\n",
    "- [Step 2](#Step-2:-Build-a-Most-Frequent-Class-tagger): Build a Most Frequent Class tagger to use as a baseline\n",
    "- [Step 3](#Step-3:-Build-an-HMM-tagger): Build an HMM Part of Speech tagger and compare to the MFC baseline\n",
    "- [Step 4](#Step-4:-[Optional]-Improving-model-performance): (Optional) Improve the HMM tagger"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "**Note:** Make sure you have selected a **Python 3** kernel in Workspaces or the hmm-tagger conda environment if you are running the Jupyter server on your own machine.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Jupyter \"magic methods\" -- only need to be run once per kernel restart\n",
    "%load_ext autoreload\n",
    "%aimport helpers, tests\n",
    "%autoreload 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import python modules -- this cell needs to be run again if you make changes to any of the files\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "from IPython.core.display import HTML\n",
    "from itertools import chain\n",
    "from collections import Counter, defaultdict\n",
    "from helpers import show_model, Dataset\n",
    "from pomegranate import State, HiddenMarkovModel, DiscreteDistribution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 1: Read and preprocess the dataset\n",
    "---\n",
    "We'll start by reading in a text corpus and splitting it into a training and testing dataset. The data set is a copy of the [Brown corpus](https://en.wikipedia.org/wiki/Brown_Corpus) (originally from the [NLTK](https://www.nltk.org/) library) that has already been pre-processed to only include the [universal tagset](https://arxiv.org/pdf/1104.2086.pdf). You should expect to get slightly higher accuracy using this simplified tagset than the same model would achieve on a larger tagset like the full [Penn treebank tagset](https://www.ling.upenn.edu/courses/Fall_2003/ling001/penn_treebank_pos.html), but the process you'll follow would be the same.\n",
    "\n",
    "The `Dataset` class provided in helpers.py will read and parse the corpus. You can generate your own datasets compatible with the reader by writing them to the following format. The dataset is stored in plaintext as a collection of words and corresponding tags. Each sentence starts with a unique identifier on the first line, followed by one tab-separated word/tag pair on each following line. Sentences are separated by a single blank line.\n",
    "\n",
    "Example from the Brown corpus. \n",
    "```\n",
    "b100-38532\n",
    "Perhaps\tADV\n",
    "it\tPRON\n",
    "was\tVERB\n",
    "right\tADJ\n",
    ";\t.\n",
    ";\t.\n",
    "\n",
    "b100-35577\n",
    "...\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 57340 sentences in the corpus.\n",
      "There are 45872 sentences in the training set.\n",
      "There are 11468 sentences in the testing set.\n"
     ]
    }
   ],
   "source": [
    "data = Dataset(\"tags-universal.txt\", \"brown-universal.txt\", train_test_split=0.8)\n",
    "\n",
    "print(\"There are {} sentences in the corpus.\".format(len(data)))\n",
    "print(\"There are {} sentences in the training set.\".format(len(data.training_set)))\n",
    "print(\"There are {} sentences in the testing set.\".format(len(data.testing_set)))\n",
    "\n",
    "assert len(data) == len(data.training_set) + len(data.testing_set), \\\n",
    "       \"The number of sentences in the training set + testing set should sum to the number of sentences in the corpus\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Dataset Interface\n",
    "\n",
    "You can access (mostly) immutable references to the dataset through a simple interface provided through the `Dataset` class, which represents an iterable collection of sentences along with easy access to partitions of the data for training & testing. Review the reference below, then run and review the next few cells to make sure you understand the interface before moving on to the next step.\n",
    "\n",
    "```\n",
    "Dataset-only Attributes:\n",
    "    training_set - reference to a Subset object containing the samples for training\n",
    "    testing_set - reference to a Subset object containing the samples for testing\n",
    "\n",
    "Dataset & Subset Attributes:\n",
    "    sentences - a dictionary with an entry {sentence_key: Sentence()} for each sentence in the corpus\n",
    "    keys - an immutable ordered (not sorted) collection of the sentence_keys for the corpus\n",
    "    vocab - an immutable collection of the unique words in the corpus\n",
    "    tagset - an immutable collection of the unique tags in the corpus\n",
    "    X - returns an array of words grouped by sentences ((w11, w12, w13, ...), (w21, w22, w23, ...), ...)\n",
    "    Y - returns an array of tags grouped by sentences ((t11, t12, t13, ...), (t21, t22, t23, ...), ...)\n",
    "    N - returns the number of distinct samples (individual words or tags) in the dataset\n",
    "\n",
    "Methods:\n",
    "    stream() - returns an flat iterable over all (word, tag) pairs across all sentences in the corpus\n",
    "    __iter__() - returns an iterable over the data as (sentence_key, Sentence()) pairs\n",
    "    __len__() - returns the nubmer of sentences in the dataset\n",
    "```\n",
    "\n",
    "For example, consider a Subset, `subset`, of the sentences `{\"s0\": Sentence((\"See\", \"Spot\", \"run\"), (\"VERB\", \"NOUN\", \"VERB\")), \"s1\": Sentence((\"Spot\", \"ran\"), (\"NOUN\", \"VERB\"))}`. The subset will have these attributes:\n",
    "\n",
    "```\n",
    "subset.keys == {\"s1\", \"s0\"}  # unordered\n",
    "subset.vocab == {\"See\", \"run\", \"ran\", \"Spot\"}  # unordered\n",
    "subset.tagset == {\"VERB\", \"NOUN\"}  # unordered\n",
    "subset.X == ((\"Spot\", \"ran\"), (\"See\", \"Spot\", \"run\"))  # order matches .keys\n",
    "subset.Y == ((\"NOUN\", \"VERB\"), (\"VERB\", \"NOUN\", \"VERB\"))  # order matches .keys\n",
    "subset.N == 7  # there are a total of seven observations over all sentences\n",
    "len(subset) == 2  # because there are two sentences\n",
    "```\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "**Note:** The `Dataset` class is _convenient_, but it is **not** efficient. It is not suitable for huge datasets because it stores multiple redundant copies of the same data.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Sentences\n",
    "\n",
    "`Dataset.sentences` is a dictionary of all sentences in the training corpus, each keyed to a unique sentence identifier. Each `Sentence` is itself an object with two attributes: a tuple of the words in the sentence named `words` and a tuple of the tag corresponding to each word named `tags`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sentence: b100-38532\n",
      "words:\n",
      "\t('Perhaps', 'it', 'was', 'right', ';', ';')\n",
      "tags:\n",
      "\t('ADV', 'PRON', 'VERB', 'ADJ', '.', '.')\n"
     ]
    }
   ],
   "source": [
    "key = 'b100-38532'\n",
    "print(\"Sentence: {}\".format(key))\n",
    "print(\"words:\\n\\t{!s}\".format(data.sentences[key].words))\n",
    "print(\"tags:\\n\\t{!s}\".format(data.sentences[key].tags))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "**Note:** The underlying iterable sequence is **unordered** over the sentences in the corpus; it is not guaranteed to return the sentences in a consistent order between calls. Use `Dataset.stream()`, `Dataset.keys`, `Dataset.X`, or `Dataset.Y` attributes if you need ordered access to the data.\n",
    "</div>\n",
    "\n",
    "#### Counting Unique Elements\n",
    "\n",
    "You can access the list of unique words (the dataset vocabulary) via `Dataset.vocab` and the unique list of tags via `Dataset.tagset`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are a total of 1161192 samples of 56057 unique words in the corpus.\n",
      "There are 928458 samples of 50536 unique words in the training set.\n",
      "There are 232734 samples of 25112 unique words in the testing set.\n",
      "There are 5521 words in the test set that are missing in the training set.\n"
     ]
    }
   ],
   "source": [
    "print(\"There are a total of {} samples of {} unique words in the corpus.\"\n",
    "      .format(data.N, len(data.vocab)))\n",
    "print(\"There are {} samples of {} unique words in the training set.\"\n",
    "      .format(data.training_set.N, len(data.training_set.vocab)))\n",
    "print(\"There are {} samples of {} unique words in the testing set.\"\n",
    "      .format(data.testing_set.N, len(data.testing_set.vocab)))\n",
    "print(\"There are {} words in the test set that are missing in the training set.\"\n",
    "      .format(len(data.testing_set.vocab - data.training_set.vocab)))\n",
    "\n",
    "assert data.N == data.training_set.N + data.testing_set.N, \\\n",
    "       \"The number of training + test samples should sum to the total number of samples\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Accessing word and tag Sequences\n",
    "The `Dataset.X` and `Dataset.Y` attributes provide access to ordered collections of matching word and tag sequences for each sentence in the dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sentence 1: ('Mr.', 'Podger', 'had', 'thanked', 'him', 'gravely', ',', 'and', 'now', 'he', 'made', 'use', 'of', 'the', 'advice', '.')\n",
      "\n",
      "Labels 1: ('NOUN', 'NOUN', 'VERB', 'VERB', 'PRON', 'ADV', '.', 'CONJ', 'ADV', 'PRON', 'VERB', 'NOUN', 'ADP', 'DET', 'NOUN', '.')\n",
      "\n",
      "Sentence 2: ('But', 'there', 'seemed', 'to', 'be', 'some', 'difference', 'of', 'opinion', 'as', 'to', 'how', 'far', 'the', 'board', 'should', 'go', ',', 'and', 'whose', 'advice', 'it', 'should', 'follow', '.')\n",
      "\n",
      "Labels 2: ('CONJ', 'PRT', 'VERB', 'PRT', 'VERB', 'DET', 'NOUN', 'ADP', 'NOUN', 'ADP', 'ADP', 'ADV', 'ADV', 'DET', 'NOUN', 'VERB', 'VERB', '.', 'CONJ', 'DET', 'NOUN', 'PRON', 'VERB', 'VERB', '.')\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# accessing words with Dataset.X and tags with Dataset.Y \n",
    "for i in range(2):    \n",
    "    print(\"Sentence {}:\".format(i + 1), data.X[i])\n",
    "    print()\n",
    "    print(\"Labels {}:\".format(i + 1), data.Y[i])\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Accessing (word, tag) Samples\n",
    "The `Dataset.stream()` method returns an iterator that chains together every pair of (word, tag) entries across all sentences in the entire corpus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Stream (word, tag) pairs:\n",
      "\n",
      "\t ('Mr.', 'NOUN')\n",
      "\t ('Podger', 'NOUN')\n",
      "\t ('had', 'VERB')\n",
      "\t ('thanked', 'VERB')\n",
      "\t ('him', 'PRON')\n",
      "\t ('gravely', 'ADV')\n",
      "\t (',', '.')\n"
     ]
    }
   ],
   "source": [
    "# use Dataset.stream() (word, tag) samples for the entire corpus\n",
    "print(\"\\nStream (word, tag) pairs:\\n\")\n",
    "for i, pair in enumerate(data.stream()):\n",
    "    print(\"\\t\", pair)\n",
    "    if i > 5: break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "For both our baseline tagger and the HMM model we'll build, we need to estimate the frequency of tags & words from the frequency counts of observations in the training corpus. In the next several cells you will complete functions to compute the counts of several sets of counts. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 2: Build a Most Frequent Class tagger\n",
    "---\n",
    "\n",
    "Perhaps the simplest tagger (and a good baseline for tagger performance) is to simply choose the tag most frequently assigned to each word. This \"most frequent class\" tagger inspects each observed word in the sequence and assigns it the label that was most often assigned to that word in the corpus."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### IMPLEMENTATION: Pair Counts\n",
    "\n",
    "Complete the function below that computes the joint frequency counts for two input sequences."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"alert alert-block alert-success\">Your emission counts look good!</div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def pair_counts(sequences_A, sequences_B):\n",
    "    \"\"\"Return a dictionary keyed to each unique value in the first sequence list\n",
    "    that counts the number of occurrences of the corresponding value from the\n",
    "    second sequences list.\n",
    "    \n",
    "    For example, if sequences_A is tags and sequences_B is the corresponding\n",
    "    words, then if 1244 sequences contain the word \"time\" tagged as a NOUN, then\n",
    "    you should return a dictionary such that pair_counts[NOUN][time] == 1244\n",
    "    \"\"\"\n",
    "    # TODO: Finish this function!\n",
    "    pair_counts_dict = defaultdict(lambda: defaultdict(int))\n",
    "    # nested dictionary defaults to 0 if key doesn't already exist\n",
    "        \n",
    "    for i in range(len(sequences_A)):\n",
    "    # sequences_A is a tuple of tuples (and so is sequences_B)\n",
    "    # sequences_A is tags and sequences_B is the corresponding words\n",
    "        for tag, word in zip(sequences_A[i], sequences_B[i]):\n",
    "            pair_counts_dict[tag][word] += 1\n",
    "    return pair_counts_dict\n",
    "\n",
    "\n",
    "# Calculate C(t_i, w_i)\n",
    "emission_counts = pair_counts(data.Y, data.X)\n",
    "\n",
    "\n",
    "assert len(emission_counts) == 12, \\\n",
    "       \"Uh oh. There should be 12 tags in your dictionary.\"\n",
    "assert max(emission_counts[\"NOUN\"], key=emission_counts[\"NOUN\"].get) == 'time', \\\n",
    "       \"Hmmm...'time' is expected to be the most common NOUN.\"\n",
    "HTML('<div class=\"alert alert-block alert-success\">Your emission counts look good!</div>')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### IMPLEMENTATION: Most Frequent Class Tagger\n",
    "\n",
    "Use the `pair_counts()` function and the training dataset to find the most frequent class label for each word in the training data, and populate the `mfc_table` below. The table keys should be words, and the values should be the appropriate tag string.\n",
    "\n",
    "The `MFCTagger` class is provided to mock the interface of Pomegranite HMM models so that they can be used interchangeably."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"alert alert-block alert-success\">Your MFC tagger has all the correct words!</div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a lookup table mfc_table where mfc_table[word] contains the tag label most frequently assigned to that word\n",
    "from collections import namedtuple\n",
    "\n",
    "FakeState = namedtuple(\"FakeState\", \"name\")\n",
    "\n",
    "class MFCTagger:\n",
    "    # NOTE: You should not need to modify this class or any of its methods\n",
    "    missing = FakeState(name=\"<MISSING>\")\n",
    "    \n",
    "    def __init__(self, table):\n",
    "        self.table = defaultdict(lambda: MFCTagger.missing)\n",
    "        self.table.update({word: FakeState(name=tag) for word, tag in table.items()})\n",
    "        \n",
    "    def viterbi(self, seq):\n",
    "        \"\"\"This method simplifies predictions by matching the Pomegranate viterbi() interface\"\"\"\n",
    "        return 0., list(enumerate([\"<start>\"] + [self.table[w] for w in seq] + [\"<end>\"]))\n",
    "\n",
    "\n",
    "# TODO: calculate the frequency of each tag being assigned to each word (hint: similar, but not\n",
    "# the same as the emission probabilities) and use it to fill the mfc_table\n",
    "\n",
    "word_counts = pair_counts(data.training_set.X, data.training_set.Y) # pair_counts(words, tags)\n",
    "\n",
    "mfc_table = {}\n",
    "\n",
    "for word, tags in word_counts.items():\n",
    "    for tag, count in tags.items():\n",
    "        if count == max(tags.values()):\n",
    "        # max(tags.values()) corresponds to the most frequent tag\n",
    "            mfc_table[word] = tag\n",
    "\n",
    "\n",
    "# DO NOT MODIFY BELOW THIS LINE\n",
    "mfc_model = MFCTagger(mfc_table) # Create a Most Frequent Class tagger instance\n",
    "\n",
    "assert len(mfc_table) == len(data.training_set.vocab), \"\"\n",
    "assert all(k in data.training_set.vocab for k in mfc_table.keys()), \"\"\n",
    "assert sum(int(k not in mfc_table) for k in data.testing_set.vocab) == 5521, \"\"\n",
    "HTML('<div class=\"alert alert-block alert-success\">Your MFC tagger has all the correct words!</div>')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Making Predictions with a Model\n",
    "The helper functions provided below interface with Pomegranate network models & the mocked MFCTagger to take advantage of the [missing value](http://pomegranate.readthedocs.io/en/latest/nan.html) functionality in Pomegranate through a simple sequence decoding function. Run these functions, then run the next cell to see some of the predictions made by the MFC tagger."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def replace_unknown(sequence):\n",
    "    \"\"\"Return a copy of the input sequence where each unknown word is replaced\n",
    "    by the literal string value 'nan'. Pomegranate will ignore these values\n",
    "    during computation.\n",
    "    \"\"\"\n",
    "    return [w if w in data.training_set.vocab else 'nan' for w in sequence]\n",
    "\n",
    "def simplify_decoding(X, model):\n",
    "    \"\"\"X should be a 1-D sequence of observations for the model to predict\"\"\"\n",
    "    _, state_path = model.viterbi(replace_unknown(X))\n",
    "    return [state[1].name for state in state_path[1:-1]]  # do not show the start/end state predictions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example Decoding Sequences with MFC Tagger"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sentence Key: b100-28144\n",
      "\n",
      "Predicted labels:\n",
      "-----------------\n",
      "['CONJ', 'NOUN', 'NUM', '.', 'NOUN', 'NUM', '.', 'NOUN', 'NUM', '.', 'CONJ', 'NOUN', 'NUM', '.', '.', 'NOUN', '.', '.']\n",
      "\n",
      "Actual labels:\n",
      "--------------\n",
      "('CONJ', 'NOUN', 'NUM', '.', 'NOUN', 'NUM', '.', 'NOUN', 'NUM', '.', 'CONJ', 'NOUN', 'NUM', '.', '.', 'NOUN', '.', '.')\n",
      "\n",
      "\n",
      "Sentence Key: b100-23146\n",
      "\n",
      "Predicted labels:\n",
      "-----------------\n",
      "['PRON', 'VERB', 'DET', 'NOUN', 'ADP', 'ADJ', 'ADJ', 'NOUN', 'VERB', 'VERB', '.', 'ADP', 'VERB', 'DET', 'NOUN', 'ADP', 'NOUN', 'ADP', 'DET', 'NOUN', '.']\n",
      "\n",
      "Actual labels:\n",
      "--------------\n",
      "('PRON', 'VERB', 'DET', 'NOUN', 'ADP', 'ADJ', 'ADJ', 'NOUN', 'VERB', 'VERB', '.', 'ADP', 'VERB', 'DET', 'NOUN', 'ADP', 'NOUN', 'ADP', 'DET', 'NOUN', '.')\n",
      "\n",
      "\n",
      "Sentence Key: b100-35462\n",
      "\n",
      "Predicted labels:\n",
      "-----------------\n",
      "['DET', 'ADJ', 'NOUN', 'VERB', 'VERB', 'VERB', 'ADP', 'DET', 'ADJ', 'ADJ', 'NOUN', 'ADP', 'DET', 'ADJ', 'NOUN', '.', 'ADP', 'ADJ', 'NOUN', '.', 'CONJ', 'ADP', 'DET', '<MISSING>', 'ADP', 'ADJ', 'ADJ', '.', 'ADJ', '.', 'CONJ', 'ADJ', 'NOUN', 'ADP', 'ADV', 'NOUN', '.']\n",
      "\n",
      "Actual labels:\n",
      "--------------\n",
      "('DET', 'ADJ', 'NOUN', 'VERB', 'VERB', 'VERB', 'ADP', 'DET', 'ADJ', 'ADJ', 'NOUN', 'ADP', 'DET', 'ADJ', 'NOUN', '.', 'ADP', 'ADJ', 'NOUN', '.', 'CONJ', 'ADP', 'DET', 'NOUN', 'ADP', 'ADJ', 'ADJ', '.', 'ADJ', '.', 'CONJ', 'ADJ', 'NOUN', 'ADP', 'ADJ', 'NOUN', '.')\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for key in data.testing_set.keys[:3]:\n",
    "    print(\"Sentence Key: {}\\n\".format(key))\n",
    "    print(\"Predicted labels:\\n-----------------\")\n",
    "    print(simplify_decoding(data.sentences[key].words, mfc_model))\n",
    "    print()\n",
    "    print(\"Actual labels:\\n--------------\")\n",
    "    print(data.sentences[key].tags)\n",
    "    print(\"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluating Model Accuracy\n",
    "\n",
    "The function below will evaluate the accuracy of the MFC tagger on the collection of all sentences from a text corpus. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def accuracy(X, Y, model):\n",
    "    \"\"\"Calculate the prediction accuracy by using the model to decode each sequence\n",
    "    in the input X and comparing the prediction with the true labels in Y.\n",
    "    \n",
    "    The X should be an array whose first dimension is the number of sentences to test,\n",
    "    and each element of the array should be an iterable of the words in the sequence.\n",
    "    The arrays X and Y should have the exact same shape.\n",
    "    \n",
    "    X = [(\"See\", \"Spot\", \"run\"), (\"Run\", \"Spot\", \"run\", \"fast\"), ...]\n",
    "    Y = [(), (), ...]\n",
    "    \"\"\"\n",
    "    correct = total_predictions = 0\n",
    "    for observations, actual_tags in zip(X, Y):\n",
    "        \n",
    "        # The model.viterbi call in simplify_decoding will return None if the HMM\n",
    "        # raises an error (for example, if a test sentence contains a word that\n",
    "        # is out of vocabulary for the training set). Any exception counts the\n",
    "        # full sentence as an error (which makes this a conservative estimate).\n",
    "        try:\n",
    "            most_likely_tags = simplify_decoding(observations, model)\n",
    "            correct += sum(p == t for p, t in zip(most_likely_tags, actual_tags))\n",
    "        except:\n",
    "            pass\n",
    "        total_predictions += len(observations)\n",
    "    return correct / total_predictions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Evaluate the accuracy of the MFC tagger\n",
    "Run the next cell to evaluate the accuracy of the tagger on the training and test corpus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "training accuracy mfc_model: 95.72%\n",
      "testing accuracy mfc_model: 93.00%\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div class=\"alert alert-block alert-success\">Your MFC tagger accuracy looks correct!</div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mfc_training_acc = accuracy(data.training_set.X, data.training_set.Y, mfc_model)\n",
    "print(\"training accuracy mfc_model: {:.2f}%\".format(100 * mfc_training_acc))\n",
    "\n",
    "mfc_testing_acc = accuracy(data.testing_set.X, data.testing_set.Y, mfc_model)\n",
    "print(\"testing accuracy mfc_model: {:.2f}%\".format(100 * mfc_testing_acc))\n",
    "\n",
    "assert mfc_training_acc >= 0.955, \"Uh oh. Your MFC accuracy on the training set doesn't look right.\"\n",
    "assert mfc_testing_acc >= 0.925, \"Uh oh. Your MFC accuracy on the testing set doesn't look right.\"\n",
    "HTML('<div class=\"alert alert-block alert-success\">Your MFC tagger accuracy looks correct!</div>')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 3: Build an HMM tagger\n",
    "---\n",
    "The HMM tagger has one hidden state for each possible tag, and parameterized by two distributions: the emission probabilties giving the conditional probability of observing a given **word** from each hidden state, and the transition probabilities giving the conditional probability of moving between **tags** during the sequence.\n",
    "\n",
    "We will also estimate the starting probability distribution (the probability of each **tag** being the first tag in a sequence), and the terminal probability distribution (the probability of each **tag** being the last tag in a sequence).\n",
    "\n",
    "The maximum likelihood estimate of these distributions can be calculated from the frequency counts as described in the following sections where you'll implement functions to count the frequencies, and finally build the model. The HMM model will make predictions according to the formula:\n",
    "\n",
    "$$t_i^n = \\underset{t_i^n}{\\mathrm{argmax}} \\prod_{i=1}^n P(w_i|t_i) P(t_i|t_{i-1})$$\n",
    "\n",
    "Refer to Speech & Language Processing [Chapter 10](https://web.stanford.edu/~jurafsky/slp3/10.pdf) for more information."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### IMPLEMENTATION: Unigram Counts\n",
    "\n",
    "Complete the function below to estimate the co-occurrence frequency of each symbol over all of the input sequences. The unigram probabilities in our HMM model are estimated from the formula below, where N is the total number of samples in the input. (You only need to compute the counts for now.)\n",
    "\n",
    "$$P(tag_1) = \\frac{C(tag_1)}{N}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"alert alert-block alert-success\">Your tag unigrams look good!</div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def unigram_counts(sequences):\n",
    "    \"\"\"Return a dictionary keyed to each unique value in the input sequence list that\n",
    "    counts the number of occurrences of the value in the sequences list. The sequences\n",
    "    collection should be a 2-dimensional array.\n",
    "    \n",
    "    For example, if the tag NOUN appears 275558 times over all the input sequences,\n",
    "    then you should return a dictionary such that your_unigram_counts[NOUN] == 275558.\n",
    "    \"\"\"\n",
    "    # TODO: Finish this function!\n",
    "    unigram_counts_dict = defaultdict(int)\n",
    "    # dictionary defaults to 0 if key doesn't already exist\n",
    "    \n",
    "    for sentence_tags in sequences:\n",
    "        for tag in sentence_tags:\n",
    "            unigram_counts_dict[tag] += 1\n",
    "    return unigram_counts_dict\n",
    "\n",
    "\n",
    "# TODO: call unigram_counts with a list of tag sequences from the training set\n",
    "tag_unigrams = unigram_counts(data.training_set.Y)\n",
    "\n",
    "\n",
    "assert set(tag_unigrams.keys()) == data.training_set.tagset, \\\n",
    "       \"Uh oh. It looks like your tag counts doesn't include all the tags!\"\n",
    "assert min(tag_unigrams, key=tag_unigrams.get) == 'X', \\\n",
    "       \"Hmmm...'X' is expected to be the least common class\"\n",
    "assert max(tag_unigrams, key=tag_unigrams.get) == 'NOUN', \\\n",
    "       \"Hmmm...'NOUN' is expected to be the most common class\"\n",
    "HTML('<div class=\"alert alert-block alert-success\">Your tag unigrams look good!</div>')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### IMPLEMENTATION: Bigram Counts\n",
    "\n",
    "Complete the function below to estimate the co-occurrence frequency of each pair of symbols in each of the input sequences. These counts are used in the HMM model to estimate the bigram probability of two tags from the frequency counts according to the formula: $$P(tag_2|tag_1) = \\frac{C(tag_2|tag_1)}{C(tag_2)}$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"alert alert-block alert-success\">Your tag bigrams look good!</div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def bigram_counts(sequences):\n",
    "    \"\"\"Return a dictionary keyed to each unique PAIR of values in the input sequences\n",
    "    list that counts the number of occurrences of pair in the sequences list. The input\n",
    "    should be a 2-dimensional array.\n",
    "    \n",
    "    For example, if the pair of tags (NOUN, VERB) appear 61582 times, then you should\n",
    "    return a dictionary such that your_bigram_counts[(NOUN, VERB)] == 61582\n",
    "    \"\"\"\n",
    "\n",
    "    # TODO: Finish this function!\n",
    "    bigram_counts_dict = defaultdict(int)\n",
    "    # dictionary defaults to 0 if key doesn't already exist\n",
    "    \n",
    "    for sentence_tags in sequences:\n",
    "        for i in range(len(sentence_tags)-1):\n",
    "        # i stops at the second to last tag of each sentence\n",
    "            bigram_counts_dict[(sentence_tags[i], sentence_tags[i+1])] += 1\n",
    "    return bigram_counts_dict\n",
    "\n",
    "\n",
    "# TODO: call bigram_counts with a list of tag sequences from the training set\n",
    "tag_bigrams = bigram_counts(data.training_set.Y)\n",
    "\n",
    "\n",
    "assert len(tag_bigrams) == 144, \\\n",
    "       \"Uh oh. There should be 144 pairs of bigrams (12 tags x 12 tags)\"\n",
    "assert min(tag_bigrams, key=tag_bigrams.get) in [('X', 'NUM'), ('PRON', 'X')], \\\n",
    "       \"Hmmm...The least common bigram should be one of ('X', 'NUM') or ('PRON', 'X').\"\n",
    "assert max(tag_bigrams, key=tag_bigrams.get) in [('DET', 'NOUN')], \\\n",
    "       \"Hmmm...('DET', 'NOUN') is expected to be the most common bigram.\"\n",
    "HTML('<div class=\"alert alert-block alert-success\">Your tag bigrams look good!</div>')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### IMPLEMENTATION: Sequence Starting Counts\n",
    "Complete the code below to estimate the bigram probabilities of a sequence starting with each tag."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"alert alert-block alert-success\">Your starting tag counts look good!</div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def starting_counts(sequences):\n",
    "    \"\"\"Return a dictionary keyed to each unique value in the input sequences list\n",
    "    that counts the number of occurrences where that value is at the beginning of\n",
    "    a sequence.\n",
    "    \n",
    "    For example, if 8093 sequences start with NOUN, then you should return a\n",
    "    dictionary such that your_starting_counts[NOUN] == 8093\n",
    "    \"\"\"\n",
    "    # TODO: Finish this function!\n",
    "    starting_counts_dict = defaultdict(int)\n",
    "    # dictionary defaults to 0 if key doesn't already exist\n",
    "    \n",
    "    for sentence_tags in sequences:\n",
    "        starting_counts_dict[sentence_tags[0]] += 1\n",
    "        # considers only the first tag of each sentence\n",
    "    return starting_counts_dict\n",
    "\n",
    "\n",
    "# TODO: Calculate the count of each tag starting a sequence\n",
    "tag_starts = starting_counts(data.training_set.Y)\n",
    "\n",
    "\n",
    "assert len(tag_starts) == 12, \"Uh oh. There should be 12 tags in your dictionary.\"\n",
    "assert min(tag_starts, key=tag_starts.get) == 'X', \"Hmmm...'X' is expected to be the least common starting bigram.\"\n",
    "assert max(tag_starts, key=tag_starts.get) == 'DET', \"Hmmm...'DET' is expected to be the most common starting bigram.\"\n",
    "HTML('<div class=\"alert alert-block alert-success\">Your starting tag counts look good!</div>')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### IMPLEMENTATION: Sequence Ending Counts\n",
    "Complete the function below to estimate the bigram probabilities of a sequence ending with each tag."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"alert alert-block alert-success\">Your ending tag counts look good!</div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def ending_counts(sequences):\n",
    "    \"\"\"Return a dictionary keyed to each unique value in the input sequences list\n",
    "    that counts the number of occurrences where that value is at the end of\n",
    "    a sequence.\n",
    "    \n",
    "    For example, if 18 sequences end with DET, then you should return a\n",
    "    dictionary such that your_starting_counts[DET] == 18\n",
    "    \"\"\"\n",
    "    # TODO: Finish this function!\n",
    "    ending_counts_dict = defaultdict(int)\n",
    "    # dictionary defaults to 0 if key doesn't already exist\n",
    "    \n",
    "    for sentence_tags in sequences:\n",
    "        ending_counts_dict[sentence_tags[-1]] += 1\n",
    "        # considers only the last tag of each sentence\n",
    "    return ending_counts_dict\n",
    "\n",
    "\n",
    "# TODO: Calculate the count of each tag ending a sequence\n",
    "tag_ends = ending_counts(data.training_set.Y)\n",
    "\n",
    "    \n",
    "assert len(tag_ends) == 12, \"Uh oh. There should be 12 tags in your dictionary.\"\n",
    "assert min(tag_ends, key=tag_ends.get) in ['X', 'CONJ'], \"Hmmm...'X' or 'CONJ' should be the least common ending bigram.\"\n",
    "assert max(tag_ends, key=tag_ends.get) == '.', \"Hmmm...'.' is expected to be the most common ending bigram.\"\n",
    "HTML('<div class=\"alert alert-block alert-success\">Your ending tag counts look good!</div>')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### IMPLEMENTATION: Basic HMM Tagger\n",
    "Use the tag unigrams and bigrams calculated above to construct a hidden Markov tagger.\n",
    "\n",
    "- Add one state per tag\n",
    "    - The emission distribution at each state should be estimated with the formula: $P(w|t) = \\frac{C(t, w)}{C(t)}$\n",
    "- Add an edge from the starting state `basic_model.start` to each tag\n",
    "    - The transition probability should be estimated with the formula: $P(t|start) = \\frac{C(start, t)}{C(start)}$\n",
    "- Add an edge from each tag to the end state `basic_model.end`\n",
    "    - The transition probability should be estimated with the formula: $P(end|t) = \\frac{C(t, end)}{C(t)}$\n",
    "- Add an edge between _every_ pair of tags\n",
    "    - The transition probability should be estimated with the formula: $P(t_2|t_1) = \\frac{C(t_1, t_2)}{C(t_1)}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class=\"alert alert-block alert-success\">Your HMM network topology looks good!</div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "basic_model = HiddenMarkovModel(name=\"base-hmm-tagger\")\n",
    "\n",
    "# TODO: create states with emission probability distributions P(word | tag) and add to the model\n",
    "# (Hint: you may need to loop & create/add new states)\n",
    "\n",
    "# Emission counts for the training set\n",
    "emission_counts_training = pair_counts(data.training_set.Y, data.training_set.X)\n",
    "\n",
    "\n",
    "# Calculate emission probability distribution (tag_emission_pd) and add states\n",
    "tags_state = {}\n",
    "\n",
    "for tag, words in emission_counts_training.items():\n",
    "    \n",
    "    emission_distribution = {}\n",
    "\n",
    "    for word in words.keys():\n",
    "        emission_distribution[word] = emission_counts_training[tag][word] / tag_unigrams[tag]\n",
    "\n",
    "    tag_emission_pd = DiscreteDistribution(emission_distribution)\n",
    "    \n",
    "    # Create one state per tag\n",
    "    tags_state[tag] = State(tag_emission_pd, name=tag)\n",
    "\n",
    "# Add one state per tag\n",
    "basic_model.add_states([tag_state for tag_state in tags_state.values()])\n",
    "\n",
    "\n",
    "# TODO: add edges between states for the observed transition frequencies P(tag_i | tag_i-1)\n",
    "# (Hint: you may need to loop & add transitions\n",
    "\n",
    "# Add an edge from the starting state basic_model.start to each tag\n",
    "for tag in tag_starts.keys():\n",
    "    \n",
    "    # transition probability\n",
    "    transition_p = tag_starts[tag] / sum(tag_starts.values())\n",
    "    \n",
    "    basic_model.add_transition(basic_model.start, tags_state[tag], transition_p)\n",
    "\n",
    "\n",
    "# Add an edge from each tag to the end state basic_model.end\n",
    "for tag in tag_ends.keys():\n",
    "    \n",
    "    # transition probability\n",
    "    transition_p = tag_ends[tag] / tag_unigrams[tag]\n",
    "    \n",
    "    basic_model.add_transition(tags_state[tag], basic_model.end, transition_p)\n",
    "    \n",
    "\n",
    "# Add an edge between every pair of tags\n",
    "for (tag1, tag2) in tag_bigrams.keys():\n",
    "    \n",
    "    # transition probability\n",
    "    transition_p = tag_bigrams[(tag1, tag2)] / tag_unigrams[tag1]\n",
    "    \n",
    "    basic_model.add_transition(tags_state[tag1], tags_state[tag2], transition_p)\n",
    "\n",
    "\n",
    "# NOTE: YOU SHOULD NOT NEED TO MODIFY ANYTHING BELOW THIS LINE\n",
    "# finalize the model\n",
    "basic_model.bake()\n",
    "\n",
    "assert all(tag in set(s.name for s in basic_model.states) for tag in data.training_set.tagset), \\\n",
    "       \"Every state in your network should use the name of the associated tag, which must be one of the training set tags.\"\n",
    "assert basic_model.edge_count() == 168, \\\n",
    "       (\"Your network should have an edge from the start node to each state, one edge between every \" +\n",
    "        \"pair of tags (states), and an edge from each state to the end node.\")\n",
    "HTML('<div class=\"alert alert-block alert-success\">Your HMM network topology looks good!</div>')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "training accuracy basic hmm model: 97.54%\n",
      "testing accuracy basic hmm model: 95.95%\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div class=\"alert alert-block alert-success\">Your HMM tagger accuracy looks correct! Congratulations, you've finished the project.</div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hmm_training_acc = accuracy(data.training_set.X, data.training_set.Y, basic_model)\n",
    "print(\"training accuracy basic hmm model: {:.2f}%\".format(100 * hmm_training_acc))\n",
    "\n",
    "hmm_testing_acc = accuracy(data.testing_set.X, data.testing_set.Y, basic_model)\n",
    "print(\"testing accuracy basic hmm model: {:.2f}%\".format(100 * hmm_testing_acc))\n",
    "\n",
    "assert hmm_training_acc > 0.97, \"Uh oh. Your HMM accuracy on the training set doesn't look right.\"\n",
    "assert hmm_testing_acc > 0.955, \"Uh oh. Your HMM accuracy on the testing set doesn't look right.\"\n",
    "HTML('<div class=\"alert alert-block alert-success\">Your HMM tagger accuracy looks correct! Congratulations, you\\'ve finished the project.</div>')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example Decoding Sequences with the HMM Tagger"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sentence Key: b100-28144\n",
      "\n",
      "Predicted labels:\n",
      "-----------------\n",
      "['CONJ', 'NOUN', 'NUM', '.', 'NOUN', 'NUM', '.', 'NOUN', 'NUM', '.', 'CONJ', 'NOUN', 'NUM', '.', '.', 'NOUN', '.', '.']\n",
      "\n",
      "Actual labels:\n",
      "--------------\n",
      "('CONJ', 'NOUN', 'NUM', '.', 'NOUN', 'NUM', '.', 'NOUN', 'NUM', '.', 'CONJ', 'NOUN', 'NUM', '.', '.', 'NOUN', '.', '.')\n",
      "\n",
      "\n",
      "Sentence Key: b100-23146\n",
      "\n",
      "Predicted labels:\n",
      "-----------------\n",
      "['PRON', 'VERB', 'DET', 'NOUN', 'ADP', 'ADJ', 'ADJ', 'NOUN', 'VERB', 'VERB', '.', 'ADP', 'VERB', 'DET', 'NOUN', 'ADP', 'NOUN', 'ADP', 'DET', 'NOUN', '.']\n",
      "\n",
      "Actual labels:\n",
      "--------------\n",
      "('PRON', 'VERB', 'DET', 'NOUN', 'ADP', 'ADJ', 'ADJ', 'NOUN', 'VERB', 'VERB', '.', 'ADP', 'VERB', 'DET', 'NOUN', 'ADP', 'NOUN', 'ADP', 'DET', 'NOUN', '.')\n",
      "\n",
      "\n",
      "Sentence Key: b100-35462\n",
      "\n",
      "Predicted labels:\n",
      "-----------------\n",
      "['DET', 'ADJ', 'NOUN', 'VERB', 'VERB', 'VERB', 'ADP', 'DET', 'ADJ', 'ADJ', 'NOUN', 'ADP', 'DET', 'ADJ', 'NOUN', '.', 'ADP', 'ADJ', 'NOUN', '.', 'CONJ', 'ADP', 'DET', 'NOUN', 'ADP', 'ADJ', 'ADJ', '.', 'ADJ', '.', 'CONJ', 'ADJ', 'NOUN', 'ADP', 'ADJ', 'NOUN', '.']\n",
      "\n",
      "Actual labels:\n",
      "--------------\n",
      "('DET', 'ADJ', 'NOUN', 'VERB', 'VERB', 'VERB', 'ADP', 'DET', 'ADJ', 'ADJ', 'NOUN', 'ADP', 'DET', 'ADJ', 'NOUN', '.', 'ADP', 'ADJ', 'NOUN', '.', 'CONJ', 'ADP', 'DET', 'NOUN', 'ADP', 'ADJ', 'ADJ', '.', 'ADJ', '.', 'CONJ', 'ADJ', 'NOUN', 'ADP', 'ADJ', 'NOUN', '.')\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for key in data.testing_set.keys[:3]:\n",
    "    print(\"Sentence Key: {}\\n\".format(key))\n",
    "    print(\"Predicted labels:\\n-----------------\")\n",
    "    print(simplify_decoding(data.sentences[key].words, basic_model))\n",
    "    print()\n",
    "    print(\"Actual labels:\\n--------------\")\n",
    "    print(data.sentences[key].tags)\n",
    "    print(\"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Finishing the project\n",
    "---\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "**Note:** **SAVE YOUR NOTEBOOK**, then run the next cell to generate an HTML copy. You will zip & submit both this file and the HTML copy for review.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "!!jupyter nbconvert *.ipynb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 4: [Optional] Improving model performance\n",
    "---\n",
    "There are additional enhancements that can be incorporated into your tagger that improve performance on larger tagsets where the data sparsity problem is more significant. The data sparsity problem arises because the same amount of data split over more tags means there will be fewer samples in each tag, and there will be more missing data  tags that have zero occurrences in the data. The techniques in this section are optional.\n",
    "\n",
    "- [Laplace Smoothing](https://en.wikipedia.org/wiki/Additive_smoothing) (pseudocounts)\n",
    "    Laplace smoothing is a technique where you add a small, non-zero value to all observed counts to offset for unobserved values.\n",
    "\n",
    "- Backoff Smoothing\n",
    "    Another smoothing technique is to interpolate between n-grams for missing data. This method is more effective than Laplace smoothing at combatting the data sparsity problem. Refer to chapters 4, 9, and 10 of the [Speech & Language Processing](https://web.stanford.edu/~jurafsky/slp3/) book for more information.\n",
    "\n",
    "- Extending to Trigrams\n",
    "    HMM taggers have achieved better than 96% accuracy on this dataset with the full Penn treebank tagset using an architecture described in [this](http://www.coli.uni-saarland.de/~thorsten/publications/Brants-ANLP00.pdf) paper. Altering your HMM to achieve the same performance would require implementing deleted interpolation (described in the paper), incorporating trigram probabilities in your frequency tables, and re-implementing the Viterbi algorithm to consider three consecutive states instead of two.\n",
    "\n",
    "### Obtain the Brown Corpus with a Larger Tagset\n",
    "Run the code below to download a copy of the brown corpus with the full NLTK tagset. You will need to research the available tagset information in the NLTK docs and determine the best way to extract the subset of NLTK tags you want to explore. If you write the following the format specified in Step 1, then you can reload the data using all of the code above for comparison.\n",
    "\n",
    "Refer to [Chapter 5](http://www.nltk.org/book/ch05.html) of the NLTK book for more information on the available tagsets."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "### Optional implementation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Add-one (Laplace) smoothing and add-k smoothing (0<k<1) with Pomegranate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To apply smoothing in Pomegrante, we can use its parameter `pseudocount`. In particular, to apply **smoothing to our transition probabilities**, we can do the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "basic_model.fit(data.training_set.X, algorithm='viterbi', transition_pseudocount=1, use_pseudocount=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To apply add-k smoothing, we just need to set `transition_pseudocount` to a value between 0 and 1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Brown corpus tagged with a larger tagset "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's try our HMM tagger with a different tagset. We'll start with the **Brown corpus tagged with the full tagset** instead of the universal tagset we've used before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('The', 'AT'),\n",
       " ('Fulton', 'NP-TL'),\n",
       " ('County', 'NN-TL'),\n",
       " ('Grand', 'JJ-TL'),\n",
       " ('Jury', 'NN-TL'),\n",
       " ('said', 'VBD'),\n",
       " ('Friday', 'NR'),\n",
       " ('an', 'AT'),\n",
       " ('investigation', 'NN'),\n",
       " ('of', 'IN'),\n",
       " (\"Atlanta's\", 'NP$'),\n",
       " ('recent', 'JJ'),\n",
       " ('primary', 'NN'),\n",
       " ('election', 'NN'),\n",
       " ('produced', 'VBD'),\n",
       " ('``', '``'),\n",
       " ('no', 'AT'),\n",
       " ('evidence', 'NN'),\n",
       " (\"''\", \"''\"),\n",
       " ('that', 'CS'),\n",
       " ('any', 'DTI'),\n",
       " ('irregularities', 'NNS'),\n",
       " ('took', 'VBD'),\n",
       " ('place', 'NN'),\n",
       " ('.', '.')]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import nltk\n",
    "from nltk.corpus import brown\n",
    "\n",
    "brown_tagged = brown.tagged_sents()\n",
    "brown_tagged[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now check how many tags we have and the different counts for each tag."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "tc = defaultdict(int)\n",
    "\n",
    "for sentence in brown_tagged:\n",
    "    for word, tag in sentence:\n",
    "        tc[tag] += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defaultdict(int,\n",
       "            {\"'\": 317,\n",
       "             \"''\": 8789,\n",
       "             '(': 2264,\n",
       "             '(-HL': 162,\n",
       "             ')': 2273,\n",
       "             ')-HL': 184,\n",
       "             '*': 4603,\n",
       "             '*-HL': 8,\n",
       "             '*-NC': 1,\n",
       "             '*-TL': 1,\n",
       "             ',': 58156,\n",
       "             ',-HL': 171,\n",
       "             ',-NC': 5,\n",
       "             ',-TL': 4,\n",
       "             '--': 3405,\n",
       "             '---HL': 26,\n",
       "             '.': 60638,\n",
       "             '.-HL': 598,\n",
       "             '.-NC': 16,\n",
       "             '.-TL': 2,\n",
       "             ':': 1558,\n",
       "             ':-HL': 138,\n",
       "             ':-TL': 22,\n",
       "             'ABL': 357,\n",
       "             'ABN': 3010,\n",
       "             'ABN-HL': 4,\n",
       "             'ABN-NC': 1,\n",
       "             'ABN-TL': 7,\n",
       "             'ABX': 730,\n",
       "             'AP': 9522,\n",
       "             'AP$': 9,\n",
       "             'AP+AP-NC': 1,\n",
       "             'AP-HL': 40,\n",
       "             'AP-NC': 2,\n",
       "             'AP-TL': 18,\n",
       "             'AT': 97959,\n",
       "             'AT-HL': 332,\n",
       "             'AT-NC': 35,\n",
       "             'AT-TL': 746,\n",
       "             'AT-TL-HL': 5,\n",
       "             'BE': 6360,\n",
       "             'BE-HL': 13,\n",
       "             'BE-TL': 1,\n",
       "             'BED': 3282,\n",
       "             'BED*': 22,\n",
       "             'BED-NC': 3,\n",
       "             'BEDZ': 9806,\n",
       "             'BEDZ*': 154,\n",
       "             'BEDZ-HL': 1,\n",
       "             'BEDZ-NC': 8,\n",
       "             'BEG': 686,\n",
       "             'BEM': 226,\n",
       "             'BEM*': 9,\n",
       "             'BEM-NC': 2,\n",
       "             'BEN': 2470,\n",
       "             'BEN-TL': 2,\n",
       "             'BER': 4379,\n",
       "             'BER*': 47,\n",
       "             'BER*-NC': 1,\n",
       "             'BER-HL': 11,\n",
       "             'BER-NC': 5,\n",
       "             'BER-TL': 6,\n",
       "             'BEZ': 10066,\n",
       "             'BEZ*': 117,\n",
       "             'BEZ-HL': 30,\n",
       "             'BEZ-NC': 5,\n",
       "             'BEZ-TL': 8,\n",
       "             'CC': 37718,\n",
       "             'CC-HL': 119,\n",
       "             'CC-NC': 5,\n",
       "             'CC-TL': 307,\n",
       "             'CC-TL-HL': 2,\n",
       "             'CD': 13510,\n",
       "             'CD$': 5,\n",
       "             'CD-HL': 444,\n",
       "             'CD-NC': 5,\n",
       "             'CD-TL': 898,\n",
       "             'CD-TL-HL': 17,\n",
       "             'CS': 22143,\n",
       "             'CS-HL': 25,\n",
       "             'CS-NC': 5,\n",
       "             'CS-TL': 2,\n",
       "             'DO': 1353,\n",
       "             'DO*': 485,\n",
       "             'DO*-HL': 3,\n",
       "             'DO+PPSS': 1,\n",
       "             'DO-HL': 4,\n",
       "             'DO-NC': 2,\n",
       "             'DO-TL': 5,\n",
       "             'DOD': 1047,\n",
       "             'DOD*': 402,\n",
       "             'DOD*-TL': 1,\n",
       "             'DOD-NC': 1,\n",
       "             'DOZ': 467,\n",
       "             'DOZ*': 89,\n",
       "             'DOZ*-TL': 1,\n",
       "             'DOZ-HL': 16,\n",
       "             'DOZ-TL': 2,\n",
       "             'DT': 8957,\n",
       "             'DT$': 5,\n",
       "             'DT+BEZ': 179,\n",
       "             'DT+BEZ-NC': 1,\n",
       "             'DT+MD': 3,\n",
       "             'DT-HL': 6,\n",
       "             'DT-NC': 7,\n",
       "             'DT-TL': 9,\n",
       "             'DTI': 2921,\n",
       "             'DTI-HL': 6,\n",
       "             'DTI-TL': 2,\n",
       "             'DTS': 2435,\n",
       "             'DTS+BEZ': 2,\n",
       "             'DTS-HL': 2,\n",
       "             'DTX': 104,\n",
       "             'EX': 2164,\n",
       "             'EX+BEZ': 105,\n",
       "             'EX+HVD': 3,\n",
       "             'EX+HVZ': 2,\n",
       "             'EX+MD': 4,\n",
       "             'EX-HL': 1,\n",
       "             'EX-NC': 1,\n",
       "             'FW-*': 6,\n",
       "             'FW-*-TL': 2,\n",
       "             'FW-AT': 24,\n",
       "             'FW-AT+NN-TL': 13,\n",
       "             'FW-AT+NP-TL': 2,\n",
       "             'FW-AT-HL': 1,\n",
       "             'FW-AT-TL': 44,\n",
       "             'FW-BE': 1,\n",
       "             'FW-BER': 3,\n",
       "             'FW-BEZ': 4,\n",
       "             'FW-CC': 27,\n",
       "             'FW-CC-TL': 14,\n",
       "             'FW-CD': 7,\n",
       "             'FW-CD-TL': 2,\n",
       "             'FW-CS': 3,\n",
       "             'FW-DT': 2,\n",
       "             'FW-DT+BEZ': 2,\n",
       "             'FW-DTS': 1,\n",
       "             'FW-HV': 1,\n",
       "             'FW-IN': 84,\n",
       "             'FW-IN+AT': 4,\n",
       "             'FW-IN+AT-T': 3,\n",
       "             'FW-IN+AT-TL': 18,\n",
       "             'FW-IN+NN': 5,\n",
       "             'FW-IN+NN-TL': 2,\n",
       "             'FW-IN+NP-TL': 2,\n",
       "             'FW-IN-TL': 40,\n",
       "             'FW-JJ': 53,\n",
       "             'FW-JJ-NC': 2,\n",
       "             'FW-JJ-TL': 74,\n",
       "             'FW-JJR': 1,\n",
       "             'FW-JJT': 1,\n",
       "             'FW-NN': 288,\n",
       "             'FW-NN$': 9,\n",
       "             'FW-NN$-TL': 4,\n",
       "             'FW-NN-NC': 6,\n",
       "             'FW-NN-TL': 170,\n",
       "             'FW-NN-TL-NC': 1,\n",
       "             'FW-NNS': 83,\n",
       "             'FW-NNS-NC': 2,\n",
       "             'FW-NNS-TL': 36,\n",
       "             'FW-NP': 7,\n",
       "             'FW-NP-TL': 4,\n",
       "             'FW-NPS': 2,\n",
       "             'FW-NPS-TL': 1,\n",
       "             'FW-NR': 1,\n",
       "             'FW-NR-TL': 3,\n",
       "             'FW-OD-NC': 1,\n",
       "             'FW-OD-TL': 4,\n",
       "             'FW-PN': 1,\n",
       "             'FW-PP$': 3,\n",
       "             'FW-PP$-NC': 1,\n",
       "             'FW-PP$-TL': 2,\n",
       "             'FW-PPL': 9,\n",
       "             'FW-PPL+VBZ': 2,\n",
       "             'FW-PPO': 4,\n",
       "             'FW-PPO+IN': 3,\n",
       "             'FW-PPS': 1,\n",
       "             'FW-PPSS': 6,\n",
       "             'FW-PPSS+HV': 1,\n",
       "             'FW-QL': 1,\n",
       "             'FW-RB': 32,\n",
       "             'FW-RB+CC': 1,\n",
       "             'FW-RB-TL': 3,\n",
       "             'FW-TO+VB': 1,\n",
       "             'FW-UH': 8,\n",
       "             'FW-UH-NC': 1,\n",
       "             'FW-UH-TL': 1,\n",
       "             'FW-VB': 26,\n",
       "             'FW-VB-NC': 3,\n",
       "             'FW-VB-TL': 1,\n",
       "             'FW-VBD': 2,\n",
       "             'FW-VBD-TL': 1,\n",
       "             'FW-VBG': 7,\n",
       "             'FW-VBG-TL': 1,\n",
       "             'FW-VBN': 12,\n",
       "             'FW-VBZ': 4,\n",
       "             'FW-WDT': 16,\n",
       "             'FW-WPO': 1,\n",
       "             'FW-WPS': 1,\n",
       "             'HV': 3928,\n",
       "             'HV*': 42,\n",
       "             'HV+TO': 3,\n",
       "             'HV-HL': 3,\n",
       "             'HV-NC': 11,\n",
       "             'HV-TL': 3,\n",
       "             'HVD': 4895,\n",
       "             'HVD*': 99,\n",
       "             'HVD-HL': 1,\n",
       "             'HVG': 281,\n",
       "             'HVG-HL': 1,\n",
       "             'HVN': 237,\n",
       "             'HVZ': 2433,\n",
       "             'HVZ*': 22,\n",
       "             'HVZ-NC': 2,\n",
       "             'HVZ-TL': 4,\n",
       "             'IN': 120557,\n",
       "             'IN+IN': 1,\n",
       "             'IN+PPO': 1,\n",
       "             'IN-HL': 508,\n",
       "             'IN-NC': 41,\n",
       "             'IN-TL': 1477,\n",
       "             'IN-TL-HL': 6,\n",
       "             'JJ': 64028,\n",
       "             'JJ$-TL': 1,\n",
       "             'JJ+JJ-NC': 2,\n",
       "             'JJ-HL': 396,\n",
       "             'JJ-NC': 41,\n",
       "             'JJ-TL': 4107,\n",
       "             'JJ-TL-HL': 26,\n",
       "             'JJ-TL-NC': 1,\n",
       "             'JJR': 1958,\n",
       "             'JJR+CS': 1,\n",
       "             'JJR-HL': 17,\n",
       "             'JJR-NC': 5,\n",
       "             'JJR-TL': 15,\n",
       "             'JJS': 359,\n",
       "             'JJS-HL': 1,\n",
       "             'JJS-TL': 20,\n",
       "             'JJT': 1005,\n",
       "             'JJT-HL': 6,\n",
       "             'JJT-NC': 1,\n",
       "             'JJT-TL': 4,\n",
       "             'MD': 12431,\n",
       "             'MD*': 866,\n",
       "             'MD*-HL': 1,\n",
       "             'MD+HV': 7,\n",
       "             'MD+PPSS': 1,\n",
       "             'MD+TO': 2,\n",
       "             'MD-HL': 27,\n",
       "             'MD-NC': 2,\n",
       "             'MD-TL': 8,\n",
       "             'NIL': 157,\n",
       "             'NN': 152470,\n",
       "             'NN$': 1480,\n",
       "             'NN$-HL': 20,\n",
       "             'NN$-TL': 361,\n",
       "             'NN+BEZ': 34,\n",
       "             'NN+BEZ-TL': 2,\n",
       "             'NN+HVD-TL': 1,\n",
       "             'NN+HVZ': 5,\n",
       "             'NN+HVZ-TL': 1,\n",
       "             'NN+IN': 1,\n",
       "             'NN+MD': 2,\n",
       "             'NN+NN-NC': 1,\n",
       "             'NN-HL': 1471,\n",
       "             'NN-NC': 118,\n",
       "             'NN-TL': 13372,\n",
       "             'NN-TL-HL': 129,\n",
       "             'NN-TL-NC': 3,\n",
       "             'NNS': 55110,\n",
       "             'NNS$': 257,\n",
       "             'NNS$-HL': 4,\n",
       "             'NNS$-NC': 2,\n",
       "             'NNS$-TL': 74,\n",
       "             'NNS$-TL-HL': 1,\n",
       "             'NNS+MD': 2,\n",
       "             'NNS-HL': 609,\n",
       "             'NNS-NC': 26,\n",
       "             'NNS-TL': 2226,\n",
       "             'NNS-TL-HL': 14,\n",
       "             'NNS-TL-NC': 3,\n",
       "             'NP': 34476,\n",
       "             'NP$': 2565,\n",
       "             'NP$-HL': 8,\n",
       "             'NP$-TL': 141,\n",
       "             'NP+BEZ': 25,\n",
       "             'NP+BEZ-NC': 3,\n",
       "             'NP+HVZ': 6,\n",
       "             'NP+HVZ-NC': 1,\n",
       "             'NP+MD': 2,\n",
       "             'NP-HL': 517,\n",
       "             'NP-NC': 15,\n",
       "             'NP-TL': 4019,\n",
       "             'NP-TL-HL': 7,\n",
       "             'NPS': 1275,\n",
       "             'NPS$': 38,\n",
       "             'NPS$-HL': 1,\n",
       "             'NPS$-TL': 3,\n",
       "             'NPS-HL': 8,\n",
       "             'NPS-NC': 2,\n",
       "             'NPS-TL': 67,\n",
       "             'NR': 1566,\n",
       "             'NR$': 66,\n",
       "             'NR$-TL': 11,\n",
       "             'NR+MD': 1,\n",
       "             'NR-HL': 10,\n",
       "             'NR-NC': 4,\n",
       "             'NR-TL': 309,\n",
       "             'NR-TL-HL': 5,\n",
       "             'NRS': 16,\n",
       "             'NRS-TL': 1,\n",
       "             'OD': 1935,\n",
       "             'OD-HL': 8,\n",
       "             'OD-NC': 1,\n",
       "             'OD-TL': 201,\n",
       "             'PN': 2573,\n",
       "             'PN$': 89,\n",
       "             'PN+BEZ': 7,\n",
       "             'PN+HVD': 1,\n",
       "             'PN+HVZ': 3,\n",
       "             'PN+MD': 3,\n",
       "             'PN-HL': 2,\n",
       "             'PN-NC': 2,\n",
       "             'PN-TL': 5,\n",
       "             'PP$': 16872,\n",
       "             'PP$$': 164,\n",
       "             'PP$-HL': 10,\n",
       "             'PP$-NC': 13,\n",
       "             'PP$-TL': 35,\n",
       "             'PPL': 1233,\n",
       "             'PPL-HL': 1,\n",
       "             'PPL-NC': 2,\n",
       "             'PPL-TL': 1,\n",
       "             'PPLS': 345,\n",
       "             'PPO': 11181,\n",
       "             'PPO-HL': 5,\n",
       "             'PPO-NC': 9,\n",
       "             'PPO-TL': 13,\n",
       "             'PPS': 18253,\n",
       "             'PPS+BEZ': 430,\n",
       "             'PPS+BEZ-HL': 1,\n",
       "             'PPS+BEZ-NC': 3,\n",
       "             'PPS+HVD': 83,\n",
       "             'PPS+HVZ': 43,\n",
       "             'PPS+MD': 144,\n",
       "             'PPS-HL': 19,\n",
       "             'PPS-NC': 9,\n",
       "             'PPS-TL': 6,\n",
       "             'PPSS': 13802,\n",
       "             'PPSS+BEM': 270,\n",
       "             'PPSS+BER': 278,\n",
       "             'PPSS+BER-N': 1,\n",
       "             'PPSS+BER-NC': 1,\n",
       "             'PPSS+BER-TL': 1,\n",
       "             'PPSS+BEZ': 1,\n",
       "             'PPSS+BEZ*': 1,\n",
       "             'PPSS+HV': 241,\n",
       "             'PPSS+HV-TL': 1,\n",
       "             'PPSS+HVD': 83,\n",
       "             'PPSS+MD': 484,\n",
       "             'PPSS+MD-NC': 2,\n",
       "             'PPSS+VB': 2,\n",
       "             'PPSS-HL': 25,\n",
       "             'PPSS-NC': 31,\n",
       "             'PPSS-TL': 9,\n",
       "             'QL': 8735,\n",
       "             'QL-HL': 4,\n",
       "             'QL-NC': 2,\n",
       "             'QL-TL': 6,\n",
       "             'QLP': 261,\n",
       "             'RB': 36464,\n",
       "             'RB$': 9,\n",
       "             'RB+BEZ': 11,\n",
       "             'RB+BEZ-HL': 1,\n",
       "             'RB+BEZ-NC': 1,\n",
       "             'RB+CS': 3,\n",
       "             'RB-HL': 49,\n",
       "             'RB-NC': 26,\n",
       "             'RB-TL': 40,\n",
       "             'RBR': 1182,\n",
       "             'RBR+CS': 1,\n",
       "             'RBR-NC': 1,\n",
       "             'RBT': 101,\n",
       "             'RN': 9,\n",
       "             'RP': 6009,\n",
       "             'RP+IN': 4,\n",
       "             'RP-HL': 14,\n",
       "             'RP-NC': 5,\n",
       "             'RP-TL': 4,\n",
       "             'TO': 14918,\n",
       "             'TO+VB': 2,\n",
       "             'TO-HL': 55,\n",
       "             'TO-NC': 13,\n",
       "             'TO-TL': 10,\n",
       "             'UH': 608,\n",
       "             'UH-HL': 1,\n",
       "             'UH-NC': 5,\n",
       "             'UH-TL': 15,\n",
       "             'VB': 33693,\n",
       "             'VB+AT': 2,\n",
       "             'VB+IN': 3,\n",
       "             'VB+JJ-NC': 1,\n",
       "             'VB+PPO': 71,\n",
       "             'VB+RP': 2,\n",
       "             'VB+TO': 4,\n",
       "             'VB+VB-NC': 1,\n",
       "             'VB-HL': 125,\n",
       "             'VB-NC': 41,\n",
       "             'VB-TL': 96,\n",
       "             'VBD': 26167,\n",
       "             'VBD-HL': 8,\n",
       "             'VBD-NC': 11,\n",
       "             'VBD-TL': 6,\n",
       "             'VBG': 17893,\n",
       "             'VBG+TO': 17,\n",
       "             'VBG-HL': 146,\n",
       "             'VBG-NC': 16,\n",
       "             'VBG-TL': 133,\n",
       "             'VBN': 29186,\n",
       "             'VBN+TO': 5,\n",
       "             'VBN-HL': 137,\n",
       "             'VBN-NC': 9,\n",
       "             'VBN-TL': 591,\n",
       "             'VBN-TL-HL': 6,\n",
       "             'VBN-TL-NC': 3,\n",
       "             'VBZ': 7373,\n",
       "             'VBZ-HL': 72,\n",
       "             'VBZ-NC': 7,\n",
       "             'VBZ-TL': 17,\n",
       "             'WDT': 5539,\n",
       "             'WDT+BER': 1,\n",
       "             'WDT+BER+PP': 1,\n",
       "             'WDT+BEZ': 47,\n",
       "             'WDT+BEZ-HL': 1,\n",
       "             'WDT+BEZ-NC': 2,\n",
       "             'WDT+BEZ-TL': 1,\n",
       "             'WDT+DO+PPS': 1,\n",
       "             'WDT+DOD': 1,\n",
       "             'WDT+HVZ': 2,\n",
       "             'WDT-HL': 30,\n",
       "             'WDT-NC': 7,\n",
       "             'WP$': 252,\n",
       "             'WPO': 280,\n",
       "             'WPO-NC': 1,\n",
       "             'WPO-TL': 4,\n",
       "             'WPS': 3924,\n",
       "             'WPS+BEZ': 21,\n",
       "             'WPS+BEZ-NC': 2,\n",
       "             'WPS+BEZ-TL': 1,\n",
       "             'WPS+HVD': 6,\n",
       "             'WPS+HVZ': 2,\n",
       "             'WPS+MD': 8,\n",
       "             'WPS-HL': 2,\n",
       "             'WPS-NC': 3,\n",
       "             'WPS-TL': 12,\n",
       "             'WQL': 176,\n",
       "             'WQL-TL': 5,\n",
       "             'WRB': 4509,\n",
       "             'WRB+BER': 1,\n",
       "             'WRB+BEZ': 11,\n",
       "             'WRB+BEZ-TL': 3,\n",
       "             'WRB+DO': 1,\n",
       "             'WRB+DOD': 6,\n",
       "             'WRB+DOD*': 1,\n",
       "             'WRB+DOZ': 1,\n",
       "             'WRB+IN': 1,\n",
       "             'WRB+MD': 1,\n",
       "             'WRB-HL': 36,\n",
       "             'WRB-NC': 7,\n",
       "             'WRB-TL': 9,\n",
       "             '``': 8837})"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('WDT+BER+PP', 1),\n",
       " ('DOD*-TL', 1),\n",
       " ('NN+HVZ-TL', 1),\n",
       " ('FW-QL', 1),\n",
       " ('WRB+DOD*', 1),\n",
       " ('WDT+DO+PPS', 1),\n",
       " ('FW-RB+CC', 1),\n",
       " ('RB+BEZ-NC', 1),\n",
       " ('NN+HVD-TL', 1),\n",
       " ('JJR+CS', 1),\n",
       " ('PPSS+BER-TL', 1),\n",
       " ('JJ$-TL', 1),\n",
       " ('JJ-TL-NC', 1),\n",
       " ('PN+HVD', 1),\n",
       " ('WDT+DOD', 1),\n",
       " ('PPSS+BEZ*', 1),\n",
       " ('FW-TO+VB', 1),\n",
       " ('WRB+DOZ', 1),\n",
       " ('PPL-TL', 1),\n",
       " ('FW-UH-NC', 1),\n",
       " ('BER*-NC', 1),\n",
       " ('AP+AP-NC', 1),\n",
       " ('IN+PPO', 1),\n",
       " ('PPSS+BER-N', 1),\n",
       " ('WPS+BEZ-TL', 1),\n",
       " ('WPO-NC', 1),\n",
       " ('JJT-NC', 1),\n",
       " ('PPL-HL', 1),\n",
       " ('JJS-HL', 1),\n",
       " ('RBR-NC', 1),\n",
       " ('NPS$-HL', 1),\n",
       " ('MD+PPSS', 1),\n",
       " ('WRB+IN', 1),\n",
       " ('FW-UH-TL', 1),\n",
       " ('FW-HV', 1),\n",
       " ('NN+IN', 1),\n",
       " ('PPSS+BER-NC', 1),\n",
       " ('BE-TL', 1),\n",
       " ('VB+JJ-NC', 1),\n",
       " ('WDT+BER', 1),\n",
       " ('FW-WPS', 1),\n",
       " ('DO+PPSS', 1),\n",
       " ('DOZ*-TL', 1),\n",
       " ('NP+HVZ-NC', 1),\n",
       " ('*-TL', 1),\n",
       " ('NN+NN-NC', 1),\n",
       " ('FW-JJR', 1),\n",
       " ('DT+BEZ-NC', 1),\n",
       " ('FW-NPS-TL', 1),\n",
       " ('RB+BEZ-HL', 1),\n",
       " ('NNS$-TL-HL', 1),\n",
       " ('HVG-HL', 1),\n",
       " ('PPSS+BEZ', 1),\n",
       " ('VB+VB-NC', 1),\n",
       " ('EX-HL', 1),\n",
       " ('FW-PPS', 1),\n",
       " ('WRB+BER', 1),\n",
       " ('FW-VB-TL', 1),\n",
       " ('IN+IN', 1),\n",
       " ('DOD-NC', 1),\n",
       " ('FW-PPSS+HV', 1),\n",
       " ('OD-NC', 1),\n",
       " ('MD*-HL', 1),\n",
       " ('PPSS+HV-TL', 1),\n",
       " ('ABN-NC', 1),\n",
       " ('FW-WPO', 1),\n",
       " ('EX-NC', 1),\n",
       " ('FW-PP$-NC', 1),\n",
       " ('HVD-HL', 1),\n",
       " ('FW-JJT', 1),\n",
       " ('WRB+DO', 1),\n",
       " ('FW-VBG-TL', 1),\n",
       " ('FW-AT-HL', 1),\n",
       " ('FW-OD-NC', 1),\n",
       " ('BEDZ-HL', 1),\n",
       " ('WRB+MD', 1),\n",
       " ('NRS-TL', 1),\n",
       " ('FW-NN-TL-NC', 1),\n",
       " ('FW-DTS', 1),\n",
       " ('NR+MD', 1),\n",
       " ('WDT+BEZ-HL', 1),\n",
       " ('WDT+BEZ-TL', 1),\n",
       " ('FW-PN', 1),\n",
       " ('FW-VBD-TL', 1),\n",
       " ('UH-HL', 1),\n",
       " ('PPS+BEZ-HL', 1),\n",
       " ('FW-NR', 1),\n",
       " ('FW-BE', 1),\n",
       " ('RBR+CS', 1),\n",
       " ('*-NC', 1),\n",
       " ('EX+HVZ', 2),\n",
       " ('NN+BEZ-TL', 2),\n",
       " ('CS-TL', 2),\n",
       " ('WPS-HL', 2),\n",
       " ('DTS+BEZ', 2),\n",
       " ('FW-*-TL', 2),\n",
       " ('FW-CD-TL', 2),\n",
       " ('MD+TO', 2),\n",
       " ('FW-PPL+VBZ', 2),\n",
       " ('AP-NC', 2),\n",
       " ('MD-NC', 2),\n",
       " ('WDT+HVZ', 2),\n",
       " ('DTS-HL', 2),\n",
       " ('PPL-NC', 2),\n",
       " ('VB+RP', 2),\n",
       " ('FW-AT+NP-TL', 2),\n",
       " ('FW-JJ-NC', 2),\n",
       " ('NNS$-NC', 2),\n",
       " ('WPS+HVZ', 2),\n",
       " ('BEM-NC', 2),\n",
       " ('VB+AT', 2),\n",
       " ('.-TL', 2),\n",
       " ('FW-PP$-TL', 2),\n",
       " ('FW-VBD', 2),\n",
       " ('NPS-NC', 2),\n",
       " ('NN+MD', 2),\n",
       " ('DOZ-TL', 2),\n",
       " ('HVZ-NC', 2),\n",
       " ('CC-TL-HL', 2),\n",
       " ('NP+MD', 2),\n",
       " ('TO+VB', 2),\n",
       " ('PPSS+MD-NC', 2),\n",
       " ('FW-NPS', 2),\n",
       " ('QL-NC', 2),\n",
       " ('WDT+BEZ-NC', 2),\n",
       " ('FW-IN+NP-TL', 2),\n",
       " ('WPS+BEZ-NC', 2),\n",
       " ('NNS+MD', 2),\n",
       " ('FW-NNS-NC', 2),\n",
       " ('JJ+JJ-NC', 2),\n",
       " ('FW-DT', 2),\n",
       " ('PPSS+VB', 2),\n",
       " ('DTI-TL', 2),\n",
       " ('FW-DT+BEZ', 2),\n",
       " ('PN-NC', 2),\n",
       " ('DO-NC', 2),\n",
       " ('PN-HL', 2),\n",
       " ('BEN-TL', 2),\n",
       " ('FW-IN+NN-TL', 2),\n",
       " ('HV-HL', 3),\n",
       " ('NN-TL-NC', 3),\n",
       " ('NNS-TL-NC', 3),\n",
       " ('FW-CS', 3),\n",
       " ('DT+MD', 3),\n",
       " ('FW-RB-TL', 3),\n",
       " ('EX+HVD', 3),\n",
       " ('PN+MD', 3),\n",
       " ('FW-VB-NC', 3),\n",
       " ('VB+IN', 3),\n",
       " ('BED-NC', 3),\n",
       " ('PN+HVZ', 3),\n",
       " ('PPS+BEZ-NC', 3),\n",
       " ('FW-IN+AT-T', 3),\n",
       " ('WRB+BEZ-TL', 3),\n",
       " ('HV-TL', 3),\n",
       " ('NP+BEZ-NC', 3),\n",
       " ('WPS-NC', 3),\n",
       " ('FW-NR-TL', 3),\n",
       " ('VBN-TL-NC', 3),\n",
       " ('FW-BER', 3),\n",
       " ('RB+CS', 3),\n",
       " ('DO*-HL', 3),\n",
       " ('HV+TO', 3),\n",
       " ('FW-PP$', 3),\n",
       " ('FW-PPO+IN', 3),\n",
       " ('NPS$-TL', 3),\n",
       " ('FW-IN+AT', 4),\n",
       " ('FW-NN$-TL', 4),\n",
       " ('FW-OD-TL', 4),\n",
       " ('VB+TO', 4),\n",
       " ('HVZ-TL', 4),\n",
       " ('ABN-HL', 4),\n",
       " ('FW-VBZ', 4),\n",
       " (',-TL', 4),\n",
       " ('EX+MD', 4),\n",
       " ('QL-HL', 4),\n",
       " ('RP-TL', 4),\n",
       " ('DO-HL', 4),\n",
       " ('NR-NC', 4),\n",
       " ('NNS$-HL', 4),\n",
       " ('FW-NP-TL', 4),\n",
       " ('FW-PPO', 4),\n",
       " ('RP+IN', 4),\n",
       " ('WPO-TL', 4),\n",
       " ('FW-BEZ', 4),\n",
       " ('JJT-TL', 4),\n",
       " ('RP-NC', 5),\n",
       " ('BEZ-NC', 5),\n",
       " ('NR-TL-HL', 5),\n",
       " ('BER-NC', 5),\n",
       " ('CS-NC', 5),\n",
       " ('AT-TL-HL', 5),\n",
       " ('PPO-HL', 5),\n",
       " ('UH-NC', 5),\n",
       " ('CD-NC', 5),\n",
       " ('CC-NC', 5),\n",
       " ('JJR-NC', 5),\n",
       " ('VBN+TO', 5),\n",
       " ('NN+HVZ', 5),\n",
       " ('PN-TL', 5),\n",
       " ('CD$', 5),\n",
       " (',-NC', 5),\n",
       " ('DT$', 5),\n",
       " ('WQL-TL', 5),\n",
       " ('FW-IN+NN', 5),\n",
       " ('DO-TL', 5),\n",
       " ('NP+HVZ', 6),\n",
       " ('VBD-TL', 6),\n",
       " ('DT-HL', 6),\n",
       " ('JJT-HL', 6),\n",
       " ('DTI-HL', 6),\n",
       " ('IN-TL-HL', 6),\n",
       " ('WPS+HVD', 6),\n",
       " ('FW-*', 6),\n",
       " ('FW-NN-NC', 6),\n",
       " ('FW-PPSS', 6),\n",
       " ('PPS-TL', 6),\n",
       " ('WRB+DOD', 6),\n",
       " ('QL-TL', 6),\n",
       " ('VBN-TL-HL', 6),\n",
       " ('BER-TL', 6),\n",
       " ('WDT-NC', 7),\n",
       " ('DT-NC', 7),\n",
       " ('PN+BEZ', 7),\n",
       " ('NP-TL-HL', 7),\n",
       " ('WRB-NC', 7),\n",
       " ('ABN-TL', 7),\n",
       " ('FW-NP', 7),\n",
       " ('VBZ-NC', 7),\n",
       " ('MD+HV', 7),\n",
       " ('FW-VBG', 7),\n",
       " ('FW-CD', 7),\n",
       " ('FW-UH', 8),\n",
       " ('BEDZ-NC', 8),\n",
       " ('WPS+MD', 8),\n",
       " ('NPS-HL', 8),\n",
       " ('*-HL', 8),\n",
       " ('NP$-HL', 8),\n",
       " ('MD-TL', 8),\n",
       " ('OD-HL', 8),\n",
       " ('BEZ-TL', 8),\n",
       " ('VBD-HL', 8),\n",
       " ('VBN-NC', 9),\n",
       " ('AP$', 9),\n",
       " ('PPO-NC', 9),\n",
       " ('RN', 9),\n",
       " ('DT-TL', 9),\n",
       " ('FW-PPL', 9),\n",
       " ('PPSS-TL', 9),\n",
       " ('FW-NN$', 9),\n",
       " ('BEM*', 9),\n",
       " ('WRB-TL', 9),\n",
       " ('RB$', 9),\n",
       " ('PPS-NC', 9),\n",
       " ('PP$-HL', 10),\n",
       " ('NR-HL', 10),\n",
       " ('TO-TL', 10),\n",
       " ('WRB+BEZ', 11),\n",
       " ('RB+BEZ', 11),\n",
       " ('VBD-NC', 11),\n",
       " ('BER-HL', 11),\n",
       " ('NR$-TL', 11),\n",
       " ('HV-NC', 11),\n",
       " ('FW-VBN', 12),\n",
       " ('WPS-TL', 12),\n",
       " ('PPO-TL', 13),\n",
       " ('TO-NC', 13),\n",
       " ('BE-HL', 13),\n",
       " ('FW-AT+NN-TL', 13),\n",
       " ('PP$-NC', 13),\n",
       " ('RP-HL', 14),\n",
       " ('FW-CC-TL', 14),\n",
       " ('NNS-TL-HL', 14),\n",
       " ('NP-NC', 15),\n",
       " ('JJR-TL', 15),\n",
       " ('UH-TL', 15),\n",
       " ('.-NC', 16),\n",
       " ('VBG-NC', 16),\n",
       " ('NRS', 16),\n",
       " ('FW-WDT', 16),\n",
       " ('DOZ-HL', 16),\n",
       " ('JJR-HL', 17),\n",
       " ('CD-TL-HL', 17),\n",
       " ('VBZ-TL', 17),\n",
       " ('VBG+TO', 17),\n",
       " ('FW-IN+AT-TL', 18),\n",
       " ('AP-TL', 18),\n",
       " ('PPS-HL', 19),\n",
       " ('NN$-HL', 20),\n",
       " ('JJS-TL', 20),\n",
       " ('WPS+BEZ', 21),\n",
       " (':-TL', 22),\n",
       " ('BED*', 22),\n",
       " ('HVZ*', 22),\n",
       " ('FW-AT', 24),\n",
       " ('PPSS-HL', 25),\n",
       " ('CS-HL', 25),\n",
       " ('NP+BEZ', 25),\n",
       " ('JJ-TL-HL', 26),\n",
       " ('NNS-NC', 26),\n",
       " ('FW-VB', 26),\n",
       " ('---HL', 26),\n",
       " ('RB-NC', 26),\n",
       " ('FW-CC', 27),\n",
       " ('MD-HL', 27),\n",
       " ('WDT-HL', 30),\n",
       " ('BEZ-HL', 30),\n",
       " ('PPSS-NC', 31),\n",
       " ('FW-RB', 32),\n",
       " ('NN+BEZ', 34),\n",
       " ('PP$-TL', 35),\n",
       " ('AT-NC', 35),\n",
       " ('FW-NNS-TL', 36),\n",
       " ('WRB-HL', 36),\n",
       " ('NPS$', 38),\n",
       " ('FW-IN-TL', 40),\n",
       " ('RB-TL', 40),\n",
       " ('AP-HL', 40),\n",
       " ('IN-NC', 41),\n",
       " ('VB-NC', 41),\n",
       " ('JJ-NC', 41),\n",
       " ('HV*', 42),\n",
       " ('PPS+HVZ', 43),\n",
       " ('FW-AT-TL', 44),\n",
       " ('WDT+BEZ', 47),\n",
       " ('BER*', 47),\n",
       " ('RB-HL', 49),\n",
       " ('FW-JJ', 53),\n",
       " ('TO-HL', 55),\n",
       " ('NR$', 66),\n",
       " ('NPS-TL', 67),\n",
       " ('VB+PPO', 71),\n",
       " ('VBZ-HL', 72),\n",
       " ('FW-JJ-TL', 74),\n",
       " ('NNS$-TL', 74),\n",
       " ('PPS+HVD', 83),\n",
       " ('FW-NNS', 83),\n",
       " ('PPSS+HVD', 83),\n",
       " ('FW-IN', 84),\n",
       " ('PN$', 89),\n",
       " ('DOZ*', 89),\n",
       " ('VB-TL', 96),\n",
       " ('HVD*', 99),\n",
       " ('RBT', 101),\n",
       " ('DTX', 104),\n",
       " ('EX+BEZ', 105),\n",
       " ('BEZ*', 117),\n",
       " ('NN-NC', 118),\n",
       " ('CC-HL', 119),\n",
       " ('VB-HL', 125),\n",
       " ('NN-TL-HL', 129),\n",
       " ('VBG-TL', 133),\n",
       " ('VBN-HL', 137),\n",
       " (':-HL', 138),\n",
       " ('NP$-TL', 141),\n",
       " ('PPS+MD', 144),\n",
       " ('VBG-HL', 146),\n",
       " ('BEDZ*', 154),\n",
       " ('NIL', 157),\n",
       " ('(-HL', 162),\n",
       " ('PP$$', 164),\n",
       " ('FW-NN-TL', 170),\n",
       " (',-HL', 171),\n",
       " ('WQL', 176),\n",
       " ('DT+BEZ', 179),\n",
       " (')-HL', 184),\n",
       " ('OD-TL', 201),\n",
       " ('BEM', 226),\n",
       " ('HVN', 237),\n",
       " ('PPSS+HV', 241),\n",
       " ('WP$', 252),\n",
       " ('NNS$', 257),\n",
       " ('QLP', 261),\n",
       " ('PPSS+BEM', 270),\n",
       " ('PPSS+BER', 278),\n",
       " ('WPO', 280),\n",
       " ('HVG', 281),\n",
       " ('FW-NN', 288),\n",
       " ('CC-TL', 307),\n",
       " ('NR-TL', 309),\n",
       " (\"'\", 317),\n",
       " ('AT-HL', 332),\n",
       " ('PPLS', 345),\n",
       " ('ABL', 357),\n",
       " ('JJS', 359),\n",
       " ('NN$-TL', 361),\n",
       " ('JJ-HL', 396),\n",
       " ('DOD*', 402),\n",
       " ('PPS+BEZ', 430),\n",
       " ('CD-HL', 444),\n",
       " ('DOZ', 467),\n",
       " ('PPSS+MD', 484),\n",
       " ('DO*', 485),\n",
       " ('IN-HL', 508),\n",
       " ('NP-HL', 517),\n",
       " ('VBN-TL', 591),\n",
       " ('.-HL', 598),\n",
       " ('UH', 608),\n",
       " ('NNS-HL', 609),\n",
       " ('BEG', 686),\n",
       " ('ABX', 730),\n",
       " ('AT-TL', 746),\n",
       " ('MD*', 866),\n",
       " ('CD-TL', 898),\n",
       " ('JJT', 1005),\n",
       " ('DOD', 1047),\n",
       " ('RBR', 1182),\n",
       " ('PPL', 1233),\n",
       " ('NPS', 1275),\n",
       " ('DO', 1353),\n",
       " ('NN-HL', 1471),\n",
       " ('IN-TL', 1477),\n",
       " ('NN$', 1480),\n",
       " (':', 1558),\n",
       " ('NR', 1566),\n",
       " ('OD', 1935),\n",
       " ('JJR', 1958),\n",
       " ('EX', 2164),\n",
       " ('NNS-TL', 2226),\n",
       " ('(', 2264),\n",
       " (')', 2273),\n",
       " ('HVZ', 2433),\n",
       " ('DTS', 2435),\n",
       " ('BEN', 2470),\n",
       " ('NP$', 2565),\n",
       " ('PN', 2573),\n",
       " ('DTI', 2921),\n",
       " ('ABN', 3010),\n",
       " ('BED', 3282),\n",
       " ('--', 3405),\n",
       " ('WPS', 3924),\n",
       " ('HV', 3928),\n",
       " ('NP-TL', 4019),\n",
       " ('JJ-TL', 4107),\n",
       " ('BER', 4379),\n",
       " ('WRB', 4509),\n",
       " ('*', 4603),\n",
       " ('HVD', 4895),\n",
       " ('WDT', 5539),\n",
       " ('RP', 6009),\n",
       " ('BE', 6360),\n",
       " ('VBZ', 7373),\n",
       " ('QL', 8735),\n",
       " (\"''\", 8789),\n",
       " ('``', 8837),\n",
       " ('DT', 8957),\n",
       " ('AP', 9522),\n",
       " ('BEDZ', 9806),\n",
       " ('BEZ', 10066),\n",
       " ('PPO', 11181),\n",
       " ('MD', 12431),\n",
       " ('NN-TL', 13372),\n",
       " ('CD', 13510),\n",
       " ('PPSS', 13802),\n",
       " ('TO', 14918),\n",
       " ('PP$', 16872),\n",
       " ('VBG', 17893),\n",
       " ('PPS', 18253),\n",
       " ('CS', 22143),\n",
       " ('VBD', 26167),\n",
       " ('VBN', 29186),\n",
       " ('VB', 33693),\n",
       " ('NP', 34476),\n",
       " ('RB', 36464),\n",
       " ('CC', 37718),\n",
       " ('NNS', 55110),\n",
       " (',', 58156),\n",
       " ('.', 60638),\n",
       " ('JJ', 64028),\n",
       " ('AT', 97959),\n",
       " ('IN', 120557),\n",
       " ('NN', 152470)]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(tc.items(), key=lambda x: x[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "472"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(tc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have **472 unique tags**. As we've seen, some of these tags are very rare and thus may be complicated to predict by our simple HMM model, hindering its accuracy.\n",
    "\n",
    "Let's check what they mean to see if we can find a logical way to reduce their number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(: opening parenthesis\n",
      "    (\n",
      "): closing parenthesis\n",
      "    )\n",
      "*: negator\n",
      "    not n't\n",
      ",: comma\n",
      "    ,\n",
      "--: dash\n",
      "    --\n",
      ".: sentence terminator\n",
      "    . ? ; ! :\n",
      ":: colon\n",
      "    :\n",
      "ABL: determiner/pronoun, pre-qualifier\n",
      "    quite such rather\n",
      "ABN: determiner/pronoun, pre-quantifier\n",
      "    all half many nary\n",
      "ABX: determiner/pronoun, double conjunction or pre-quantifier\n",
      "    both\n",
      "AP: determiner/pronoun, post-determiner\n",
      "    many other next more last former little several enough most least only\n",
      "    very few fewer past same Last latter less single plenty 'nough lesser\n",
      "    certain various manye next-to-last particular final previous present\n",
      "    nuf\n",
      "AP$: determiner/pronoun, post-determiner, genitive\n",
      "    other's\n",
      "AP+AP: determiner/pronoun, post-determiner, hyphenated pair\n",
      "    many-much\n",
      "AT: article\n",
      "    the an no a every th' ever' ye\n",
      "BE: verb 'to be', infinitive or imperative\n",
      "    be\n",
      "BED: verb 'to be', past tense, 2nd person singular or all persons plural\n",
      "    were\n",
      "BED*: verb 'to be', past tense, 2nd person singular or all persons plural, negated\n",
      "    weren't\n",
      "BEDZ: verb 'to be', past tense, 1st and 3rd person singular\n",
      "    was\n",
      "BEDZ*: verb 'to be', past tense, 1st and 3rd person singular, negated\n",
      "    wasn't\n",
      "BEG: verb 'to be', present participle or gerund\n",
      "    being\n",
      "BEM: verb 'to be', present tense, 1st person singular\n",
      "    am\n",
      "BEM*: verb 'to be', present tense, 1st person singular, negated\n",
      "    ain't\n",
      "BEN: verb 'to be', past participle\n",
      "    been\n",
      "BER: verb 'to be', present tense, 2nd person singular or all persons plural\n",
      "    are art\n",
      "BER*: verb 'to be', present tense, 2nd person singular or all persons plural, negated\n",
      "    aren't ain't\n",
      "BEZ: verb 'to be', present tense, 3rd person singular\n",
      "    is\n",
      "BEZ*: verb 'to be', present tense, 3rd person singular, negated\n",
      "    isn't ain't\n",
      "CC: conjunction, coordinating\n",
      "    and or but plus & either neither nor yet 'n' and/or minus an'\n",
      "CD: numeral, cardinal\n",
      "    two one 1 four 2 1913 71 74 637 1937 8 five three million 87-31 29-5\n",
      "    seven 1,119 fifty-three 7.5 billion hundred 125,000 1,700 60 100 six\n",
      "    ...\n",
      "CD$: numeral, cardinal, genitive\n",
      "    1960's 1961's .404's\n",
      "CS: conjunction, subordinating\n",
      "    that as after whether before while like because if since for than altho\n",
      "    until so unless though providing once lest s'posin' till whereas\n",
      "    whereupon supposing tho' albeit then so's 'fore\n",
      "DO: verb 'to do', uninflected present tense, infinitive or imperative\n",
      "    do dost\n",
      "DO*: verb 'to do', uninflected present tense or imperative, negated\n",
      "    don't\n",
      "DO+PPSS: verb 'to do', past or present tense + pronoun, personal, nominative, not 3rd person singular\n",
      "    d'you\n",
      "DOD: verb 'to do', past tense\n",
      "    did done\n",
      "DOD*: verb 'to do', past tense, negated\n",
      "    didn't\n",
      "DOZ: verb 'to do', present tense, 3rd person singular\n",
      "    does\n",
      "DOZ*: verb 'to do', present tense, 3rd person singular, negated\n",
      "    doesn't don't\n",
      "DT: determiner/pronoun, singular\n",
      "    this each another that 'nother\n",
      "DT$: determiner/pronoun, singular, genitive\n",
      "    another's\n",
      "DT+BEZ: determiner/pronoun + verb 'to be', present tense, 3rd person singular\n",
      "    that's\n",
      "DT+MD: determiner/pronoun + modal auxillary\n",
      "    that'll this'll\n",
      "DTI: determiner/pronoun, singular or plural\n",
      "    any some\n",
      "DTS: determiner/pronoun, plural\n",
      "    these those them\n",
      "DTS+BEZ: pronoun, plural + verb 'to be', present tense, 3rd person singular\n",
      "    them's\n",
      "DTX: determiner, pronoun or double conjunction\n",
      "    neither either one\n",
      "EX: existential there\n",
      "    there\n",
      "EX+BEZ: existential there + verb 'to be', present tense, 3rd person singular\n",
      "    there's\n",
      "EX+HVD: existential there + verb 'to have', past tense\n",
      "    there'd\n",
      "EX+HVZ: existential there + verb 'to have', present tense, 3rd person singular\n",
      "    there's\n",
      "EX+MD: existential there + modal auxillary\n",
      "    there'll there'd\n",
      "FW-*: foreign word: negator\n",
      "    pas non ne\n",
      "FW-AT: foreign word: article\n",
      "    la le el un die der ein keine eine das las les Il\n",
      "FW-AT+NN: foreign word: article + noun, singular, common\n",
      "    l'orchestre l'identite l'arcade l'ange l'assistance l'activite\n",
      "    L'Universite l'independance L'Union L'Unita l'osservatore\n",
      "FW-AT+NP: foreign word: article + noun, singular, proper\n",
      "    L'Astree L'Imperiale\n",
      "FW-BE: foreign word: verb 'to be', infinitive or imperative\n",
      "    sit\n",
      "FW-BER: foreign word: verb 'to be', present tense, 2nd person singular or all persons plural\n",
      "    sind sunt etes\n",
      "FW-BEZ: foreign word: verb 'to be', present tense, 3rd person singular\n",
      "    ist est\n",
      "FW-CC: foreign word: conjunction, coordinating\n",
      "    et ma mais und aber och nec y\n",
      "FW-CD: foreign word: numeral, cardinal\n",
      "    une cinq deux sieben unam zwei\n",
      "FW-CS: foreign word: conjunction, subordinating\n",
      "    bevor quam ma\n",
      "FW-DT: foreign word: determiner/pronoun, singular\n",
      "    hoc\n",
      "FW-DT+BEZ: foreign word: determiner + verb 'to be', present tense, 3rd person singular\n",
      "    c'est\n",
      "FW-DTS: foreign word: determiner/pronoun, plural\n",
      "    haec\n",
      "FW-HV: foreign word: verb 'to have', present tense, not 3rd person singular\n",
      "    habe\n",
      "FW-IN: foreign word: preposition\n",
      "    ad de en a par con dans ex von auf super post sine sur sub avec per\n",
      "    inter sans pour pendant in di\n",
      "FW-IN+AT: foreign word: preposition + article\n",
      "    della des du aux zur d'un del dell'\n",
      "FW-IN+NN: foreign word: preposition + noun, singular, common\n",
      "    d'etat d'hotel d'argent d'identite d'art\n",
      "FW-IN+NP: foreign word: preposition + noun, singular, proper\n",
      "    d'Yquem d'Eiffel\n",
      "FW-JJ: foreign word: adjective\n",
      "    avant Espagnol sinfonica Siciliana Philharmonique grand publique haute\n",
      "    noire bouffe Douce meme humaine bel serieuses royaux anticus presto\n",
      "    Sovietskaya Bayerische comique schwarzen ...\n",
      "FW-JJR: foreign word: adjective, comparative\n",
      "    fortiori\n",
      "FW-JJT: foreign word: adjective, superlative\n",
      "    optimo\n",
      "FW-NN: foreign word: noun, singular, common\n",
      "    ballet esprit ersatz mano chatte goutte sang Fledermaus oud def kolkhoz\n",
      "    roi troika canto boite blutwurst carne muzyka bonheur monde piece force\n",
      "    ...\n",
      "FW-NN$: foreign word: noun, singular, common, genitive\n",
      "    corporis intellectus arte's dei aeternitatis senioritatis curiae\n",
      "    patronne's chambre's\n",
      "FW-NNS: foreign word: noun, plural, common\n",
      "    al culpas vopos boites haflis kolkhozes augen tyrannis alpha-beta-\n",
      "    gammas metis banditos rata phis negociants crus Einsatzkommandos\n",
      "    kamikaze wohaws sabinas zorrillas palazzi engages coureurs corroborees\n",
      "    yori Ubermenschen ...\n",
      "FW-NP: foreign word: noun, singular, proper\n",
      "    Karshilama Dieu Rundfunk Afrique Espanol Afrika Spagna Gott Carthago\n",
      "    deus\n",
      "FW-NPS: foreign word: noun, plural, proper\n",
      "    Svenskarna Atlantes Dieux\n",
      "FW-NR: foreign word: noun, singular, adverbial\n",
      "    heute morgen aujourd'hui hoy\n",
      "FW-OD: foreign word: numeral, ordinal\n",
      "    18e 17e quintus\n",
      "FW-PN: foreign word: pronoun, nominal\n",
      "    hoc\n",
      "FW-PP$: foreign word: determiner, possessive\n",
      "    mea mon deras vos\n",
      "FW-PPL: foreign word: pronoun, singular, reflexive\n",
      "    se\n",
      "FW-PPL+VBZ: foreign word: pronoun, singular, reflexive + verb, present tense, 3rd person singular\n",
      "    s'excuse s'accuse\n",
      "FW-PPO: pronoun, personal, accusative\n",
      "    lui me moi mi\n",
      "FW-PPO+IN: foreign word: pronoun, personal, accusative + preposition\n",
      "    mecum tecum\n",
      "FW-PPS: foreign word: pronoun, personal, nominative, 3rd person singular\n",
      "    il\n",
      "FW-PPSS: foreign word: pronoun, personal, nominative, not 3rd person singular\n",
      "    ich vous sie je\n",
      "FW-PPSS+HV: foreign word: pronoun, personal, nominative, not 3rd person singular + verb 'to have', present tense, not 3rd person singular\n",
      "    j'ai\n",
      "FW-QL: foreign word: qualifier\n",
      "    minus\n",
      "FW-RB: foreign word: adverb\n",
      "    bas assai deja um wiederum cito velociter vielleicht simpliciter non zu\n",
      "    domi nuper sic forsan olim oui semper tout despues hors\n",
      "FW-RB+CC: foreign word: adverb + conjunction, coordinating\n",
      "    forisque\n",
      "FW-TO+VB: foreign word: infinitival to + verb, infinitive\n",
      "    d'entretenir\n",
      "FW-UH: foreign word: interjection\n",
      "    sayonara bien adieu arigato bonjour adios bueno tchalo ciao o\n",
      "FW-VB: foreign word: verb, present tense, not 3rd person singular, imperative or infinitive\n",
      "    nolo contendere vive fermate faciunt esse vade noli tangere dites duces\n",
      "    meminisse iuvabit gosaimasu voulez habla ksu'u'peli'afo lacheln miuchi\n",
      "    say allons strafe portant\n",
      "FW-VBD: foreign word: verb, past tense\n",
      "    stabat peccavi audivi\n",
      "FW-VBG: foreign word: verb, present participle or gerund\n",
      "    nolens volens appellant seq. obliterans servanda dicendi delenda\n",
      "FW-VBN: foreign word: verb, past participle\n",
      "    vue verstrichen rasa verboten engages\n",
      "FW-VBZ: foreign word: verb, present tense, 3rd person singular\n",
      "    gouverne sinkt sigue diapiace\n",
      "FW-WDT: foreign word: WH-determiner\n",
      "    quo qua quod que quok\n",
      "FW-WPO: foreign word: WH-pronoun, accusative\n",
      "    quibusdam\n",
      "FW-WPS: foreign word: WH-pronoun, nominative\n",
      "    qui\n",
      "HV: verb 'to have', uninflected present tense, infinitive or imperative\n",
      "    have hast\n",
      "HV*: verb 'to have', uninflected present tense or imperative, negated\n",
      "    haven't ain't\n",
      "HV+TO: verb 'to have', uninflected present tense + infinitival to\n",
      "    hafta\n",
      "HVD: verb 'to have', past tense\n",
      "    had\n",
      "HVD*: verb 'to have', past tense, negated\n",
      "    hadn't\n",
      "HVG: verb 'to have', present participle or gerund\n",
      "    having\n",
      "HVN: verb 'to have', past participle\n",
      "    had\n",
      "HVZ: verb 'to have', present tense, 3rd person singular\n",
      "    has hath\n",
      "HVZ*: verb 'to have', present tense, 3rd person singular, negated\n",
      "    hasn't ain't\n",
      "IN: preposition\n",
      "    of in for by considering to on among at through with under into\n",
      "    regarding than since despite according per before toward against as\n",
      "    after during including between without except upon out over ...\n",
      "IN+IN: preposition, hyphenated pair\n",
      "    f'ovuh\n",
      "IN+PPO: preposition + pronoun, personal, accusative\n",
      "    t'hi-im\n",
      "JJ: adjective\n",
      "    ecent over-all possible hard-fought favorable hard meager fit such\n",
      "    widespread outmoded inadequate ambiguous grand clerical effective\n",
      "    orderly federal foster general proportionate ...\n",
      "JJ$: adjective, genitive\n",
      "    Great's\n",
      "JJ+JJ: adjective, hyphenated pair\n",
      "    big-large long-far\n",
      "JJR: adjective, comparative\n",
      "    greater older further earlier later freer franker wider better deeper\n",
      "    firmer tougher faster higher bigger worse younger lighter nicer slower\n",
      "    happier frothier Greater newer Elder ...\n",
      "JJR+CS: adjective + conjunction, coordinating\n",
      "    lighter'n\n",
      "JJS: adjective, semantically superlative\n",
      "    top chief principal northernmost master key head main tops utmost\n",
      "    innermost foremost uppermost paramount topmost\n",
      "JJT: adjective, superlative\n",
      "    best largest coolest calmest latest greatest earliest simplest\n",
      "    strongest newest fiercest unhappiest worst youngest worthiest fastest\n",
      "    hottest fittest lowest finest smallest staunchest ...\n",
      "MD: modal auxillary\n",
      "    should may might will would must can could shall ought need wilt\n",
      "MD*: modal auxillary, negated\n",
      "    cannot couldn't wouldn't can't won't shouldn't shan't mustn't musn't\n",
      "MD+HV: modal auxillary + verb 'to have', uninflected form\n",
      "    shouldda musta coulda must've woulda could've\n",
      "MD+PPSS: modal auxillary + pronoun, personal, nominative, not 3rd person singular\n",
      "    willya\n",
      "MD+TO: modal auxillary + infinitival to\n",
      "    oughta\n",
      "NN: noun, singular, common\n",
      "    failure burden court fire appointment awarding compensation Mayor\n",
      "    interim committee fact effect airport management surveillance jail\n",
      "    doctor intern extern night weekend duty legislation Tax Office ...\n",
      "NN$: noun, singular, common, genitive\n",
      "    season's world's player's night's chapter's golf's football's\n",
      "    baseball's club's U.'s coach's bride's bridegroom's board's county's\n",
      "    firm's company's superintendent's mob's Navy's ...\n",
      "NN+BEZ: noun, singular, common + verb 'to be', present tense, 3rd person singular\n",
      "    water's camera's sky's kid's Pa's heat's throat's father's money's\n",
      "    undersecretary's granite's level's wife's fat's Knife's fire's name's\n",
      "    hell's leg's sun's roulette's cane's guy's kind's baseball's ...\n",
      "NN+HVD: noun, singular, common + verb 'to have', past tense\n",
      "    Pa'd\n",
      "NN+HVZ: noun, singular, common + verb 'to have', present tense, 3rd person singular\n",
      "    guy's Knife's boat's summer's rain's company's\n",
      "NN+IN: noun, singular, common + preposition\n",
      "    buncha\n",
      "NN+MD: noun, singular, common + modal auxillary\n",
      "    cowhand'd sun'll\n",
      "NN+NN: noun, singular, common, hyphenated pair\n",
      "    stomach-belly\n",
      "NNS: noun, plural, common\n",
      "    irregularities presentments thanks reports voters laws legislators\n",
      "    years areas adjustments chambers $100 bonds courts sales details raises\n",
      "    sessions members congressmen votes polls calls ...\n",
      "NNS$: noun, plural, common, genitive\n",
      "    taxpayers' children's members' States' women's cutters' motorists'\n",
      "    steelmakers' hours' Nations' lawyers' prisoners' architects' tourists'\n",
      "    Employers' secretaries' Rogues' ...\n",
      "NNS+MD: noun, plural, common + modal auxillary\n",
      "    duds'd oystchers'll\n",
      "NP: noun, singular, proper\n",
      "    Fulton Atlanta September-October Durwood Pye Ivan Allen Jr. Jan.\n",
      "    Alpharetta Grady William B. Hartsfield Pearl Williams Aug. Berry J. M.\n",
      "    Cheshire Griffin Opelika Ala. E. Pelham Snodgrass ...\n",
      "NP$: noun, singular, proper, genitive\n",
      "    Green's Landis' Smith's Carreon's Allison's Boston's Spahn's Willie's\n",
      "    Mickey's Milwaukee's Mays' Howsam's Mantle's Shaw's Wagner's Rickey's\n",
      "    Shea's Palmer's Arnold's Broglio's ...\n",
      "NP+BEZ: noun, singular, proper + verb 'to be', present tense, 3rd person singular\n",
      "    W.'s Ike's Mack's Jack's Kate's Katharine's Black's Arthur's Seaton's\n",
      "    Buckhorn's Breed's Penny's Rob's Kitty's Blackwell's Myra's Wally's\n",
      "    Lucille's Springfield's Arlene's\n",
      "NP+HVZ: noun, singular, proper + verb 'to have', present tense, 3rd person singular\n",
      "    Bill's Guardino's Celie's Skolman's Crosson's Tim's Wally's\n",
      "NP+MD: noun, singular, proper + modal auxillary\n",
      "    Gyp'll John'll\n",
      "NPS: noun, plural, proper\n",
      "    Chases Aderholds Chapelles Armisteads Lockies Carbones French Marskmen\n",
      "    Toppers Franciscans Romans Cadillacs Masons Blacks Catholics British\n",
      "    Dixiecrats Mississippians Congresses ...\n",
      "NPS$: noun, plural, proper, genitive\n",
      "    Republicans' Orioles' Birds' Yanks' Redbirds' Bucs' Yankees' Stevenses'\n",
      "    Geraghtys' Burkes' Wackers' Achaeans' Dresbachs' Russians' Democrats'\n",
      "    Gershwins' Adventists' Negroes' Catholics' ...\n",
      "NR: noun, singular, adverbial\n",
      "    Friday home Wednesday Tuesday Monday Sunday Thursday yesterday tomorrow\n",
      "    tonight West East Saturday west left east downtown north northeast\n",
      "    southeast northwest North South right ...\n",
      "NR$: noun, singular, adverbial, genitive\n",
      "    Saturday's Monday's yesterday's tonight's tomorrow's Sunday's\n",
      "    Wednesday's Friday's today's Tuesday's West's Today's South's\n",
      "NR+MD: noun, singular, adverbial + modal auxillary\n",
      "    today'll\n",
      "NRS: noun, plural, adverbial\n",
      "    Sundays Mondays Saturdays Wednesdays Souths Fridays\n",
      "OD: numeral, ordinal\n",
      "    first 13th third nineteenth 2d 61st second sixth eighth ninth twenty-\n",
      "    first eleventh 50th eighteenth- Thirty-ninth 72nd 1/20th twentieth\n",
      "    mid-19th thousandth 350th sixteenth 701st ...\n",
      "PN: pronoun, nominal\n",
      "    none something everything one anyone nothing nobody everybody everyone\n",
      "    anybody anything someone no-one nothin\n",
      "PN$: pronoun, nominal, genitive\n",
      "    one's someone's anybody's nobody's everybody's anyone's everyone's\n",
      "PN+BEZ: pronoun, nominal + verb 'to be', present tense, 3rd person singular\n",
      "    nothing's everything's somebody's nobody's someone's\n",
      "PN+HVD: pronoun, nominal + verb 'to have', past tense\n",
      "    nobody'd\n",
      "PN+HVZ: pronoun, nominal + verb 'to have', present tense, 3rd person singular\n",
      "    nobody's somebody's one's\n",
      "PN+MD: pronoun, nominal + modal auxillary\n",
      "    someone'll somebody'll anybody'd\n",
      "PP$: determiner, possessive\n",
      "    our its his their my your her out thy mine thine\n",
      "PP$$: pronoun, possessive\n",
      "    ours mine his hers theirs yours\n",
      "PPL: pronoun, singular, reflexive\n",
      "    itself himself myself yourself herself oneself ownself\n",
      "PPLS: pronoun, plural, reflexive\n",
      "    themselves ourselves yourselves\n",
      "PPO: pronoun, personal, accusative\n",
      "    them it him me us you 'em her thee we'uns\n",
      "PPS: pronoun, personal, nominative, 3rd person singular\n",
      "    it he she thee\n",
      "PPS+BEZ: pronoun, personal, nominative, 3rd person singular + verb 'to be', present tense, 3rd person singular\n",
      "    it's he's she's\n",
      "PPS+HVD: pronoun, personal, nominative, 3rd person singular + verb 'to have', past tense\n",
      "    she'd he'd it'd\n",
      "PPS+HVZ: pronoun, personal, nominative, 3rd person singular + verb 'to have', present tense, 3rd person singular\n",
      "    it's he's she's\n",
      "PPS+MD: pronoun, personal, nominative, 3rd person singular + modal auxillary\n",
      "    he'll she'll it'll he'd it'd she'd\n",
      "PPSS: pronoun, personal, nominative, not 3rd person singular\n",
      "    they we I you ye thou you'uns\n",
      "PPSS+BEM: pronoun, personal, nominative, not 3rd person singular + verb 'to be', present tense, 1st person singular\n",
      "    I'm Ahm\n",
      "PPSS+BER: pronoun, personal, nominative, not 3rd person singular + verb 'to be', present tense, 2nd person singular or all persons plural\n",
      "    we're you're they're\n",
      "PPSS+BEZ: pronoun, personal, nominative, not 3rd person singular + verb 'to be', present tense, 3rd person singular\n",
      "    you's\n",
      "PPSS+BEZ*: pronoun, personal, nominative, not 3rd person singular + verb 'to be', present tense, 3rd person singular, negated\n",
      "    'tain't\n",
      "PPSS+HV: pronoun, personal, nominative, not 3rd person singular + verb 'to have', uninflected present tense\n",
      "    I've we've they've you've\n",
      "PPSS+HVD: pronoun, personal, nominative, not 3rd person singular + verb 'to have', past tense\n",
      "    I'd you'd we'd they'd\n",
      "PPSS+MD: pronoun, personal, nominative, not 3rd person singular + modal auxillary\n",
      "    you'll we'll I'll we'd I'd they'll they'd you'd\n",
      "PPSS+VB: pronoun, personal, nominative, not 3rd person singular + verb 'to verb', uninflected present tense\n",
      "    y'know\n",
      "QL: qualifier, pre\n",
      "    well less very most so real as highly fundamentally even how much\n",
      "    remarkably somewhat more completely too thus ill deeply little overly\n",
      "    halfway almost impossibly far severly such ...\n",
      "QLP: qualifier, post\n",
      "    indeed enough still 'nuff\n",
      "RB: adverb\n",
      "    only often generally also nevertheless upon together back newly no\n",
      "    likely meanwhile near then heavily there apparently yet outright fully\n",
      "    aside consistently specifically formally ever just ...\n",
      "RB$: adverb, genitive\n",
      "    else's\n",
      "RB+BEZ: adverb + verb 'to be', present tense, 3rd person singular\n",
      "    here's there's\n",
      "RB+CS: adverb + conjunction, coordinating\n",
      "    well's soon's\n",
      "RBR: adverb, comparative\n",
      "    further earlier better later higher tougher more harder longer sooner\n",
      "    less faster easier louder farther oftener nearer cheaper slower tighter\n",
      "    lower worse heavier quicker ...\n",
      "RBR+CS: adverb, comparative + conjunction, coordinating\n",
      "    more'n\n",
      "RBT: adverb, superlative\n",
      "    most best highest uppermost nearest brightest hardest fastest deepest\n",
      "    farthest loudest ...\n",
      "RN: adverb, nominal\n",
      "    here afar then\n",
      "RP: adverb, particle\n",
      "    up out off down over on in about through across after\n",
      "RP+IN: adverb, particle + preposition\n",
      "    out'n outta\n",
      "TO: infinitival to\n",
      "    to t'\n",
      "TO+VB: infinitival to + verb, infinitive\n",
      "    t'jawn t'lah\n",
      "UH: interjection\n",
      "    Hurrah bang whee hmpf ah goodbye oops oh-the-pain-of-it ha crunch say\n",
      "    oh why see well hello lo alas tarantara rum-tum-tum gosh hell keerist\n",
      "    Jesus Keeeerist boy c'mon 'mon goddamn bah hoo-pig damn ...\n",
      "VB: verb, base: uninflected present, imperative or infinitive\n",
      "    investigate find act follow inure achieve reduce take remedy re-set\n",
      "    distribute realize disable feel receive continue place protect\n",
      "    eliminate elaborate work permit run enter force ...\n",
      "VB+AT: verb, base: uninflected present or infinitive + article\n",
      "    wanna\n",
      "VB+IN: verb, base: uninflected present, imperative or infinitive + preposition\n",
      "    lookit\n",
      "VB+JJ: verb, base: uninflected present, imperative or infinitive + adjective\n",
      "    die-dead\n",
      "VB+PPO: verb, uninflected present tense + pronoun, personal, accusative\n",
      "    let's lemme gimme\n",
      "VB+RP: verb, imperative + adverbial particle\n",
      "    g'ahn c'mon\n",
      "VB+TO: verb, base: uninflected present, imperative or infinitive + infinitival to\n",
      "    wanta wanna\n",
      "VB+VB: verb, base: uninflected present, imperative or infinitive; hypenated pair\n",
      "    say-speak\n",
      "VBD: verb, past tense\n",
      "    said produced took recommended commented urged found added praised\n",
      "    charged listed became announced brought attended wanted voted defeated\n",
      "    received got stood shot scheduled feared promised made ...\n",
      "VBG: verb, present participle or gerund\n",
      "    modernizing improving purchasing Purchasing lacking enabling pricing\n",
      "    keeping getting picking entering voting warning making strengthening\n",
      "    setting neighboring attending participating moving ...\n",
      "VBG+TO: verb, present participle + infinitival to\n",
      "    gonna\n",
      "VBN: verb, past participle\n",
      "    conducted charged won received studied revised operated accepted\n",
      "    combined experienced recommended effected granted seen protected\n",
      "    adopted retarded notarized selected composed gotten printed ...\n",
      "VBN+TO: verb, past participle + infinitival to\n",
      "    gotta\n",
      "VBZ: verb, present tense, 3rd person singular\n",
      "    deserves believes receives takes goes expires says opposes starts\n",
      "    permits expects thinks faces votes teaches holds calls fears spends\n",
      "    collects backs eliminates sets flies gives seeks reads ...\n",
      "WDT: WH-determiner\n",
      "    which what whatever whichever whichever-the-hell\n",
      "WDT+BER: WH-determiner + verb 'to be', present tense, 2nd person singular or all persons plural\n",
      "    what're\n",
      "WDT+BER+PP: WH-determiner + verb 'to be', present, 2nd person singular or all persons plural + pronoun, personal, nominative, not 3rd person singular\n",
      "    whaddya\n",
      "WDT+BEZ: WH-determiner + verb 'to be', present tense, 3rd person singular\n",
      "    what's\n",
      "WDT+DO+PPS: WH-determiner + verb 'to do', uninflected present tense + pronoun, personal, nominative, not 3rd person singular\n",
      "    whaddya\n",
      "WDT+DOD: WH-determiner + verb 'to do', past tense\n",
      "    what'd\n",
      "WDT+HVZ: WH-determiner + verb 'to have', present tense, 3rd person singular\n",
      "    what's\n",
      "WP$: WH-pronoun, genitive\n",
      "    whose whosever\n",
      "WPO: WH-pronoun, accusative\n",
      "    whom that who\n",
      "WPS: WH-pronoun, nominative\n",
      "    that who whoever whosoever what whatsoever\n",
      "WPS+BEZ: WH-pronoun, nominative + verb 'to be', present, 3rd person singular\n",
      "    that's who's\n",
      "WPS+HVD: WH-pronoun, nominative + verb 'to have', past tense\n",
      "    who'd\n",
      "WPS+HVZ: WH-pronoun, nominative + verb 'to have', present tense, 3rd person singular\n",
      "    who's that's\n",
      "WPS+MD: WH-pronoun, nominative + modal auxillary\n",
      "    who'll that'd who'd that'll\n",
      "WQL: WH-qualifier\n",
      "    however how\n",
      "WRB: WH-adverb\n",
      "    however when where why whereby wherever how whenever whereon wherein\n",
      "    wherewith wheare wherefore whereof howsabout\n",
      "WRB+BER: WH-adverb + verb 'to be', present, 2nd person singular or all persons plural\n",
      "    where're\n",
      "WRB+BEZ: WH-adverb + verb 'to be', present, 3rd person singular\n",
      "    how's where's\n",
      "WRB+DO: WH-adverb + verb 'to do', present, not 3rd person singular\n",
      "    howda\n",
      "WRB+DOD: WH-adverb + verb 'to do', past tense\n",
      "    where'd how'd\n",
      "WRB+DOD*: WH-adverb + verb 'to do', past tense, negated\n",
      "    whyn't\n",
      "WRB+DOZ: WH-adverb + verb 'to do', present tense, 3rd person singular\n",
      "    how's\n",
      "WRB+IN: WH-adverb + preposition\n",
      "    why'n\n",
      "WRB+MD: WH-adverb + modal auxillary\n",
      "    where'd\n"
     ]
    }
   ],
   "source": [
    "nltk.help.brown_tagset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instead of this fine-grained tagset, we'll reduce the number of unique tags following a simple ad hoc rule:\n",
    "\n",
    "- tags with 2 characters or less remain the same\n",
    "- tag with more than 2 characters are grouped together under the equivalent 2-character tag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "brown_tagged_2chars = []\n",
    "\n",
    "for sentence in brown_tagged:\n",
    "    wt_pair2 = []\n",
    "    for wt_pair in sentence:\n",
    "        if len(wt_pair[1]) < 3:\n",
    "            wt_pair2.append(wt_pair)\n",
    "        else:\n",
    "            wt_pair2.append((wt_pair[0], wt_pair[1][:2]))\n",
    "    brown_tagged_2chars.append(wt_pair2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('The', 'AT'),\n",
       " ('Fulton', 'NP'),\n",
       " ('County', 'NN'),\n",
       " ('Grand', 'JJ'),\n",
       " ('Jury', 'NN'),\n",
       " ('said', 'VB'),\n",
       " ('Friday', 'NR'),\n",
       " ('an', 'AT'),\n",
       " ('investigation', 'NN'),\n",
       " ('of', 'IN'),\n",
       " (\"Atlanta's\", 'NP'),\n",
       " ('recent', 'JJ'),\n",
       " ('primary', 'NN'),\n",
       " ('election', 'NN'),\n",
       " ('produced', 'VB'),\n",
       " ('``', '``'),\n",
       " ('no', 'AT'),\n",
       " ('evidence', 'NN'),\n",
       " (\"''\", \"''\"),\n",
       " ('that', 'CS'),\n",
       " ('any', 'DT'),\n",
       " ('irregularities', 'NN'),\n",
       " ('took', 'VB'),\n",
       " ('place', 'NN'),\n",
       " ('.', '.')]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "brown_tagged_2chars[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's now check our new tagset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "tc2 = defaultdict(int)\n",
    "\n",
    "for sentence in brown_tagged_2chars:\n",
    "    for word, tag in sentence:\n",
    "        tc2[tag] += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('RN', 9),\n",
       " ('*-', 10),\n",
       " ('NI', 157),\n",
       " (':-', 160),\n",
       " ('(-', 162),\n",
       " (',-', 180),\n",
       " ('WQ', 181),\n",
       " (')-', 184),\n",
       " (\"'\", 317),\n",
       " ('.-', 616),\n",
       " ('UH', 629),\n",
       " ('FW', 1226),\n",
       " (':', 1558),\n",
       " ('NR', 1989),\n",
       " ('OD', 2145),\n",
       " ('(', 2264),\n",
       " (')', 2273),\n",
       " ('EX', 2280),\n",
       " ('PN', 2685),\n",
       " ('--', 3431),\n",
       " ('DO', 3879),\n",
       " ('AB', 4109),\n",
       " ('WP', 4518),\n",
       " ('WR', 4587),\n",
       " ('*', 4603),\n",
       " ('WD', 5633),\n",
       " ('RP', 6036),\n",
       " (\"''\", 8789),\n",
       " ('``', 8837),\n",
       " ('QL', 9008),\n",
       " ('AP', 9592),\n",
       " ('HV', 11965),\n",
       " ('MD', 13345),\n",
       " ('DT', 14639),\n",
       " ('CD', 14879),\n",
       " ('TO', 14998),\n",
       " ('CS', 22175),\n",
       " ('BE', 37720),\n",
       " ('RB', 37889),\n",
       " ('CC', 38151),\n",
       " ('NP', 43179),\n",
       " (',', 58156),\n",
       " ('.', 60638),\n",
       " ('PP', 64108),\n",
       " ('JJ', 71994),\n",
       " ('AT', 99077),\n",
       " ('VB', 115842),\n",
       " ('IN', 122591),\n",
       " ('NN', 227799)]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(tc2.items(), key=lambda x: x[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "49"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(tc2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our new tagset has **49 unique tags**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now **save our new tagged sentences and corresponding tagset** in the **same format as before**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"brown-49_tagset.txt\", \"w\") as f:\n",
    "    for i, sentence in enumerate(brown_tagged_2chars):\n",
    "        id = \"b-49_tagset-\"+str(i+1)\n",
    "        f.write(id+ '\\n')\n",
    "        for word, tag in sentence:\n",
    "            f.write(word+ '\\t'+ tag+ '\\n')\n",
    "        f.write('\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"49_tagset.txt\", \"w\") as f:\n",
    "    for tag in tc2.keys():\n",
    "        f.write(tag+ '\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now **build a new HMM tagger** using the same method as before.\n",
    "\n",
    "We'll start by reading the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 57340 sentences in the corpus.\n",
      "There are 45872 sentences in the training set.\n",
      "There are 11468 sentences in the testing set.\n"
     ]
    }
   ],
   "source": [
    "data = Dataset(\"49_tagset.txt\", \"brown-49_tagset.txt\", train_test_split=0.8)\n",
    "\n",
    "print(\"There are {} sentences in the corpus.\".format(len(data)))\n",
    "print(\"There are {} sentences in the training set.\".format(len(data.training_set)))\n",
    "print(\"There are {} sentences in the testing set.\".format(len(data.testing_set)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the functions we have defined before, we can calculate the necessary counts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "tag_unigrams = unigram_counts(data.training_set.Y)\n",
    "\n",
    "tag_bigrams = bigram_counts(data.training_set.Y)\n",
    "\n",
    "tag_starts = starting_counts(data.training_set.Y)\n",
    "\n",
    "tag_ends = ending_counts(data.training_set.Y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's now time to create our model and evaluate it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "basic_model = HiddenMarkovModel(name=\"base-hmm-tagger\")\n",
    "\n",
    "\n",
    "# Emission counts for the training set\n",
    "emission_counts_training = pair_counts(data.training_set.Y, data.training_set.X)\n",
    "\n",
    "\n",
    "# Calculate emission probability distribution (tag_emission_pd) and add states\n",
    "tags_state = {}\n",
    "\n",
    "for tag, words in emission_counts_training.items():\n",
    "    \n",
    "    emission_distribution = {}\n",
    "\n",
    "    for word in words.keys():\n",
    "        emission_distribution[word] = emission_counts_training[tag][word] / tag_unigrams[tag]\n",
    "\n",
    "    tag_emission_pd = DiscreteDistribution(emission_distribution)\n",
    "    \n",
    "    # Create one state per tag\n",
    "    tags_state[tag] = State(tag_emission_pd, name=tag)\n",
    "\n",
    "# Add one state per tag\n",
    "basic_model.add_states([tag_state for tag_state in tags_state.values()])\n",
    "\n",
    "\n",
    "# Add an edge from the starting state basic_model.start to each tag\n",
    "for tag in tag_starts.keys():\n",
    "    \n",
    "    # transition probability\n",
    "    transition_p = tag_starts[tag] / sum(tag_starts.values())\n",
    "    \n",
    "    basic_model.add_transition(basic_model.start, tags_state[tag], transition_p)\n",
    "\n",
    "    \n",
    "# Add an edge from each tag to the end state basic_model.end\n",
    "for tag in tag_ends.keys():\n",
    "    \n",
    "    # transition probability\n",
    "    transition_p = tag_ends[tag] / tag_unigrams[tag]\n",
    "    \n",
    "    basic_model.add_transition(tags_state[tag], basic_model.end, transition_p)\n",
    "    \n",
    "\n",
    "# Add an edge between every pair of tags\n",
    "for (tag1, tag2) in tag_bigrams.keys():\n",
    "    \n",
    "    # transition probability\n",
    "    transition_p = tag_bigrams[(tag1, tag2)] / tag_unigrams[tag1]\n",
    "    \n",
    "    basic_model.add_transition(tags_state[tag1], tags_state[tag2], transition_p)\n",
    "\n",
    "    \n",
    "# finalize the model\n",
    "basic_model.bake()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "training accuracy basic hmm model: 97.62%\n",
      "testing accuracy basic hmm model: 95.61%\n"
     ]
    }
   ],
   "source": [
    "hmm_training_acc = accuracy(data.training_set.X, data.training_set.Y, basic_model)\n",
    "print(\"training accuracy basic hmm model: {:.2f}%\".format(100 * hmm_training_acc))\n",
    "\n",
    "hmm_testing_acc = accuracy(data.testing_set.X, data.testing_set.Y, basic_model)\n",
    "print(\"testing accuracy basic hmm model: {:.2f}%\".format(100 * hmm_testing_acc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's use our model to make some predictions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sentence Key: b-49_tagset-39379\n",
      "\n",
      "Predicted labels:\n",
      "-----------------\n",
      "['CC', 'WD', 'RB', 'MD', 'PP', 'DO', '.', '.']\n",
      "\n",
      "Actual labels:\n",
      "--------------\n",
      "('CC', 'WD', 'RB', 'MD', 'PP', 'DO', '.', '.')\n",
      "\n",
      "\n",
      "Sentence Key: b-49_tagset-35345\n",
      "\n",
      "Predicted labels:\n",
      "-----------------\n",
      "['AP', 'IN', 'PP', 'MD', 'VB', 'CS', 'IN', 'DT', 'NN', 'IN', 'AT', 'NN', 'IN', 'NN', 'CC', 'AT', 'VB', 'IN', 'NN', 'EX', 'BE', 'PN', 'QL', 'JJ', '.']\n",
      "\n",
      "Actual labels:\n",
      "--------------\n",
      "('AP', 'IN', 'PP', 'MD', 'VB', 'CS', 'IN', 'DT', 'NN', 'IN', 'AT', 'NN', 'IN', 'NN', 'CC', 'AT', 'NN', 'IN', 'VB', 'EX', 'BE', 'PN', 'QL', 'JJ', '.')\n",
      "\n",
      "\n",
      "Sentence Key: b-49_tagset-38213\n",
      "\n",
      "Predicted labels:\n",
      "-----------------\n",
      "['NP', 'VB', ',', '``', 'DT', 'AB', 'NN', '.']\n",
      "\n",
      "Actual labels:\n",
      "--------------\n",
      "('NP', 'VB', ',', '``', 'DT', 'QL', 'JJ', '.')\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for key in data.testing_set.keys[:3]:\n",
    "    print(\"Sentence Key: {}\\n\".format(key))\n",
    "    print(\"Predicted labels:\\n-----------------\")\n",
    "    print(simplify_decoding(data.sentences[key].words, basic_model))\n",
    "    print()\n",
    "    print(\"Actual labels:\\n--------------\")\n",
    "    print(data.sentences[key].tags)\n",
    "    print(\"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ideas for future implementation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One way to improve performance would be to **include trigrams in our HMM tagger**. However, one side affect of this approach would be an **increase in data sparsity**. The fact that a particular sequence of tags in the test set may never have occured in the training set would lead to an incorrect prediction that this sequence would never occur. To counter this effect we could try to implement the following methods:\n",
    "\n",
    "- ~~add-one (Laplace) smoothing or add-k smoothing (with 0<k<1)~~ [done with Pomegranate]\n",
    "<br><br>\n",
    "- backoff (use a lower-order n-gram when the higher-order n-gram is not present)\n",
    "<br><br>\n",
    "- interpolation (mix the probability estimates from all the n-gram estimators)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Final notes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The attempts I've made for both the Viterbi and Baum-Welch algorithms lead to a minor improvement or even to a decrease in the model's accuracy and have a high running time (>1h for the Brown corpus tagged with the 49-tag tagset (with Baum-Welch) and almost 1h for the universal tagset (with Viterbi)). Further investigation is needed."
   ]
  }
 ],
 "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.5.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}