03_NLTK_and_Numpy_overview.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to NLTK, NumPy, SciPy, and MatPlotLib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Practical course material for the ASDM Class 09 (Text Mining) by Florian Leitner.\n",
    "\n",
    "© 2016 Florian Leitner. All rights reserved."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This lab will cover working with the [Natural Langauge ToolKit](http://www.nltk.org/index.html), with [Numerical and Scientific Python aka. NumPy and SciPy](http://www.numpy.org/), and with [MatPlotLib](http://matplotlib.org/) (while your instructor ensures that all participants have a working notebook environment...). These are maybe the most fundamental libraries to do Computational Linguistics and Scientific Computing using Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    }
   ],
   "source": [
    "%pylab inline --no-import-all"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you have not yet done so already, read up on pylab and, in particular, what `--no-import-all` does."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pylab?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Natural Language ToolKit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try to import the NLTK library; If that does not work, you need to install it with `conda install nltk` if you are using Anaconda Python (or `pip3 install nltk` if you are using regular Python)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.2.5\n"
     ]
    }
   ],
   "source": [
    "import nltk\n",
    "print(nltk.__version__) # should be 3.2.1 or newer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fetch some metadata (text \"copora\") for the NLTK; we will use only `book` content."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "showing info https://raw.githubusercontent.com/nltk/nltk_data/gh-pages/index.xml\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nltk.download()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This should have opened another window where you can choose what corpora to download. It is sufficient for now to only download the `book` content. Note that downloading everything can take quite a while..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** Introductory Examples for the NLTK Book ***\n",
      "Loading text1, ..., text9 and sent1, ..., sent9\n",
      "Type the name of the text or sentence to view it.\n",
      "Type: 'texts()' or 'sents()' to list the materials.\n",
      "text1: Moby Dick by Herman Melville 1851\n",
      "text2: Sense and Sensibility by Jane Austen 1811\n",
      "text3: The Book of Genesis\n",
      "text4: Inaugural Address Corpus\n",
      "text5: Chat Corpus\n",
      "text6: Monty Python and the Holy Grail\n",
      "text7: Wall Street Journal\n",
      "text8: Personals Corpus\n",
      "text9: The Man Who Was Thursday by G . K . Chesterton 1908\n"
     ]
    }
   ],
   "source": [
    "# export NLTK_DATA=\"/Users/fnl/work/var/nltk_data\"\n",
    "import nltk.book as b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Text Object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Text: Moby Dick by Herman Melville 1851>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.text1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "nltk.text.Text"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(b.text1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some quick info:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "nltk.text.Text?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More in-depth documentation with all methods defined on `Text`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class Text in module nltk.text:\n",
      "\n",
      "class Text(builtins.object)\n",
      " |  A wrapper around a sequence of simple (string) tokens, which is\n",
      " |  intended to support initial exploration of texts (via the\n",
      " |  interactive console).  Its methods perform a variety of analyses\n",
      " |  on the text's contexts (e.g., counting, concordancing, collocation\n",
      " |  discovery), and display the results.  If you wish to write a\n",
      " |  program which makes use of these analyses, then you should bypass\n",
      " |  the ``Text`` class, and use the appropriate analysis function or\n",
      " |  class directly instead.\n",
      " |  \n",
      " |  A ``Text`` is typically initialized from a given document or\n",
      " |  corpus.  E.g.:\n",
      " |  \n",
      " |  >>> import nltk.corpus\n",
      " |  >>> from nltk.text import Text\n",
      " |  >>> moby = Text(nltk.corpus.gutenberg.words('melville-moby_dick.txt'))\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __getitem__(self, i)\n",
      " |  \n",
      " |  __init__(self, tokens, name=None)\n",
      " |      Create a Text object.\n",
      " |      \n",
      " |      :param tokens: The source text.\n",
      " |      :type tokens: sequence of str\n",
      " |  \n",
      " |  __len__(self)\n",
      " |  \n",
      " |  __repr__(self)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __str__(self)\n",
      " |      Return str(self).\n",
      " |  \n",
      " |  __unicode__ = __str__(self)\n",
      " |  \n",
      " |  collocations(self, num=20, window_size=2)\n",
      " |      Print collocations derived from the text, ignoring stopwords.\n",
      " |      \n",
      " |      :seealso: find_collocations\n",
      " |      :param num: The maximum number of collocations to print.\n",
      " |      :type num: int\n",
      " |      :param window_size: The number of tokens spanned by a collocation (default=2)\n",
      " |      :type window_size: int\n",
      " |  \n",
      " |  common_contexts(self, words, num=20)\n",
      " |      Find contexts where the specified words appear; list\n",
      " |      most frequent common contexts first.\n",
      " |      \n",
      " |      :param word: The word used to seed the similarity search\n",
      " |      :type word: str\n",
      " |      :param num: The number of words to generate (default=20)\n",
      " |      :type num: int\n",
      " |      :seealso: ContextIndex.common_contexts()\n",
      " |  \n",
      " |  concordance(self, word, width=79, lines=25)\n",
      " |      Print a concordance for ``word`` with the specified context window.\n",
      " |      Word matching is not case-sensitive.\n",
      " |      :seealso: ``ConcordanceIndex``\n",
      " |  \n",
      " |  count(self, word)\n",
      " |      Count the number of times this word appears in the text.\n",
      " |  \n",
      " |  dispersion_plot(self, words)\n",
      " |      Produce a plot showing the distribution of the words through the text.\n",
      " |      Requires pylab to be installed.\n",
      " |      \n",
      " |      :param words: The words to be plotted\n",
      " |      :type words: list(str)\n",
      " |      :seealso: nltk.draw.dispersion_plot()\n",
      " |  \n",
      " |  findall(self, regexp)\n",
      " |      Find instances of the regular expression in the text.\n",
      " |      The text is a list of tokens, and a regexp pattern to match\n",
      " |      a single token must be surrounded by angle brackets.  E.g.\n",
      " |      \n",
      " |      >>> print('hack'); from nltk.book import text1, text5, text9\n",
      " |      hack...\n",
      " |      >>> text5.findall(\"<.*><.*><bro>\")\n",
      " |      you rule bro; telling you bro; u twizted bro\n",
      " |      >>> text1.findall(\"<a>(<.*>)<man>\")\n",
      " |      monied; nervous; dangerous; white; white; white; pious; queer; good;\n",
      " |      mature; white; Cape; great; wise; wise; butterless; white; fiendish;\n",
      " |      pale; furious; better; certain; complete; dismasted; younger; brave;\n",
      " |      brave; brave; brave\n",
      " |      >>> text9.findall(\"<th.*>{3,}\")\n",
      " |      thread through those; the thought that; that the thing; the thing\n",
      " |      that; that that thing; through these than through; them that the;\n",
      " |      through the thick; them that they; thought that the\n",
      " |      \n",
      " |      :param regexp: A regular expression\n",
      " |      :type regexp: str\n",
      " |  \n",
      " |  generate(self, words)\n",
      " |      Issues a reminder to users following the book online\n",
      " |  \n",
      " |  index(self, word)\n",
      " |      Find the index of the first occurrence of the word in the text.\n",
      " |  \n",
      " |  plot(self, *args)\n",
      " |      See documentation for FreqDist.plot()\n",
      " |      :seealso: nltk.prob.FreqDist.plot()\n",
      " |  \n",
      " |  readability(self, method)\n",
      " |  \n",
      " |  similar(self, word, num=20)\n",
      " |      Distributional similarity: find other words which appear in the\n",
      " |      same contexts as the specified word; list most similar words first.\n",
      " |      \n",
      " |      :param word: The word used to seed the similarity search\n",
      " |      :type word: str\n",
      " |      :param num: The number of words to generate (default=20)\n",
      " |      :type num: int\n",
      " |      :seealso: ContextIndex.similar_words()\n",
      " |  \n",
      " |  unicode_repr = __repr__(self)\n",
      " |  \n",
      " |  vocab(self)\n",
      " |      :seealso: nltk.prob.FreqDist\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(nltk.text.Text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ Moby Dick by Herman Melville 1851 ] ETYMOLOGY .\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1, 4, 4, 2, 6, 8, 4, 1, 9, 1]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a shortcut to Moby Dick\n",
    "moby = b.text1\n",
    "# iteration over all words in Moby Dick using a Python list comprehension\n",
    "wlens = [len(w) for w in moby]\n",
    "# show the first ten words\n",
    "print(\" \".join(moby[:10]))\n",
    "# report the lengths of the first ten words\n",
    "wlens[:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Count the frequency of \"me\" in Moby Dick"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "627"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "moby.count(\"me\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "moby.findall?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Find all tokens before \"Moby\" in the text."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ Moby; call Moby; \" Moby; is Moby; -- Moby; -- Moby; of Moby; not\n",
      "Moby; was Moby; ; Moby; for Moby; for Moby; to Moby; hunt Moby; 41\n",
      "Moby; concerning Moby; than Moby; to Moby; upon Moby; invested Moby;\n",
      "to Moby; to Moby; that Moby; declaring Moby; , Moby; in Moby; touching\n",
      "Moby; though Moby; , Moby; blow Moby; of Moby; at Moby; of Moby;\n",
      "respecting Moby; than Moby; to Moby; of Moby; , Moby; of Moby; was\n",
      "Moby; \"' Moby; you Moby; of Moby; , Moby; this Moby; of Moby; seen\n",
      "Moby; that Moby; concerning Moby; of Moby; , Moby; surrender Moby; to\n",
      "Moby; , Moby; -- Moby; about Moby; thinking Moby; slay Moby; is Moby;\n",
      "for Moby; for Moby; Oh Moby; of Moby; encountered Moby; to Moby; is\n",
      "Moby; , Moby; awaiting Moby; was Moby; , Moby; , Moby; , Moby; from\n",
      "Moby; of Moby; not Moby; -- Moby; , Moby; , Moby; with Moby; , Moby; ,\n",
      "Moby; , Moby; ! Moby; , Moby\n"
     ]
    }
   ],
   "source": [
    "moby.findall(\"<.*><Moby>\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now find all tokens occuring before \"Dick\" in the text."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moby Dick; Moby Dick; Moby Dick; Moby Dick; Moby Dick; Moby Dick; Moby\n",
      "Dick; Moby Dick; Moby Dick; Moby Dick; Moby Dick; Moby Dick; Moby\n",
      "Dick; Moby Dick; Moby Dick; Moby Dick; Moby Dick; Moby Dick; Moby\n",
      "Dick; Moby Dick; Moby Dick; Moby Dick; Moby Dick; Moby Dick; Moby\n",
      "Dick; Moby Dick; Moby Dick; Moby Dick; Moby Dick; Moby Dick; Moby\n",
      "Dick; Moby Dick; Moby Dick; Moby Dick; Moby Dick; Moby Dick; Moby\n",
      "Dick; Moby Dick; Moby Dick; Moby Dick; Moby Dick; Moby Dick; Moby\n",
      "Dick; Moby Dick; Moby Dick; Moby Dick; Moby Dick; Moby Dick; Moby\n",
      "Dick; Moby Dick; Moby Dick; Moby Dick; Moby Dick; Moby Dick; Moby\n",
      "Dick; Moby Dick; Moby Dick; Moby Dick; Moby Dick; Moby Dick; Moby\n",
      "Dick; Moby Dick; Moby Dick; Moby Dick; Moby Dick; Moby Dick; Moby\n",
      "Dick; Moby Dick; Moby Dick; Moby Dick; Moby Dick; Moby Dick; Moby\n",
      "Dick; - Dick; Moby Dick; Moby Dick; Moby Dick; Moby Dick; Moby Dick;\n",
      "Moby Dick; Moby Dick; Moby Dick; Moby Dick; Moby Dick\n"
     ]
    }
   ],
   "source": [
    "moby.findall(\"<.*><Dick>\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use regular expressions (here: only tokens with letters - roughly, \"words\") to match tokens."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "call Moby; is Moby; of Moby; not Moby; was Moby; for Moby; for Moby;\n",
      "to Moby; hunt Moby; concerning Moby; than Moby; to Moby; upon Moby;\n",
      "invested Moby; to Moby; to Moby; that Moby; declaring Moby; in Moby;\n",
      "touching Moby; though Moby; blow Moby; of Moby; at Moby; of Moby;\n",
      "respecting Moby; than Moby; to Moby; of Moby; of Moby; was Moby; you\n",
      "Moby; of Moby; this Moby; of Moby; seen Moby; that Moby; concerning\n",
      "Moby; of Moby; surrender Moby; to Moby; about Moby; thinking Moby;\n",
      "slay Moby; is Moby; for Moby; for Moby; Oh Moby; of Moby; encountered\n",
      "Moby; to Moby; is Moby; awaiting Moby; was Moby; from Moby; of Moby;\n",
      "not Moby; with Moby\n"
     ]
    }
   ],
   "source": [
    "moby.findall(\"<[A-Za-z]*><Moby>\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use regular expression grouping `()` to extract only specific tokens that were matched."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "call; is; of; not; was; for; for; to; hunt; concerning; than; to;\n",
      "upon; invested; to; to; that; declaring; in; touching; though; blow;\n",
      "of; at; of; respecting; than; to; of; of; was; you; of; this; of;\n",
      "seen; that; concerning; of; surrender; to; about; thinking; slay; is;\n",
      "for; for; Oh; of; encountered; to; is; awaiting; was; from; of; not;\n",
      "with\n"
     ]
    }
   ],
   "source": [
    "moby.findall(\"(<[A-Za-z]*>)<Moby>\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "moby.similar?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "man boat captain soul and i while whale more sometimes when if ship\n",
      "than though good mary to body brain\n"
     ]
    }
   ],
   "source": [
    "moby.similar(\"boy\") # NB: semantic similarity (\"synonyms\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "44764"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(b.text3) # total tokens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2789"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(set(b.text3)) # unique tokens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 4, 2, 6]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wlens[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.830411128023649"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(wlens) / len(wlens) # mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.830411128023649"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(wlens) * 1.0 / len(wlens)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finding the median token length:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "wlens = sorted(wlens)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wlens[len(wlens) // 2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The longest token in the book:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wlens[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plots available directly from a Text Object"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The text object and the tools that follow form an extremely important toolkit of any text miner or computational linguist. They allow us to visually inspect the properties of our text (collection/corpus)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Text: Sense and Sensibility by Jane Austen 1811>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.text2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Text: The Book of Genesis>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.text3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "b.text3.plot?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "nltk.probability.FreqDist.plot?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Show the most frequent tokens in a text; note the Zipfian distributions!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "260819\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(20,10))\n",
    "print(len(b.text1))\n",
    "b.text1.plot(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "141576\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(20,10))\n",
    "print(len(b.text2))\n",
    "b.text2.plot(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "44764\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(20,10))\n",
    "print(len(b.text3))\n",
    "b.text3.plot(100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the larger the \"buldge\" on the left and the wider the tail to the right, the larger the semantic richness of the text. Which of the books is semantically richer, then? Would you agree its book 2, \"Sense and Sensibility by Jane Austen 1811\"?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "b.text2.collocations?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Collocations** are pairs of words that occur together more frequently than would be expected by chance. Therefore, we can assume the pairs have semantics that go beyond the semantic of each individual word."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Colonel Brandon; Sir John; Lady Middleton; Miss Dashwood; every thing;\n",
      "thousand pounds; dare say; Miss Steeles; said Elinor; Miss Steele;\n",
      "every body; John Dashwood; great deal; Harley Street; Berkeley Street;\n",
      "Miss Dashwoods; young man; Combe Magna; every day; next morning\n"
     ]
    }
   ],
   "source": [
    "b.text2.collocations()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "b.text2.dispersion_plot?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In a nutshell, plot the occurrence of each word in the text. Lets look at the most frequent proper nouns (names) as we found above in the frequency plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "b.text2.dispersion_plot([\"Elinor\", \"Marianne\", \"Edward\", \"Dashwood\", \"Willoughby\", \"Lucy\", \"Brandon\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So this allows us to even quickly get a \"feel\" for the story itself, e.g., here you can easily tell who interacts with whom (or who not)!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NLTK's Discrete \"Frequency\" Distributions\n",
    "\n",
    "A counter for tokens."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nltk import FreqDist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "fdist = FreqDist(b.text2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('[', 3),\n",
       " ('Sense', 1),\n",
       " ('and', 3350),\n",
       " ('Sensibility', 1),\n",
       " ('by', 737),\n",
       " ('Jane', 1),\n",
       " ('Austen', 1),\n",
       " ('1811', 1),\n",
       " (']', 1),\n",
       " ('CHAPTER', 50)]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(fdist.items())[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "','"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fdist.max() # the word length with the highest count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3861"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fdist[\"the\"] # the count for the token \"the\" "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.027271571452788607"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fdist.freq(\"the\") # frequency/total_frequency => the probability of the token \"the\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy and SciPy: Numeric Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A good NumPy tutorial: [www.engr.ucsb.edu/~shell/che210d/numpy.pdf](http://www.engr.ucsb.edu/~shell/che210d/numpy.pdf)\n",
    "\n",
    "The API/reference for NumPy and SciPy: [docs.scipy.org/doc/](http://docs.scipy.org/doc/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# already done for us by the %pylab setup at the beginning:\n",
    "# import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NumPy Arrays as Vectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(10)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10,)"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.arange(10, 20)\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  0,  11,  24,  39,  56,  75,  96, 119, 144, 171])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a * b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "        True])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a < b # NumPy arrays generally behave simlarly to R vectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,\n",
       "       17, 18, 19])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = np.concatenate((a, b)) # NB that the argument to np.concatenate() is a SINGLE LIST\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([6, 7, 8, 9])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[a > 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "735"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.dot(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['lesser', 'lesser', 'lesser', 'lesser', 'lesser', 'lesser',\n",
       "       'greater', 'greater', 'greater', 'greater'], dtype='<U7')"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.where(a > 5, \"greater\", \"lesser\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.view?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hurray\n"
     ]
    }
   ],
   "source": [
    "if 5 in a:\n",
    "    print(\"hurray\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5.0 in a # \"a\" is a list of integers, \"5.0\" is a float"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Array Statistics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's convert our `wlens` list from the NLTK part to a NumPy array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "wlarr = np.array(wlens)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "999044"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wlarr.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.830411128023649"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wlarr.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.892518355697793"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wlarr.var()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.427450999649178"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wlarr.std()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wlarr.min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wlarr.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "wlarr.argmax?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wlarr[wlarr.argmax()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "wlarr.sort()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wlarr[len(wlarr)//2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.median(wlarr) # NB: median is not a method defined on array!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arrays as Matrices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 1.],\n",
       "       [2., 3.]])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[0, 1], [2, 3]], float)\n",
    "b = np.array([2, 3], float)\n",
    "c = np.array([[1, 1], [4, 0]], float)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2)"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 3.],\n",
       "       [4., 9.]])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b * a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 6., 11.])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.dot(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 4.,  0.],\n",
       "       [14.,  2.]])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.dot(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2.,  0.])"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.cross(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3., 13.])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.inner(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0.],\n",
       "       [2., 3.],\n",
       "       [4., 6.],\n",
       "       [6., 9.]])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.outer(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Linear Algebra Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-2.0"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.det(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([-0.56155281,  3.56155281]), array([[-0.87192821, -0.27032301],\n",
       "        [ 0.48963374, -0.96276969]]))"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.eig(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-1.5,  0.5],\n",
       "       [ 1. ,  0. ]])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.inv(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[-0.22975292, -0.97324899],\n",
       "        [-0.97324899,  0.22975292]]),\n",
       " array([3.70245917, 0.54018151]),\n",
       " array([[-0.52573111, -0.85065081],\n",
       "        [ 0.85065081, -0.52573111]]))"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.svd(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Advanced Linear Algrebra"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy import linalg as la"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[-0.22975292, -0.97324899],\n",
       "        [-0.97324899,  0.22975292]]),\n",
       " array([3.70245917, 0.54018151]),\n",
       " array([[-0.52573111, -0.85065081],\n",
       "        [ 0.85065081, -0.52573111]]))"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "la.svd(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24.1 µs ± 1.23 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit np.linalg.svd(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "82 µs ± 6.33 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit la.svd(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Other important functionalty provided by SciPy modules:\n",
    "\n",
    "* `constants` - a huge list of math/phys constants\n",
    "* `integrate` - numerical integration/ODEs\n",
    "* `optimize` - optimization functions (e.g., BFGS is here)\n",
    "* `sparse` - working with large, sparse matrices\n",
    "* `interpolate` - interpolation for discrete data (linear and spline)\n",
    "* `fftpack` - Fast Fourier transform routines\n",
    "* `signal` - Signal processing (time-series analysis)\n",
    "* **`stats`** - a huge collection of distribtuions and functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Statistical Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Three variables, four instances:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = np.array([[1, 2, 1, 3], [5, 3, 1, 8], [2, 1, 5, 6]], float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.        , 0.72870505, 0.36563621],\n",
       "       [0.72870505, 1.        , 0.30480845],\n",
       "       [0.36563621, 0.30480845, 1.        ]])"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.corrcoef(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.91666667, 2.08333333, 0.83333333],\n",
       "       [2.08333333, 8.91666667, 2.16666667],\n",
       "       [0.83333333, 2.16666667, 5.66666667]])"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.cov(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy import stats # by the way, \"RV\" means \"random variable\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "stats.norm.pdf?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.24197072, 0.39894228, 0.24197072])"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = stats.norm.pdf([-1.0, 0.0, 1.0])\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.24197072451914337"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.3989422804014327"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.2942945764799065"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For more info on working with distributions, have a look at the SciPy stats tutorial at [docs.scipy.org/doc/scipy/reference/tutorial/stats.html](http://docs.scipy.org/doc/scipy/reference/tutorial/stats.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Simple Barcharts with MatPlotLib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`matplotlib` is slightly over-enginered, particularly if you are used to R's `ggplot`: Just plotting a barchart for a dictionary of word counts can be a challenge for beginners. Here's how..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {'word': 3, 'other': 7, 'another': 2, 'hello': 5, 'plot': 4}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "rng = np.arange(len(d))\n",
    "words, counts = zip(*d.items())\n",
    "ax.bar(rng, counts)\n",
    "ax.set_xticks(rng + 0.4)\n",
    "ax.set_xticklabels(words)\n",
    "fig.autofmt_xdate()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's implement this as a function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "def wordchart(counts):\n",
    "    fig = plt.figure()\n",
    "    ax = fig.add_subplot(111)\n",
    "    rng = np.arange(len(counts))\n",
    "    words, counts = zip(*counts.items())\n",
    "    ax.bar(rng, counts)\n",
    "    ax.set_xticks(rng + 0.4)\n",
    "    ax.set_xticklabels(words)\n",
    "    fig.autofmt_xdate()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "wordchart(d)"
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}