Exploring_Medical_History_of_British_India.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exploring A Medical History of British India\n",
    "Created in July-September 2020 for the National Library of Scotland's Data Foundry by Lucy Havens, Digital Library Research Intern"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### About the *A Medical History of British India* Dataset\n",
    "The dataset consists of 468 official publications from British India, mainly from 1850-1950, that report on public health, disease mapping, vaccination efforts, veterinary experiments, and other medical topics.  The publications are a subset of a larger collection of 40,000 volumes that report on the administration of British India.  The Wellcome Trust funded the digitisation of the medical history volumes in this dataset.\n",
    "* Data format: digitised text\n",
    "* Data creation process: Optical Character Recognition (OCR) and manual cleaning\n",
    "* Data source: https://data.nls.uk/data/digitised-collections/a-medical-history-of-british-india/\n",
    "***\n",
    "### Table of Contents\n",
    "0. [Preparation](#0.-Preparation)\n",
    "1. [Data Cleaning and Standardisation](#1.-Data-Cleaning-and-Standardisation)\n",
    "2. [Summary Statistics](#2.-Summary-Statistics)\n",
    "3. [Exploratory Analysis](#3.-Exploratory-Analysis)\n",
    "***\n",
    "### Citations\n",
    "* Alex, Beatrice and Llewellyn, Clare. (2020) *Library Carpentry: Text & Data Mining*. Centre for Data, Culture & Society, University of Edinburgh. http://librarycarpentry.org/lc-tdm/.\n",
    "* Bird, Steven and Klein, Ewan and Loper, Edward. (2019) *Natural Language Processing with Python – Analyzing Text with the Natural Language Toolkit*.  O'Reilly Media. 978-0-596-51649-9. https://www.nltk.org/book/."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 0. Preparation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import libraries to use for cleaning, summarising and exploring the data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To prevent SSL certificate failure\n",
    "import os, ssl\n",
    "if (not os.environ.get('PYTHONHTTPSVERIFY', '') and\n",
    "    getattr(ssl, '_create_unverified_context', None)):\n",
    "    ssl._create_default_https_context = ssl._create_unverified_context\n",
    "\n",
    "# Libraries for data loading\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import string\n",
    "import re\n",
    "\n",
    "# Libraries for visualization\n",
    "import altair as alt\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Libraries for text analysis\n",
    "import nltk\n",
    "from nltk.tokenize import word_tokenize, sent_tokenize\n",
    "nltk.download('punkt')\n",
    "from nltk.corpus import PlaintextCorpusReader\n",
    "nltk.download('wordnet')\n",
    "from nltk.corpus import wordnet\n",
    "nltk.download('stopwords')\n",
    "from nltk.corpus import stopwords\n",
    "from nltk.text import Text\n",
    "from nltk.stem.porter import PorterStemmer\n",
    "from nltk.probability import FreqDist\n",
    "nltk.download('averaged_perceptron_tagger')\n",
    "from nltk.tag import pos_tag\n",
    "nltk.download('tagsets')  # part of speech tags\n",
    "from nltk.draw.dispersion import dispersion_plot as displt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To explore the text in the *A Medical History of British India* collection, we'll mainly use the **Natural Language Toolkit (NLTK)**, a library written for the programming language Python.\n",
    "\n",
    "The nls-text-indiaPapers folder (downloadable as *Just the text* data from the website at the top of this notebook) contains TXT files of digitised text with numerical names, as well as a CSV inventory file and a TXT ReadMe file.  Load only the TXT files of digitised text and **tokenise** the text (which splits a string into separate words and punctuation):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['No', '.', '1111', '(', 'Sanitary', '),', 'dated', 'Ootacamund', ',', 'the']\n"
     ]
    }
   ],
   "source": [
    "corpus_folder = 'data/nls-text-indiaPapers/'\n",
    "wordlists = PlaintextCorpusReader(corpus_folder, '\\d.*', encoding='latin1')\n",
    "corpus_tokens = wordlists.words()\n",
    "print(corpus_tokens[:10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Note: If you'd like to see how to specify a single TXT file to load as data, check out the Jupyter Notebook for the Britain and UK Handbooks!*\n",
    "\n",
    "It's hard to get a sense of how accurately the text has been digitised from this list of 10 tokens, so let's look at one of these words in context.  To see phrases in which \"India\" is used, we can use the `concordance()` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Displaying 20 of 16495 matches:\n",
      "ffg . Secretary to the Government of India . Resolution of Government of India \n",
      " India . Resolution of Government of India No . 1 - 137 , dated 5th March 1875 \n",
      "rch 1875 . Letter from Government of India No . 486 , dated 5th September 1876 \n",
      "ember 1876 . Letter to Government of India No . 1063 , dated 26th ditto . REFER\n",
      "ffg . Secretary to the Government of India , Home Department . REFERRING to par\n",
      " to paragraph 8 of the Government of India ' s Resolu - tion No . 1 - 136 , dat\n",
      "inion expressed by the Government of India that any measures of segragation and\n",
      "filth with which all the villages in India are surrounded is quite sufficient t\n",
      "the disease in Rajputana and Central India are in the hands of the Presidency S\n",
      "ffg . Secretary to the Government of India , Home Dept . IN continuation of my \n",
      " the Resolution of the Government of India , Home Department ( Medical ), No 1 \n",
      "d by the orders of the Government of India dated 5th March 1876 . Report on lep\n",
      "e to the orders of the Government of India , contained in paragraph 8 of Resolu\n",
      "ries propounded by the Government of India . 5 . In regard to the extent to whi\n",
      " of leprosy in Europeans resident in India which have come to his knowledge - o\n",
      " case of an European lady , who left India in 1875 and suffered with symptoms o\n",
      "ffg . Secretary to the Government of India , Home Dept . IN continuation of let\n",
      "the information of the Government of India , copy of a letter from the Officiat\n",
      "rnment of the Punjab . Government of India No . 141 , dated 5th March 1875 , pa\n",
      "ffg . Secretary to the Government of India , Home Department . IN continuation \n"
     ]
    }
   ],
   "source": [
    "t = Text(corpus_tokens)\n",
    "t.concordance('India', lines=20)  # by default NLTK's concordance method displays 25 lines"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The *A Medical History of British India* (MHBI) dataset has been digitised and then manually corrected for errors in the digitisation process, so we can be pretty confident in the quality of the text for this dataset.\n",
    "\n",
    "Let's find out just how much text and just how many files we're working with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total...\n",
      "  Tokens in MHBI Data: 28333479\n",
      "  Sentences in MHBI Data: 1671768\n",
      "  Files in MHBI Data: 468\n"
     ]
    }
   ],
   "source": [
    "def corpusStatistics(plaintext_corpus_read_lists):\n",
    "    total_tokens = 0\n",
    "    total_sents = 0\n",
    "    total_files = 0\n",
    "    for fileid in plaintext_corpus_read_lists.fileids():\n",
    "        total_tokens += len(plaintext_corpus_read_lists.words(fileid))\n",
    "        total_sents += len(plaintext_corpus_read_lists.sents(fileid))\n",
    "        total_files += 1\n",
    "    print(\"Total...\")\n",
    "    print(\"  Tokens in MHBI Data:\", total_tokens)\n",
    "    print(\"  Sentences in MHBI Data:\", total_sents)\n",
    "    print(\"  Files in MHBI Data:\", total_files)\n",
    "\n",
    "corpusStatistics(wordlists)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that I've print ``Tokens`` rather than words, though the NLTK method used to count those was ``.words()``.  This is because words in NLTK include punctuation marks and digits, in addition to alphabetic words.\n",
    "\n",
    "The `fileids` are the names of the files in the data's source folder:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['74457530.txt', '74457800.txt', '74458285.txt']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fileids = list(wordlists.fileids())\n",
    "fileids[0:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the inventory CSV file from the source folder to match the titles of the papers to the corresponding `fileid`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>fileid</th>\n",
       "      <th>title</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>74457530.txt</td>\n",
       "      <td>Distribution and causation of leprosy in Briti...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>74457800.txt</td>\n",
       "      <td>Report of an outbreak of cholera in Suhutwar, ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>74458285.txt</td>\n",
       "      <td>Report of an investigation into the causes of ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>74458388.txt</td>\n",
       "      <td>Account of plague administration in the Bombay...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>74458575.txt</td>\n",
       "      <td>Inquiry into the circumstances attending an ou...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         fileid                                              title\n",
       "0  74457530.txt  Distribution and causation of leprosy in Briti...\n",
       "1  74457800.txt  Report of an outbreak of cholera in Suhutwar, ...\n",
       "2  74458285.txt  Report of an investigation into the causes of ...\n",
       "3  74458388.txt  Account of plague administration in the Bombay...\n",
       "4  74458575.txt  Inquiry into the circumstances attending an ou..."
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_csv('data/nls-text-indiaPapers/indiaPapers-inventory.csv', header=None, names=['fileid', 'title'])\n",
    "df.head()  # prints the first 5 rows (df.tail() prints the last 5 rows)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also create a list of the titles from the dataframe column:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Distribution and causation of leprosy in British India 1875 - IP/HA.2',\n",
       " 'Report of an outbreak of cholera in Suhutwar, Bulliah sub-division - IP/30/PI.2',\n",
       " 'Report of an investigation into the causes of the diseases known in Assam as Kála-Azár and Beri-Beri - IP/3/MB.5']"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "titles = list(df['title'])\n",
    "titles[0:3]   # Display the first three titles (from index 0 up to but not including index 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variables that store the characters, words, and sentences in our dataset could be useful for exploratory analysis.  Uncomment the lines below (highlight them and press `CTRL` + `/` or `CMD` + `/`) if you'd like to use those variables for your own analysis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# def getCharsWordsSents(plaintext_corpus_read_lists, fileids):\n",
    "#     all_chars = []\n",
    "#     chars_by_file = dict.fromkeys(fileids)\n",
    "#     all_words = []\n",
    "#     words_by_file = dict.fromkeys(fileids)\n",
    "#     all_words_lower = []\n",
    "#     words_lower_by_file = dict.fromkeys(fileids)\n",
    "#     all_sents = []\n",
    "#     sents_by_file = dict.fromkeys(fileids)\n",
    "#     for fileid in plaintext_corpus_read_lists.fileids():\n",
    "        \n",
    "#         file_chars = plaintext_corpus_read_lists.raw(fileid)\n",
    "#         all_chars += [str(char).lower() for char in file_chars]\n",
    "#         chars_by_file[fileid] = all_chars\n",
    "        \n",
    "#         file_words = plaintext_corpus_read_lists.words(fileid)\n",
    "#         all_words_lower += [str(word).lower() for word in file_words if word.isalpha()]\n",
    "#         words_lower_by_file[fileid] = all_words_lower\n",
    "#         all_words += [str(word) for word in file_words  if word.isalpha()]\n",
    "#         words_by_file[fileid] = all_words\n",
    "        \n",
    "#         file_sents = sent_tokenize(plaintext_corpus_read_lists.raw(fileid))  #plaintext_corpus_read_lists.sents(fileid)\n",
    "#         all_sents += [str(sent) for sent in file_sents]\n",
    "#         sents_by_file[fileid] = all_sents\n",
    "        \n",
    "#     return all_chars, chars_by_file, all_words, words_by_file, all_words_lower, words_lower_by_file, all_sents, sents_by_file\n",
    "        \n",
    "# mhbi_chars, mhbi_file_chars, mhbi_words, mhbi_file_words, mhbi_words_lower, mhbi_file_lower_words, mhbi_sents, mhbi_file_sents = getCharsWordsSents(wordlists, fileids)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To make sure the function worked as expected, you can run some quick tests with the output lists and dictionaries:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print(mhbi_file_chars[fileids[100]][:10])\n",
    "# print(mhbi_file_words[fileids[355]][30:40])\n",
    "# print(mhbi_file_sents[fileids[-1]][-20:-10])\n",
    "# assert(len(mhbi_file_chars) == len(fileids))  # nothing prints if passes, error prints if doesn't pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print(mhbi_chars[:100])\n",
    "# print(mhbi_words[6100:6120])\n",
    "# print(mhbi_sents[-5:])\n",
    "# assert(len(mhbi_words_lower) == len(mhbi_words))  # nothing prints if passes, error prints if doesn't pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looking good!\n",
    "\n",
    "### 1. Data Cleaning and Standardisation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since the OCR has already been manually cleaned, we'll focus this section on identifying the roots of words and the parts of speech in sentences, rather than getting a sense of how many mistakes were made in the OCR process.\n",
    "\n",
    "#### 1.1 Tokenisation\n",
    "\n",
    "First let's create lists of strings from the NLTK tokens that we can use in future analysis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['No', '.', '1111', '(', 'Sanitary', '),', 'dated', 'Ootacamund', ',', 'the']\n",
      "['g', '.', 'b', '.', 'c', '.', 'p', '.', 'o', '.']\n",
      "[',', '424', '705', '491', '214', '8', '11', '5', 'surat', '607']\n",
      "['the', 'twenty', 'cases', 'mentioned', 'above', 'seventeen', 'are', 'said', 'to', 'have']\n"
     ]
    }
   ],
   "source": [
    "str_tokens = [str(word) for word in corpus_tokens]\n",
    "assert(type(str_tokens[0]) == str)  # quick test to make sure the output is as expected\n",
    "print(str_tokens[0:10])\n",
    "\n",
    "# Lowercase text\n",
    "lower_str_tokens = [t.lower() for t in str_tokens]\n",
    "print(lower_str_tokens[-10:])\n",
    "\n",
    "# Exclude stop words (i.e. the, a, is) - note that the input text must be lowercased!\n",
    "eng_stopwords = set(stopwords.words('english'))\n",
    "no_stopwords = [t for t in lower_str_tokens if not t in eng_stopwords]\n",
    "print(no_stopwords[500:510])\n",
    "assert(len(no_stopwords) < len(str_tokens))\n",
    "\n",
    "# Alphabetic tokens only (exclude digits and punctuation)\n",
    "alpha_tokens = [t for t in str_tokens if t.isalpha()]\n",
    "alpha_tokens_lower = [t for t in lower_str_tokens if t.isalpha()]\n",
    "print(alpha_tokens[1000:1010])\n",
    "assert(len(alpha_tokens_lower) == len(alpha_tokens))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.2 Reducing Words to Root Forms\n",
    "Next, we'll **stem** the tokens, or reduce the tokens to their root.  NLTK has two types of stemmers that use different algorithms to determine what the root of a word is.  Here's a sample of what they look like."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "    <b>Note:</b> This code can take several minutes to run (and a lot of memory, which is limited if you're using Binder), which is why the stemmer code has been commented out. You can uncomment the code so that it runs by removing the '#' before each line (highlight all lines and then press [CMD or CTRL] + /).\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['the', 'govern', 'of', 'india', 'that', 'ani', 'measur', 'of', 'segrag', 'and', 'medic', 'treatment', 'of', 'leper', 'throughout', 'the', 'countri', 'would', 'be', 'impractic', 'as', 'a', 'state', 'measur', 'but', 'i', 'do', 'hold', 'that', 'the', 'improv', 'of', 'the', 'hygien', 'condit', 'under', 'which', 'the', 'mass', 'of', 'the', 'peopl', 'live', 'is', 'the', 'onli', 'sure', 'method', 'of', 'stamp', 'out', 'leprosi', 'or', 'ani', 'similar', 'diseas', 'the', 'filth', 'with', 'which', 'all', 'the', 'villag', 'in', 'india', 'are', 'surround', 'is', 'quit', 'suffici', 'to', 'prevent', 'ani', 'hope', 'of', 'success', 'in', 'combat', 'the', 'diseas', 'which', 'it', 'is', 'not', 'difficult', 'to', 'forese', 'will', 'prevail', 'until', 'such', 'an', 'objection', 'state', 'of', 'matter', 'is', 'alter', 'with', 'these']\n"
     ]
    }
   ],
   "source": [
    "# Stem the text (reduce words to their root, whether or not the root is a word itself\n",
    "\n",
    "# porter = nltk.PorterStemmer()\n",
    "# porter_stemmed = [porter.stem(t) for t in alpha_tokens_lower]\n",
    "# print(porter_stemmed[500:600])\n",
    "\n",
    "# lancaster = nltk.LancasterStemmer()\n",
    "# lancaster_stemmed = [lancaster.stem(t) for t in alpha_tokens_lower]\n",
    "# print(lancaster_stemmed[500:600])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another approach to reducing words to their root is to **lemmatise** tokens.  NLTK's WordNet Lemmatizer reduces a token to its root *only* if the reduction of the token results in a word that's recognised as an English word in WordNet.  Uncomment the code below if you'd like to see what that looks like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['the', 'government', 'of', 'india', 'that', 'any', 'measure', 'of', 'segragation', 'and', 'medical', 'treatment', 'of', 'leper', 'throughout', 'the', 'country', 'would', 'be', 'impracticable', 'a', 'a', 'state', 'measure', 'but', 'i', 'do', 'hold', 'that', 'the', 'improvement', 'of', 'the', 'hygienic', 'condition', 'under', 'which', 'the', 'mass', 'of', 'the', 'people', 'live', 'is', 'the', 'only', 'sure', 'method', 'of', 'stamping', 'out', 'leprosy', 'or', 'any', 'similar', 'disease', 'the', 'filth', 'with', 'which', 'all', 'the', 'village', 'in', 'india', 'are', 'surrounded', 'is', 'quite', 'sufficient', 'to', 'prevent', 'any', 'hope', 'of', 'success', 'in', 'combating', 'the', 'disease', 'which', 'it', 'is', 'not', 'difficult', 'to', 'foresee', 'will', 'prevail', 'until', 'such', 'an', 'objectionable', 'state', 'of', 'matter', 'is', 'altered', 'with', 'these']\n"
     ]
    }
   ],
   "source": [
    "# Lemmatise the text (reduce words to their root ONLY if the root is considered a word in WordNet)\n",
    "\n",
    "# wnl = nltk.WordNetLemmatizer()\n",
    "# lemmatised = [wnl.lemmatize(t) for t in alpha_tokens_lower]  # only include alphabetic tokens\n",
    "# print(lemmatised[500:600])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Summary Statistics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.1 Frequencies and Sizes\n",
    "Now that we've created some different cuts of the MHBI dataset, let's start investigating the frequency of terms as they appear across the dataset.  One way to do so is with a **frequency distribution**, which is a line chart that shows how many times a token appears in the dataset.\n",
    "\n",
    "First let's visualise a frequency distribution for common alphabetical tokens in the dataset (tokens composed of letters, not punctuation or numbers) EXCEPT stop words (i.e. the, and, a):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Filter one-letter words, two-letter words, and  stop words out of the list of alphabetic tokens\n",
    "to_exclude = [\"per\", \"two\", \"one\", \"also\"]\n",
    "filtered_tokens = [t for t in no_stopwords if (len(t) > 2 and not t in to_exclude)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total tokens in filtered list: 11670424\n"
     ]
    }
   ],
   "source": [
    "# Calculate the frequency distribution for the filtered list of tokens\n",
    "fdist_ft = FreqDist(filtered_tokens)\n",
    "print(\"Total tokens in filtered list:\", fdist_ft.N())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1c69f2898>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Visualise the frequency distribution for a select number of tokens\n",
    "plt.figure(figsize = (14, 8))                # customise the width and height of the plot\n",
    "plt.rc('font', size=12)                       # customise the font size of the title, axes names, and axes labels\n",
    "fdist_ft.plot(20, title='Frequency Distribution of the 20 Most Common Words in the Medical History of British India Dataset (excluding stop words, 2-letter and 3-letter words)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The medical focus is clear from the top 20 words in the MHBI papers, which includes `cases`, `hospital`, `disease`, `veterinary`, `vaccination`, and `plague`.  Also, the frequency distribution suggests the people writing the papers made an effort to summarise what was going on, since the top three tokens, by far, are `total`, `year`, and `number` (perhaps summarising `cases` by `district`?)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class='alert alert-block alert-info'>\n",
    "    <b>Try It!</b> Create a frequency distribution for stemmed words, or stems.  What differences do you see in the two frequency distributions?\n",
    "  \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.2 Uniqueness and Variety"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another way to summarise the MHBI dataset is to look at the uniqueness and variety of word usage.  We can obtain the **vocabulary** of the text by creating a set of unique words (alphabetic tokens) that occur in the dataset, as well as creating a set of unique *lemmatised* words that occur in the dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unique tokens: 186247\n",
      "Unique lowercase tokens: 151872\n",
      "Unique lemmatised (lowercase) tokens: 144837\n"
     ]
    }
   ],
   "source": [
    "# Remove duplicate words from the text (obtain the vocabulary of the text)\n",
    "t_vocab = set(alpha_tokens)\n",
    "t_vocab_lower = set(alpha_tokens_lower)\n",
    "lemma_vocab = set(lemmatised)\n",
    "print(\"Unique tokens:\", len(t_vocab))\n",
    "print(\"Unique lowercase tokens:\", len(t_vocab_lower))\n",
    "print(\"Unique lemmatised (lowercase) tokens:\", len(lemma_vocab))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can create a data visualisation that illustrates when specific words are used within the MHBI dataset.  This is called a **Lexical Dispersion Plot**.  We'll pick some terms (the list of `targets`) from the list of the most common 20 words in the dataset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('...', 1634899),\n",
       " ('total', 94009),\n",
       " ('year', 82764),\n",
       " ('number', 63297),\n",
       " ('cases', 39875),\n",
       " ('......', 39757),\n",
       " ('district', 30462),\n",
       " ('may', 30145),\n",
       " ('report', 29538),\n",
       " ('hospital', 28273),\n",
       " ('government', 26231),\n",
       " ('disease', 25705),\n",
       " ('veterinary', 25575),\n",
       " ('average', 25560),\n",
       " ('years', 24749),\n",
       " ('vaccination', 24190),\n",
       " ('plague', 23489),\n",
       " ('table', 21813),\n",
       " ('males', 21500),\n",
       " ('females', 21153)]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fdist_ft.most_common(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Exploratory Analysis\n",
    "\n",
    "Let's determine the top 20 most common words for each paper (file) in the MHBI dataset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "fileids = list(df['fileid'])\n",
    "id_to_title = dict(zip(fileids,titles))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "465\n"
     ]
    }
   ],
   "source": [
    "common_words = {}\n",
    "for file in fileids:\n",
    "    tokens = wordlists.words(file)\n",
    "\n",
    "    # Filter non-alphabetic words and stop words out of the list of tokens\n",
    "    tokens_lower = [t.lower() for t in tokens if t.isalpha()]\n",
    "    to_exclude = list(set(stopwords.words('english'))) + [\"per\", \"two\", \"one\", \"also\"]\n",
    "    filtered_tokens = [t for t in tokens_lower if not t in to_exclude]\n",
    "    \n",
    "    fdist = FreqDist(filtered_tokens)\n",
    "    \n",
    "    title = id_to_title[file]\n",
    "    words = list(fdist.most_common(20))\n",
    "    common_words[title] = words\n",
    "\n",
    "print(len(common_words))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now you can use the title of a paper to find the 20 most common words in that paper:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('microbe', 26), ('mr', 15), ('hankin', 14), ('plague', 14), ('bubo', 14), ('h', 13), ('found', 12), ('action', 10), ('l', 9), ('acid', 8), ('infection', 7), ('infected', 7), ('days', 7), ('e', 7), ('rt', 7), ('pneumonia', 7), ('water', 6), ('rec', 6), ('fem', 6), ('b', 6)]\n"
     ]
    }
   ],
   "source": [
    "paper = id_to_title[fileids[10]]\n",
    "print(common_words[paper])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class='alert alert-block alert-info'>\n",
    "    <b>Try It!</b> Inspired by questions from MHBI's curator, the questions below offer starting points for topics you could consider exploring in the MHBI dataset!\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.1 Which publications are about cholera?  Leprosy?  Malaria?  Plague?  Laboratory medicine?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# t.concordance(\"cholera\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.2 How does the language around the people of India change over time?\n",
    "\n",
    "Consider comparing papers from before and after the 1857 rebellion when British East India Company rule in India was taken over by the British Crown.  How does the word choice and sentiment of the language differ before and after?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# t.concordance(\"Native\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.3 How does the language around mental hospitals change over time?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# t.concordance(\"lunatic\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# t.concordance(\"mental\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.4 How are women portrayed?\n",
    "\n",
    "Consider lock(ed) hospitals and escapes from them, and prostitution permitted in army barracks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# t.concordance(\"women\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# t.concordance(\"lock\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.5 What is the rhetoric around vaccinations and, more generally, public health?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# t.concordance(\"vaccination\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}