V04-Waffle-Charts-Word-Clouds-and-Regression-Plots-py.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "<a href=\"https://cognitiveclass.ai\"><img src = \"https://ibm.box.com/shared/static/9gegpsmnsoo25ikkbl4qzlvlyjbgxs5x.png\" width = 400> </a>\n",
    "\n",
    "<h1 align=center><font size = 5>Waffle Charts, Word Clouds, and Regression Plots</font></h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Introduction\n",
    "\n",
    "In this lab, we will learn how to create word clouds and waffle charts. Furthermore, we will start learning about additional visualization libraries that are based on Matplotlib, namely the library *seaborn*, and we will learn how to create regression plots using the *seaborn* library."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Table of Contents\n",
    "\n",
    "<div class=\"alert alert-block alert-info\" style=\"margin-top: 20px\">\n",
    "\n",
    "1. [Exploring Datasets with *p*andas](#0)<br>\n",
    "2. [Downloading and Prepping Data](#2)<br>\n",
    "3. [Visualizing Data using Matplotlib](#4) <br>\n",
    "4. [Waffle Charts](#6) <br>\n",
    "5. [Word Clouds](#8) <br>\n",
    "7. [Regression Plots](#10) <br> \n",
    "</div>\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# Exploring Datasets with *pandas* and Matplotlib<a id=\"0\"></a>\n",
    "\n",
    "Toolkits: The course heavily relies on [*pandas*](http://pandas.pydata.org/) and [**Numpy**](http://www.numpy.org/) for data wrangling, analysis, and visualization. The primary plotting library we will explore in the course is [Matplotlib](http://matplotlib.org/).\n",
    "\n",
    "Data set: Immigration to Canada from 1980 to 2013 - [International migration flows to and from selected countries - The 2015 revision](http://www.un.org/en/development/desa/population/migration/data/empirical2/migrationflows.shtml) from United Nation's website\n",
    "\n",
    "The dataset contains annual data on the flows of international migrants as recorded by the countries of destination. The data presents both inflows and outflows according to the place of birth, citizenship or place of previous / next residence both for foreigners and nationals. In this lab, we will focus on the Canadian Immigration data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# Downloading and Prepping Data <a id=\"2\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Import Primary Modules:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "ERROR:root:Internal Python error in the inspect module.\n",
      "Below is the traceback from this internal error.\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Traceback (most recent call last):\n",
      "  File \"/opt/conda/lib/python3.7/site-packages/IPython/core/interactiveshell.py\", line 3296, in run_code\n",
      "    exec(code_obj, self.user_global_ns, self.user_ns)\n",
      "  File \"<ipython-input-1-bb8dff2bb480>\", line 2, in <module>\n",
      "    import pandas as pd # primary data structure library\n",
      "  File \"/opt/conda/lib/python3.7/site-packages/pandas/__init__.py\", line 42, in <module>\n",
      "    from pandas.core.api import *\n",
      "  File \"/opt/conda/lib/python3.7/site-packages/pandas/core/api.py\", line 26, in <module>\n",
      "    from pandas.core.groupby import Grouper\n",
      "  File \"/opt/conda/lib/python3.7/site-packages/pandas/core/groupby/__init__.py\", line 1, in <module>\n",
      "    from pandas.core.groupby.groupby import GroupBy  # noqa: F401\n",
      "  File \"/opt/conda/lib/python3.7/site-packages/pandas/core/groupby/groupby.py\", line 37, in <module>\n",
      "    from pandas.core.frame import DataFrame\n",
      "  File \"/opt/conda/lib/python3.7/site-packages/pandas/core/frame.py\", line 100, in <module>\n",
      "    from pandas.core.series import Series\n",
      "  File \"/opt/conda/lib/python3.7/site-packages/pandas/core/series.py\", line 51, in <module>\n",
      "    import pandas.plotting._core as gfx\n",
      "  File \"/opt/conda/lib/python3.7/site-packages/pandas/plotting/__init__.py\", line 11, in <module>\n",
      "    from pandas.plotting._core import boxplot\n",
      "  File \"/opt/conda/lib/python3.7/site-packages/pandas/plotting/_core.py\", line 36, in <module>\n",
      "    from pandas.plotting import _converter\n",
      "  File \"/opt/conda/lib/python3.7/site-packages/pandas/plotting/_converter.py\", line 6, in <module>\n",
      "    import matplotlib.dates as dates\n",
      "  File \"/opt/conda/lib/python3.7/site-packages/matplotlib/__init__.py\", line 1099, in <module>\n",
      "    rcParams = rc_params()\n",
      "  File \"/opt/conda/lib/python3.7/site-packages/matplotlib/__init__.py\", line 940, in rc_params\n",
      "    fname = matplotlib_fname()\n",
      "  File \"/opt/conda/lib/python3.7/site-packages/matplotlib/__init__.py\", line 746, in matplotlib_fname\n",
      "    for fname in gen_candidates():\n",
      "  File \"/opt/conda/lib/python3.7/site-packages/matplotlib/__init__.py\", line 735, in gen_candidates\n",
      "    yield os.path.join(os.getcwd(), 'matplotlibrc')\n",
      "FileNotFoundError: [Errno 2] No such file or directory\n",
      "\n",
      "During handling of the above exception, another exception occurred:\n",
      "\n",
      "Traceback (most recent call last):\n",
      "  File \"/opt/conda/lib/python3.7/site-packages/IPython/core/interactiveshell.py\", line 2033, in showtraceback\n",
      "    stb = value._render_traceback_()\n",
      "AttributeError: 'FileNotFoundError' object has no attribute '_render_traceback_'\n",
      "\n",
      "During handling of the above exception, another exception occurred:\n",
      "\n",
      "Traceback (most recent call last):\n",
      "  File \"/opt/conda/lib/python3.7/site-packages/IPython/core/ultratb.py\", line 1095, in get_records\n",
      "    return _fixed_getinnerframes(etb, number_of_lines_of_context, tb_offset)\n",
      "  File \"/opt/conda/lib/python3.7/site-packages/IPython/core/ultratb.py\", line 313, in wrapped\n",
      "    return f(*args, **kwargs)\n",
      "  File \"/opt/conda/lib/python3.7/site-packages/IPython/core/ultratb.py\", line 347, in _fixed_getinnerframes\n",
      "    records = fix_frame_records_filenames(inspect.getinnerframes(etb, context))\n",
      "  File \"/opt/conda/lib/python3.7/inspect.py\", line 1502, in getinnerframes\n",
      "    frameinfo = (tb.tb_frame,) + getframeinfo(tb, context)\n",
      "  File \"/opt/conda/lib/python3.7/inspect.py\", line 1460, in getframeinfo\n",
      "    filename = getsourcefile(frame) or getfile(frame)\n",
      "  File \"/opt/conda/lib/python3.7/inspect.py\", line 696, in getsourcefile\n",
      "    if getattr(getmodule(object, filename), '__loader__', None) is not None:\n",
      "  File \"/opt/conda/lib/python3.7/inspect.py\", line 725, in getmodule\n",
      "    file = getabsfile(object, _filename)\n",
      "  File \"/opt/conda/lib/python3.7/inspect.py\", line 709, in getabsfile\n",
      "    return os.path.normcase(os.path.abspath(_filename))\n",
      "  File \"/opt/conda/lib/python3.7/posixpath.py\", line 383, in abspath\n",
      "    cwd = os.getcwd()\n",
      "FileNotFoundError: [Errno 2] No such file or directory\n"
     ]
    },
    {
     "ename": "FileNotFoundError",
     "evalue": "[Errno 2] No such file or directory",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m\u001b[0m"
     ]
    }
   ],
   "source": [
    "import numpy as np  # useful for many scientific computing in Python\n",
    "import pandas as pd # primary data structure library\n",
    "from PIL import Image # converting images into arrays\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Let us download and import our primary Canadian Immigration dataset using *pandas* `read_excel()` method. But before we can do that, we need to download a module on which *pandas* requires to read in excel files. This module is **xlrd**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Download the dataset and read it into a *pandas* dataframe:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "df_can = pd.read_csv(\"./data/df_can.csv\")\n",
    "print('Data downloaded and read into a dataframe!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Let's take a look at the first five items in our dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "df_can.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Let's find out how many entries there are in our dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# print the dimensions of the dataframe\n",
    "print(df_can.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# set the country name as index - useful for quickly looking up countries using .loc method\n",
    "df_can.set_index('Country', inplace = True)\n",
    "\n",
    "# years that we will be using in this lesson - useful for plotting later on\n",
    "years = list(map(str, range(1980, 2014)))\n",
    "print ('data dimensions:', df_can.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# Visualizing Data using Matplotlib<a id=\"4\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Import `matplotlib`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.patches as mpatches # needed for waffle Charts\n",
    "\n",
    "mpl.style.use('ggplot') # optional: for ggplot-like style\n",
    "\n",
    "# check for latest version of Matplotlib\n",
    "print ('Matplotlib version: ', mpl.__version__ ) # >= 2.0.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# Waffle Charts <a id=\"6\"></a>\n",
    "\n",
    "\n",
    "A `waffle chart` is an interesting visualization that is normally created to display progress toward goals. It is commonly an effective option when you are trying to add interesting visualization features to a visual that consists mainly of cells, such as an Excel dashboard."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Let's revisit the previous case study about Denmark, Norway, and Sweden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# let's create a new dataframe for these three countries \n",
    "df_dsn = df_can.loc[['Denmark', 'Norway', 'Sweden'], :]\n",
    "\n",
    "# let's take a look at our dataframe\n",
    "df_dsn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Unfortunately, Unlike R, `waffle` charts are not built into any of the Python visualization libraries. Therefore, we will learn how to create them from scratch."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "**Step 1.** The first step into creating a waffle chart is determing the proportion of each category with respect to the total."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# compute the proportion of each category with respect to the total\n",
    "total_values = sum(df_dsn['Total'])\n",
    "category_proportions = [(float(value) / total_values) for value in df_dsn['Total']]\n",
    "\n",
    "# print out proportions\n",
    "for i, proportion in enumerate(category_proportions):\n",
    "    print (df_dsn.index.values[i] + ': ' + str(proportion))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "**Step 2.** The second step is defining the overall size of the `waffle` chart."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "width = 40 # width of chart\n",
    "height = 10 # height of chart\n",
    "\n",
    "total_num_tiles = width * height # total number of tiles\n",
    "\n",
    "print ('Total number of tiles is ', total_num_tiles)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "**Step 3.** The third step is using the proportion of each category to determe it respective number of tiles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# compute the number of tiles for each catagory\n",
    "tiles_per_category = [round(proportion * total_num_tiles) for proportion in category_proportions]\n",
    "\n",
    "# print out number of tiles per category\n",
    "for i, tiles in enumerate(tiles_per_category):\n",
    "    print (df_dsn.index.values[i] + ': ' + str(tiles))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Based on the calculated proportions, Denmark will occupy 129 tiles of the `waffle` chart, Norway will occupy 77 tiles, and Sweden will occupy 194 tiles."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "**Step 4.** The fourth step is creating a matrix that resembles the `waffle` chart and populating it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# initialize the waffle chart as an empty matrix\n",
    "waffle_chart = np.zeros((height, width))\n",
    "\n",
    "# define indices to loop through waffle chart\n",
    "category_index = 0\n",
    "tile_index = 0\n",
    "\n",
    "# populate the waffle chart\n",
    "for col in range(width):\n",
    "    for row in range(height):\n",
    "        tile_index += 1\n",
    "\n",
    "        # if the number of tiles populated for the current category is equal to its corresponding allocated tiles...\n",
    "        if tile_index > sum(tiles_per_category[0:category_index]):\n",
    "            # ...proceed to the next category\n",
    "            category_index += 1       \n",
    "            \n",
    "        # set the class value to an integer, which increases with class\n",
    "        waffle_chart[row, col] = category_index\n",
    "        \n",
    "print ('Waffle chart populated!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Let's take a peek at how the matrix looks like."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "waffle_chart"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "As expected, the matrix consists of three categories and the total number of each category's instances matches the total number of tiles allocated to each category."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "**Step 5.** Map the `waffle` chart matrix into a visual."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# instantiate a new figure object\n",
    "fig = plt.figure()\n",
    "\n",
    "# use matshow to display the waffle chart\n",
    "colormap = plt.cm.coolwarm\n",
    "plt.matshow(waffle_chart, cmap=colormap)\n",
    "plt.colorbar()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "**Step 6.** Prettify the chart."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# instantiate a new figure object\n",
    "fig = plt.figure()\n",
    "\n",
    "# use matshow to display the waffle chart\n",
    "colormap = plt.cm.coolwarm\n",
    "plt.matshow(waffle_chart, cmap=colormap)\n",
    "plt.colorbar()\n",
    "\n",
    "# get the axis\n",
    "ax = plt.gca()\n",
    "\n",
    "# set minor ticks\n",
    "ax.set_xticks(np.arange(-.5, (width), 1), minor=True)\n",
    "ax.set_yticks(np.arange(-.5, (height), 1), minor=True)\n",
    "    \n",
    "# add gridlines based on minor ticks\n",
    "ax.grid(which='minor', color='w', linestyle='-', linewidth=2)\n",
    "\n",
    "plt.xticks([])\n",
    "plt.yticks([])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "**Step 7.** Create a legend and add it to chart."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# instantiate a new figure object\n",
    "fig = plt.figure()\n",
    "\n",
    "# use matshow to display the waffle chart\n",
    "colormap = plt.cm.coolwarm\n",
    "plt.matshow(waffle_chart, cmap=colormap)\n",
    "plt.colorbar()\n",
    "\n",
    "# get the axis\n",
    "ax = plt.gca()\n",
    "\n",
    "# set minor ticks\n",
    "ax.set_xticks(np.arange(-.5, (width), 1), minor=True)\n",
    "ax.set_yticks(np.arange(-.5, (height), 1), minor=True)\n",
    "    \n",
    "# add gridlines based on minor ticks\n",
    "ax.grid(which='minor', color='w', linestyle='-', linewidth=2)\n",
    "\n",
    "plt.xticks([])\n",
    "plt.yticks([])\n",
    "\n",
    "# compute cumulative sum of individual categories to match color schemes between chart and legend\n",
    "values_cumsum = np.cumsum(df_dsn['Total'])\n",
    "total_values = values_cumsum[len(values_cumsum) - 1]\n",
    "\n",
    "# create legend\n",
    "legend_handles = []\n",
    "for i, category in enumerate(df_dsn.index.values):\n",
    "    label_str = category + ' (' + str(df_dsn['Total'][i]) + ')'\n",
    "    color_val = colormap(float(values_cumsum[i])/total_values)\n",
    "    legend_handles.append(mpatches.Patch(color=color_val, label=label_str))\n",
    "\n",
    "# add legend to chart\n",
    "plt.legend(handles=legend_handles,\n",
    "           loc='lower center', \n",
    "           ncol=len(df_dsn.index.values),\n",
    "           bbox_to_anchor=(0., -0.2, 0.95, .1)\n",
    "          )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "And there you go! What a good looking *delicious* `waffle` chart, don't you think?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Now it would very inefficient to repeat these seven steps every time we wish to create a `waffle` chart. So let's combine all seven steps into one function called *create_waffle_chart*. This function would take the following parameters as input:\n",
    "\n",
    "> 1. **categories**: Unique categories or classes in dataframe.\n",
    "> 2. **values**: Values corresponding to categories or classes.\n",
    "> 3. **height**: Defined height of waffle chart.\n",
    "> 4. **width**: Defined width of waffle chart.\n",
    "> 5. **colormap**: Colormap class\n",
    "> 6. **value_sign**: In order to make our function more generalizable, we will add this parameter to address signs that could be associated with a value such as %, $, and so on. **value_sign** has a default value of empty string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "def create_waffle_chart(categories, values, height, width, colormap, value_sign=''):\n",
    "\n",
    "    # compute the proportion of each category with respect to the total\n",
    "    total_values = sum(values)\n",
    "    category_proportions = [(float(value) / total_values) for value in values]\n",
    "\n",
    "    # compute the total number of tiles\n",
    "    total_num_tiles = width * height # total number of tiles\n",
    "    print ('Total number of tiles is', total_num_tiles)\n",
    "    \n",
    "    # compute the number of tiles for each catagory\n",
    "    tiles_per_category = [round(proportion * total_num_tiles) for proportion in category_proportions]\n",
    "\n",
    "    # print out number of tiles per category\n",
    "    for i, tiles in enumerate(tiles_per_category):\n",
    "        print (df_dsn.index.values[i] + ': ' + str(tiles))\n",
    "    \n",
    "    # initialize the waffle chart as an empty matrix\n",
    "    waffle_chart = np.zeros((height, width))\n",
    "\n",
    "    # define indices to loop through waffle chart\n",
    "    category_index = 0\n",
    "    tile_index = 0\n",
    "\n",
    "    # populate the waffle chart\n",
    "    for col in range(width):\n",
    "        for row in range(height):\n",
    "            tile_index += 1\n",
    "\n",
    "            # if the number of tiles populated for the current category \n",
    "            # is equal to its corresponding allocated tiles...\n",
    "            if tile_index > sum(tiles_per_category[0:category_index]):\n",
    "                # ...proceed to the next category\n",
    "                category_index += 1       \n",
    "            \n",
    "            # set the class value to an integer, which increases with class\n",
    "            waffle_chart[row, col] = category_index\n",
    "    \n",
    "    # instantiate a new figure object\n",
    "    fig = plt.figure()\n",
    "\n",
    "    # use matshow to display the waffle chart\n",
    "    colormap = plt.cm.coolwarm\n",
    "    plt.matshow(waffle_chart, cmap=colormap)\n",
    "    plt.colorbar()\n",
    "\n",
    "    # get the axis\n",
    "    ax = plt.gca()\n",
    "\n",
    "    # set minor ticks\n",
    "    ax.set_xticks(np.arange(-.5, (width), 1), minor=True)\n",
    "    ax.set_yticks(np.arange(-.5, (height), 1), minor=True)\n",
    "    \n",
    "    # add dridlines based on minor ticks\n",
    "    ax.grid(which='minor', color='w', linestyle='-', linewidth=2)\n",
    "\n",
    "    plt.xticks([])\n",
    "    plt.yticks([])\n",
    "\n",
    "    # compute cumulative sum of individual categories to match color schemes between chart and legend\n",
    "    values_cumsum = np.cumsum(values)\n",
    "    total_values = values_cumsum[len(values_cumsum) - 1]\n",
    "\n",
    "    # create legend\n",
    "    legend_handles = []\n",
    "    for i, category in enumerate(categories):\n",
    "        if value_sign == '%':\n",
    "            label_str = category + ' (' + str(values[i]) + value_sign + ')'\n",
    "        else:\n",
    "            label_str = category + ' (' + value_sign + str(values[i]) + ')'\n",
    "            \n",
    "        color_val = colormap(float(values_cumsum[i])/total_values)\n",
    "        legend_handles.append(mpatches.Patch(color=color_val, label=label_str))\n",
    "\n",
    "    # add legend to chart\n",
    "    plt.legend(\n",
    "        handles=legend_handles,\n",
    "        loc='lower center', \n",
    "        ncol=len(categories),\n",
    "        bbox_to_anchor=(0., -0.2, 0.95, .1)\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Now to create a `waffle` chart, all we have to do is call the function `create_waffle_chart`. Let's define the input parameters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "width = 40 # width of chart\n",
    "height = 10 # height of chart\n",
    "\n",
    "categories = df_dsn.index.values # categories\n",
    "values = df_dsn['Total'] # correponding values of categories\n",
    "\n",
    "colormap = plt.cm.coolwarm # color map class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "And now let's call our function to create a `waffle` chart."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "create_waffle_chart(categories, values, height, width, colormap)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# Word Clouds <a id=\"8\"></a>\n",
    "\n",
    "\n",
    "`Word` clouds (also known as text clouds or tag clouds) work in a simple way: the more a specific word appears in a source of textual data (such as a speech, blog post, or database), the bigger and bolder it appears in the word cloud."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Luckily, a library already exists in Python for generating `word` clouds. The library, called `word_cloud` was developed by **Andreas Mueller**. You can learn more about the library by following this [link](https://github.com/amueller/word_cloud/).\n",
    "\n",
    "Let's use this library to learn how to generate a word cloud for a given text document."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "First, let's install the library."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# install wordcloud\n",
    "!pip install wordcloud\n",
    "\n",
    "# import library and its set of stopwords\n",
    "from wordcloud import WordCloud, STOPWORDS\n",
    "\n",
    "print ('Wordcloud is installed and imported!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "`Word` clouds are commonly used to perform high-level analysis and visualization of text data. Accordinly, let's digress from the immigration dataset and work with an example that involves analyzing text data. Let's try to analyze a short novel written by **Lewis Carroll** titled *Alice's Adventures in Wonderland*. Let's go ahead and download a _.txt_ file of the novel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# download file and save as alice_novel.txt\n",
    "# !wget --quiet https://ibm.box.com/shared/static/m54sjtrshpt5su20dzesl5en9xa5vfz1.txt -O alice_novel.txt\n",
    "\n",
    "# open the file and read it into a variable alice_novel\n",
    "alice_novel = open('./data/alice.txt', 'r').read()\n",
    "    \n",
    "print ('File downloaded and saved!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Next, let's use the stopwords that we imported from `word_cloud`. We use the function *set* to remove any redundant stopwords."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "stopwords = set(STOPWORDS)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Create a word cloud object and generate a word cloud. For simplicity, let's generate a word cloud using only the first 2000 words in the novel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# instantiate a word cloud object\n",
    "alice_wc = WordCloud(\n",
    "    background_color='white',\n",
    "    max_words=2000,\n",
    "    stopwords=stopwords\n",
    ")\n",
    "\n",
    "# generate the word cloud\n",
    "alice_wc.generate(alice_novel)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Awesome! Now that the `word` cloud is created, let's visualize it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# display the word cloud\n",
    "plt.imshow(alice_wc, interpolation='bilinear')\n",
    "plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Interesting! So in the first 2000 words in the novel, the most common words are **Alice**, **said**, **little**, **Queen**, and so on. Let's resize the cloud so that we can see the less frequent words a little better."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "fig.set_figwidth(14) # set width\n",
    "fig.set_figheight(18) # set height\n",
    "\n",
    "# display the cloud\n",
    "plt.imshow(alice_wc, interpolation='bilinear')\n",
    "plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Much better! However, **said** isn't really an informative word. So let's add it to our stopwords and re-generate the cloud."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "stopwords.add('said') # add the words said to stopwords\n",
    "\n",
    "# re-generate the word cloud\n",
    "alice_wc.generate(alice_novel)\n",
    "\n",
    "# display the cloud\n",
    "fig = plt.figure()\n",
    "fig.set_figwidth(14) # set width\n",
    "fig.set_figheight(18) # set height\n",
    "\n",
    "plt.imshow(alice_wc, interpolation='bilinear')\n",
    "plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Excellent! This looks really interesting! Another cool thing you can implement with the `word_cloud` library is superimposing the words onto a mask of any shape. Let's use a mask of Alice and her rabbit. We already created the mask for you, so let's go ahead and download it and call it *alice_mask.png*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# download image\n",
    "!wget --quiet https://ibm.box.com/shared/static/3mpxgaf6muer6af7t1nvqkw9cqj85ibm.png -O alice_mask.png\n",
    "    \n",
    "# save mask to alice_mask\n",
    "alice_mask = np.array(Image.open('alice_mask.png'))\n",
    "    \n",
    "print('Image downloaded and saved!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Let's take a look at how the mask looks like."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "fig.set_figwidth(14) # set width\n",
    "fig.set_figheight(18) # set height\n",
    "\n",
    "plt.imshow(alice_mask, cmap=plt.cm.gray, interpolation='bilinear')\n",
    "plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Shaping the `word` cloud according to the mask is straightforward using `word_cloud` library. For simplicity, we will continue using the first 2000 words in the novel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# instantiate a word cloud object\n",
    "alice_wc = WordCloud(background_color='white', max_words=2000, mask=alice_mask, stopwords=stopwords)\n",
    "\n",
    "# generate the word cloud\n",
    "alice_wc.generate(alice_novel)\n",
    "\n",
    "# display the word cloud\n",
    "fig = plt.figure()\n",
    "fig.set_figwidth(14) # set width\n",
    "fig.set_figheight(18) # set height\n",
    "\n",
    "plt.imshow(alice_wc, interpolation='bilinear')\n",
    "plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Really impressive!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Unfortunately, our immmigration data does not have any text data, but where there is a will there is a way. Let's generate sample text data from our immigration dataset, say text data of 90 words."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Let's recall how our data looks like."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "df_can.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "And what was the total immigration from 1980 to 2013?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "total_immigration = df_can['Total'].sum()\n",
    "total_immigration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Using countries with single-word names, let's duplicate each country's name based on how much they contribute to the total immigration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "max_words = 90\n",
    "word_string = ''\n",
    "for country in df_can.index.values:\n",
    "    # check if country's name is a single-word name\n",
    "    if len(country.split(' ')) == 1:\n",
    "        repeat_num_times = int(df_can.loc[country, 'Total']/float(total_immigration)*max_words)\n",
    "        word_string = word_string + ((country + ' ') * repeat_num_times)\n",
    "                                     \n",
    "# display the generated text\n",
    "word_string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "We are not dealing with any stopwords here, so there is no need to pass them when creating the word cloud."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# create the word cloud\n",
    "wordcloud = WordCloud(background_color='white').generate(word_string)\n",
    "\n",
    "print('Word cloud created!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# display the cloud\n",
    "fig = plt.figure()\n",
    "fig.set_figwidth(14)\n",
    "fig.set_figheight(18)\n",
    "\n",
    "plt.imshow(wordcloud, interpolation='bilinear')\n",
    "plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "According to the above word cloud, it looks like the majority of the people who immigrated came from one of 15 countries that are displayed by the word cloud. One cool visual that you could build, is perhaps using the map of Canada and a mask and superimposing the word cloud on top of the map of Canada. That would be an interesting visual to build!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# Regression Plots <a id=\"10\"></a>\n",
    "\n",
    "\n",
    "> Seaborn is a Python visualization library based on matplotlib. It provides a high-level interface for drawing attractive statistical graphics. You can learn more about *seaborn* by following this [link](https://seaborn.pydata.org/) and more about *seaborn* regression plots by following this [link](http://seaborn.pydata.org/generated/seaborn.regplot.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "In lab *Pie Charts, Box Plots, Scatter Plots, and Bubble Plots*, we learned how to create a scatter plot and then fit a regression line. It took ~20 lines of code to create the scatter plot along with the regression fit. In this final section, we will explore *seaborn* and see how efficient it is to create regression lines and fits using this library!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Let's first install *seaborn*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# install seaborn\n",
    "# !pip install seaborn\n",
    "\n",
    "# import library\n",
    "import seaborn as sns\n",
    "\n",
    "print('Seaborn installed and imported!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Create a new dataframe that stores that total number of landed immigrants to Canada per year from 1980 to 2013."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# we can use the sum() method to get the total population per year\n",
    "df_tot = pd.DataFrame(df_can[years].sum(axis=0))\n",
    "\n",
    "# change the years to type float (useful for regression later on)\n",
    "df_tot.index = map(float,df_tot.index)\n",
    "\n",
    "# reset the index to put in back in as a column in the df_tot dataframe\n",
    "df_tot.reset_index(inplace = True)\n",
    "\n",
    "# rename columns\n",
    "df_tot.columns = ['year', 'total']\n",
    "\n",
    "# view the final dataframe\n",
    "df_tot.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "With *seaborn*, generating a regression plot is as simple as calling the **regplot** function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "ax = sns.regplot(x='year', y='total', data=df_tot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "This is not magic; it is *seaborn*! You can also customize the color of the scatter plot and regression line. Let's change the color to green."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "ax = sns.regplot(x='year', y='total', data=df_tot, color='green')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "You can always customize the marker shape, so instead of circular markers, let's use '+'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "ax = sns.regplot(x='year', y='total', data=df_tot, color='green', marker='+')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Let's blow up the plot a little bit so that it is more appealing to the sight."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(15, 10))\n",
    "ax = sns.regplot(x='year', y='total', data=df_tot, color='green', marker='+')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "And let's increase the size of markers so they match the new size of the figure, and add a title and x- and y-labels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(15, 10))\n",
    "ax = sns.regplot(x='year', y='total', data=df_tot, color='green', marker='+', scatter_kws={'s': 200})\n",
    "\n",
    "ax.set(xlabel='Year', ylabel='Total Immigration') # add x- and y-labels\n",
    "ax.set_title('Total Immigration to Canada from 1980 - 2013') # add title"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "And finally increase the font size of the tickmark labels, the title, and the x- and y-labels so they don't feel left out!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(15, 10))\n",
    "\n",
    "sns.set(font_scale=1.5)\n",
    "\n",
    "ax = sns.regplot(x='year', y='total', data=df_tot, color='green', marker='+', scatter_kws={'s': 200})\n",
    "ax.set(xlabel='Year', ylabel='Total Immigration')\n",
    "ax.set_title('Total Immigration to Canada from 1980 - 2013')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Amazing! A complete scatter plot with a regression fit with 5 lines of code only. Isn't this really amazing?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "If you are not a big fan of the purple background, you can easily change the style to a white plain background."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(15, 10))\n",
    "\n",
    "sns.set(font_scale=1.5)\n",
    "sns.set_style('ticks') # change background to white background\n",
    "\n",
    "ax = sns.regplot(x='year', y='total', data=df_tot, color='green', marker='+', scatter_kws={'s': 200})\n",
    "ax.set(xlabel='Year', ylabel='Total Immigration')\n",
    "ax.set_title('Total Immigration to Canada from 1980 - 2013')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Or to a white background with gridlines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(15, 10))\n",
    "\n",
    "sns.set(font_scale=1.5)\n",
    "sns.set_style('whitegrid')\n",
    "\n",
    "ax = sns.regplot(x='year', y='total', data=df_tot, color='green', marker='+', scatter_kws={'s': 200})\n",
    "ax.set(xlabel='Year', ylabel='Total Immigration')\n",
    "ax.set_title('Total Immigration to Canada from 1980 - 2013')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### Thank you for completing this lab!\n",
    "\n",
    "This notebook was created by [Alex Aklson](https://www.linkedin.com/in/aklson/). I hope you found this lab interesting and educational. Feel free to contact me if you have any questions!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "This notebook is part of the free course on **Cognitive Class** called *Data Visualization with Python*. If you accessed this notebook outside the course, you can take this free self-paced course, online by clicking [here](https://cocl.us/DV0101EN_Lab4)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "<hr>\n",
    "Copyright &copy; 2017 [Cognitive Class](https://cognitiveclass.ai/?utm_source=bducopyrightlink&utm_medium=dswb&utm_campaign=bdu). This notebook and its source code are released under the terms of the [MIT License](https://bigdatauniversity.com/mit-license/)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}