F0C-10-Subplots.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# FLIP (00): Data Science \n",
    "**(Module 02: Data Visualization)**\n",
    "\n",
    "---\n",
    "- Materials in this module include resources collected from various open-source online repositories.\n",
    "- You are free to use,but NOT allowed to change and distribute this package.\n",
    "\n",
    "Prepared by and for \n",
    "**Student Members** |\n",
    "2006-2023 [TULIP Lab](http://www.tulip.org.au), Australia\n",
    "\n",
    "---\n",
    "\n",
    "\n",
    "# Session K - Subplots\n",
    "\n",
    "In our previous lesson, we used a scatterplot to look at pairs of features from the data set in an effort to determine which pair would be best for predicting a flower's species. At the time, we didn't know how to show more than one plot in a single figure, so it was tough to compare the different feature pairings to find the best predictor, but in this lesson we'll see how to display multiple plots in a single figure using the `subplot` function. \n",
    "\n",
    "But, before we can learn anything about subplotting, we need to setup our notebook and pull in a data set, so let's go ahead and do that now."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "from IPython.display import set_matplotlib_formats\n",
    "set_matplotlib_formats('retina')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Getting the Data\n",
    "\n",
    "Once again, we'll be using the [Iris data set][1] from the [UCI Machine Learning Repository][2] to play around with matplotlib's subplotting features. The code below was taken from the earlier lessons and will download and load the data set into a variable called `data`.\n",
    "\n",
    "[1]: https://archive.ics.uci.edu/ml/datasets/Iris\n",
    "[2]: http://archive.ics.uci.edu/ml/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv\n",
    "import urllib.request\n",
    "from collections import namedtuple\n",
    "\n",
    "# Create a namedtuple constructor for each record in the Iris data\n",
    "#    1. sepal length in cm\n",
    "#    2. sepal width in cm\n",
    "#    3. petal length in cm\n",
    "#    4. petal width in cm\n",
    "#    5. class: \n",
    "#       -- Iris-setosa\n",
    "#       -- Iris-versicolour\n",
    "#       -- Iris-virginica\n",
    "fields = ('sepal_length', \n",
    "          'sepal_width', \n",
    "          'petal_length', \n",
    "          'petal_width', \n",
    "          'species')\n",
    "IrisRecord = namedtuple('IrisRecord', fields)\n",
    "\n",
    "# Download and read in the data from the UCI Machine Learning Repository\n",
    "response = urllib.request.urlopen('https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data')\n",
    "iris_data_csv = response.read().strip()\n",
    "\n",
    "# Convert each record into a format that's easier to work with (i.e.,\n",
    "# wrap each record in the namedtuple that we created).\n",
    "data = []\n",
    "for row in csv.reader(iris_data_csv.splitlines()):\n",
    "    data.append(IrisRecord(\n",
    "        sepal_length          = float(row[0]),\n",
    "        sepal_width           = float(row[1]),\n",
    "        petal_length          = float(row[2]),\n",
    "        petal_width           = float(row[3]),\n",
    "        species               = row[4]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating the `scatter` Function\n",
    "\n",
    "Now, we could copy and paste the code we used for drawing our scatterplots for each plot we want to make, but that's a bit tedious and error prone. So, for this lesson, we'll grab the code from the 'More Plotting' lesson, and wrap it in a function that will allow us to create scatterplots for different pairs of features with just a single line of code.\n",
    "\n",
    "The code below creates a function called `scatter` that takes a 2D matrix of data and several keyword variables that allow us to describe which data we wish to plot as well as some of the aesthetic attributes of the plot such as `x` and `y` labels and legend location."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import cycle\n",
    "from collections import defaultdict\n",
    "\n",
    "def scatter(m, x=None, y=None, target=None, x_label=None, y_label=None, loc='upper right'):\n",
    "    \"\"\"Takes a 2D matrix and keys for getting the x and y values\n",
    "    \n",
    "    The x, y, and target parameters are either getter functions \n",
    "    that will be used to extract their corresponding values from\n",
    "    each row, or they are strings which will be used with the\n",
    "    getattr function to extract the value. If None, it is assumed\n",
    "    that the x and y values are the first and second in the row\n",
    "    and the target value is the last value in the row.\n",
    "    \"\"\"        \n",
    "    # Create a color map of species names to colors\n",
    "    color_cycler = cycle(plt.rcParams['axes.prop_cycle'])\n",
    "    cmap = defaultdict(lambda: next(color_cycler)['color'])\n",
    "    \n",
    "    # Create the x, y, and target values getter functions,\n",
    "    # and create human readable x and y labels if none \n",
    "    # were passed in.\n",
    "    if x is None:\n",
    "        x_getter = lambda r: r[0]\n",
    "    elif isinstance(x, str):\n",
    "        if x_label is None:\n",
    "            x_label = x.replace('_', ' ').title()\n",
    "        x_getter = lambda r: getattr(r, x) \n",
    "    else:\n",
    "        x_getter = x\n",
    "        \n",
    "    if y is None:\n",
    "        y_getter = lambda r: r[1]\n",
    "    elif isinstance(y, str):\n",
    "        if y_label is None:\n",
    "            y_label = y.replace('_', ' ').title()\n",
    "        y_getter = lambda r: getattr(r, y) \n",
    "    else:\n",
    "        y_getter = y\n",
    "        \n",
    "    if target is None:\n",
    "        target_getter = lambda r: r[-1]\n",
    "    elif isinstance(target, str):\n",
    "        target_getter = lambda r: getattr(r, target)\n",
    "    else:\n",
    "        target_getter = target\n",
    "    \n",
    "    # Extract the x and y values (i.e., sepal length and width)\n",
    "    # from the data set. Also, create a list of corresponding\n",
    "    # colors based on the species of each record.\n",
    "    _x, _y, colors = [], [], []\n",
    "    for r in data:\n",
    "        _x.append(x_getter(r))\n",
    "        _y.append(y_getter(r))\n",
    "        colors.append(cmap[target_getter(r)])\n",
    "\n",
    "    # Plot the data on a scatter plot. Each point will have an outline \n",
    "    # color according to their species, but we'll leave the centers \n",
    "    # colorless (for aesthetic purposes only). Finally, we'll reduce\n",
    "    # the line width of each data point (again for aesthetics only).\n",
    "    plt.scatter(_x, _y, edgecolors=colors, c='none', linewidths=0.5)\n",
    "\n",
    "    # Add x and y labels\n",
    "    if x_label is not None:\n",
    "        plt.xlabel(x_label)\n",
    "    if y_label is not None:\n",
    "        plt.ylabel(y_label)\n",
    "    \n",
    "    # Get the list of classes for the target variable\n",
    "    classes = list(set(r[-1] for r in m))\n",
    "\n",
    "    # Create a few \"proxy artists\" for creating the legend. Calling the \n",
    "    # legend() function without passing in any parameters will create a\n",
    "    # legend for any labeled data in the graph, so we could do something\n",
    "    # funky where we add a label for one line per species, but that \n",
    "    # doesn't seem as simple and clean as just creating a few lines that\n",
    "    # we use just to create the legend. Plus, this is an officially \n",
    "    # sanctioned way to create a legend (just see the legend docs).\n",
    "    legend_handles = [plt.Line2D([], [], color=cmap[cls], label=cls) for cls in classes]\n",
    "    plt.legend(handles=legend_handles, loc=loc);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Drawing Multiple Plots With `subplot`\n",
    "\n",
    "The `subplot` function can be used to create a single plot in a grid of subplots. It takes three integer values: the first two describe the shape of the grid and the third is the index of the subplot you want to create. So, for example, if we wanted to create a pair of subplots, one beside the other horizontally, we would call the `subplot` function with the first number set to 1, to signify that our grid will have 1 row, and the second number set to 2, to signify that our grid will contain 2 columns. Our grid would then contain 2 sublots, numbered 1 and 2, since the `subplot` function assumes that subplots are indexed starting at 1.\n",
    "\n",
    "Let's try creating that horizontal grid of subplots now. \n",
    "\n",
    "The very first thing we'll do is adjust the width of our figure slightly, otherwise, we'll end up with two very narrow subplots since the default width is only appropriate for a single plot. On line 2, you can see the code makes a call to the `pyplot.gcf` function to get the current `Figure` object, and then it calls the `Figure.set_figwidth` function to adjust the width of the figure. Next, on line 5, we'll call the `subplot` function to create the first plot in the grid. This call will create an instance of the `Axes` class and set it as the current axes object on the current figure. Then, we'll call the `scatter` function we created above, pass in our data, and specify the sepal length and width as the features we want to show in our first plot.\n",
    "\n",
    "To plot the second scatterplot, you simply call the `subplot` function again with the same number of rows and columns, but this time with the index value of the next plot in the grid, that would be the number 2 in this case. Notice, in this call, however, that we are passing in the single value `122` rather than three separate integer values. This is a shorthand that the `subplot` function allows if you have a grid that has less than 10 subplots in it. Finally, on the last line, we call our `scatter` function again, this time with the petal dimensions and a different location for the legend so as to not obscure the data in the graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Adjust the width to fit two plots side-by-side\n",
    "plt.gcf().set_figwidth(12)\n",
    "\n",
    "# Create the first plot in a 1x2 grid\n",
    "plt.subplot(1, 2, 1)\n",
    "scatter(data, 'sepal_length', 'sepal_width')\n",
    "\n",
    "# Create the second plot in a 1x2 grid.\n",
    "# For grids that have less than 10 subplots, you can use\n",
    "# the shorthand below where you leave out the commas between\n",
    "# the number of rows, number of columns, and index values.\n",
    "plt.subplot(122)\n",
    "scatter(data, 'petal_length', 'petal_width', loc='upper left')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looks pretty nice, right? And, viewing the data side-by-side like this makes it so much easier to see the magnitude of the effect that different feature pairs have on the clustering of our data. \n",
    "\n",
    "Let's switch it up a little bit though, and do the same thing vertically. The code below displays the same set of scatterplots, but this time, we'll display them in a single column instead of a single row. We'll also use the `subplots` function this time to create the entire grid of `Axes` objects ahead of time. \n",
    "\n",
    "The important lines in this code are lines 5, 13, and 17. First, take a look at line 5. As I mentioned, this time around we're calling the `subplots` function instead of the singular `subplot` function. The difference is that `subplot` creates only a single `Axes` object when it's called, so you build up your grid one `Axes` object at a time. The `subplots` function, on the other hand, creates the entire grid of `Axes` objects at once and returns them, along with the current `Figure`, in a tuple. On line 5, we call the `subplots` function to create a 2 row by 1 column grid, and we capture the `Axes` objects returned in the variables `ax1` and `ax2`.\n",
    "\n",
    "On lines 13 and 17, we see next bit of code that differs from the previous example. Since we're no longer creating each subplot as we need them, we'll need to set the current subplot, or axes, before we can draw each scatterplot. To do so, we have to call the set current axes function, `plt.sca`, and pass in the `Axes` object that we want to plot our data on. Once we've set the current axes, we can call our `scatter` function and it will draw the scatterplot using the `Axes` object we just set as the current axes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The difference between the subplot and subplots\n",
    "# functions is that the former creates a single \n",
    "# axes object every time it's called, whereas the\n",
    "# the latter creates all of the axes objects at once.\n",
    "fig, (ax1, ax2) = plt.subplots(2, 1)\n",
    "fig.set_figheight(10)\n",
    "\n",
    "# Since we created all of the xes objects ahead of time, \n",
    "# we have to set the current axes ourselves before calling\n",
    "# the scatter function. Below we set the current axes to \n",
    "# the first Axes object before plotting the sepal dimensions.\n",
    "plt.sca(ax1)\n",
    "scatter(data, 'sepal_length', 'sepal_width', loc='upper right')\n",
    "\n",
    "# Plot the petal dimensions in the second axes\n",
    "plt.sca(ax2)\n",
    "scatter(data, 'petal_length', 'petal_width', loc='upper left')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One of the things we didn't see though, was how to adjust some of the parameters of the grid, like the spacing between subplots for example. In this lesson, we'll take a quick look at some of the options that you have for adjusting these parameters to make your subplots look as nice and readable as possible.\n",
    "\n",
    "Let's go ahead and jump right into the code.\n",
    "\n",
    "## Adjusting Subplots\n",
    "\n",
    "In the code below we use the `subplots` function to create a 3x2 grid. Let's run it and see how it looks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.subplots(3, 2);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tight Layout\n",
    "\n",
    "It doesn't look too bad, but the vertical spacing between each subplot is a little tight---notice that there's a little overlap with some of the x-axis labels. If you want to fix that, and make the plots fit together much better, you can simply call the `pyplot.tight_layout` function. The [`tight_layout`][1] function automatically adjusts the parameters of the subplots so that they fit nicely within the figure. \n",
    "\n",
    "Let's go ahead and give it a try now to see how well it works.\n",
    "\n",
    "[1]: http://matplotlib.org/users/tight_layout_guide.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.subplots(3, 2)\n",
    "plt.tight_layout();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `pyplot.subplots_adjust`\n",
    "\n",
    "Well, that looks much better! The `tight_layout` function is really nice and should solve most of your problems, but as of now, it's still an experimental feature and not guaranteed to work. If you do run into problems with it, you can fall back on the `pyplot.subplots_adjust` function to change some, or all, of the attributes of the grid. \n",
    "\n",
    "The example below uses this function to adjust the vertical spacing, or hspace for height, between each plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.subplots(3, 2)\n",
    "plt.subplots_adjust(hspace=0.5);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Not quite as easy as calling the `tight_layout` function, but not exactly rocket science either.  \n",
    "\n",
    "We just saw how to use the `tight_layout` and `subplots_adjust` functions to make minor tweaks to our grids that can help make our plots easier to read and comprehend. In the next lesson, we'll see how to use the subplotting features that we've learned in the last few lessons to create a very powerful visualization technique called a scatterplot matrix. Following that, we'll see how to create grids of subplots of varying shapes and sizes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `Subplot2Grid`\n",
    "\n",
    "The `subplot` function is easy to understand and use, and as long as the dimensions of the subplots in your grid are exactly the same, you'll never need anything else. However, the moment you need to adjust one or two subplots to be a slightly different height or width from the rest, you'll need something a bit more powerful.\n",
    "\n",
    "In this lesson, we'll see how the `subplot2grid` function can provide us with the extra power that we'll need to create much more complex grid layouts than we've seen thus far.\n",
    "\n",
    "### The `subplot2grid` Function\n",
    "\n",
    "<!---\n",
    "We've already seen that we can call the `subplot` function with a set of integers, where the first two describe the shape of the grid and, the third specifies the index of the grid cell we want to create subplot in. This is easy to use and does the job in most cases, but when you need to create a subplot that spans multiple cells, you'll need to use the `subplot2grid` function.\n",
    "--->\n",
    "\n",
    "You can think of the `subplot2grid` function as a superset of the `subplot` function. In other words, anything that you can do with the `subplot` function, you can do with the `subplot2grid` function. In that sense, you could actually just use the `subplot2grid` function for all of your plotting needs, and the next bit of code proves it.\n",
    "\n",
    "In the code below we use the `subplot` function to create a simple 2x2 grid of cells and the first 2 subplots in that grid."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a 2x2 grid of cells and use the subplot function\n",
    "# to create the subplots in the first row.\n",
    "ax1 = plt.subplot(221)\n",
    "ax2 = plt.subplot(222)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, we use the `subplot2grid` function to do the exact same thing as above for the bottom row. Though a bit more verbose, the `subplot2grid` function's interface is still relatively simple, and the end result is the same as calling the `subplot` function. \n",
    "\n",
    "Notice that the `subplot2grid` function calls below take two tuples: the first holds the dimensions of the grid, and the second contains the row and column coordinates of a cell in that grid. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use the subplot2grid function to create the subplots in\n",
    "# the bottom row.\n",
    "ax3 = plt.subplot2grid((2, 2), (1, 0))\n",
    "ax4 = plt.subplot2grid((2, 2), (1, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To make our plots a bit easier to read, we'll take each of the `Axes` objects created by the `subplot` and `subplot2grid` functions above, and use them to write a bit of text to each subplot's center that just displays the subplot's coordinates in a `(row, column)` format."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add row and column coordinates to each of the plots in the grid\n",
    "ax1.text(0.5, 0.5, \"(0, 0)\", horizontalalignment='center', verticalalignment='center', fontsize=20)\n",
    "ax2.text(0.5, 0.5, \"(0, 1)\", horizontalalignment='center', verticalalignment='center', fontsize=20)\n",
    "ax3.text(0.5, 0.5, \"(1, 0)\", horizontalalignment='center', verticalalignment='center', fontsize=20)\n",
    "ax4.text(0.5, 0.5, \"(1, 1)\", horizontalalignment='center', verticalalignment='center', fontsize=20);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we call the `tight_layout` function to correctly space all of the subplots in our grid before showing it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The tight_layout function works no matter how you create\n",
    "# the subplots in your figure.\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we've just seen, calling the `subplot2grid` function with just two tuples produces results that are identical to calling the `subplot` function. Where it differs, though, is that you can pass in a pair of optional parameters, the `rowspan` and `colspan` parameters, to make a  subplot stretch across multiple cells in a grid. \n",
    "\n",
    "The example below, shows you how to use these optional parameters to create a relatively complex 3x2 grid layout. For this example, we use just the `subplot2grid` function to create our more complex layout."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a 3x2 grid with four cells, where one spans across\n",
    "# multiple rows, and another spans multiple columns.\n",
    "ax1 = plt.subplot2grid((3, 2), (0, 0), rowspan=2)\n",
    "ax2 = plt.subplot2grid((3, 2), (0, 1))\n",
    "ax3 = plt.subplot2grid((3, 2), (1, 1))\n",
    "ax4 = plt.subplot2grid((3, 2), (2, 0), colspan=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On lines 4 and 5 in the code above, we created two normal subplots, i.e., plots that span only a single cell. Lines 3 and 6, however, are a bit more interesting. Line 3 creates the very first subplot in our grid. This subplot begins in very first cell, i.e., at the intersection of the first row and column, and it uses the `rowspan` parameter to specify that it spans across the first two rows in our grid. Line 6 does something similar, but it uses the `colspan` parameter to force its subplot to stretch across both columns in our grid instead. \n",
    "\n",
    "The rest of the code below is, more or less, identical to what we saw in our last example and is here just to make it easier to understand what we're doing in the code above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add row and coordinate labels to the ac of the cells in the grid\n",
    "ax1.text(0.5, 0.5, \"(0, 0)\", horizontalalignment='center', verticalalignment='center', fontsize=20)\n",
    "ax2.text(0.5, 0.5, \"(0, 1)\", horizontalalignment='center', verticalalignment='center', fontsize=20)\n",
    "ax3.text(0.5, 0.5, \"(1, 1)\", horizontalalignment='center', verticalalignment='center', fontsize=20)\n",
    "ax4.text(0.5, 0.5, \"(2, 0)\", horizontalalignment='center', verticalalignment='center', fontsize=20)\n",
    "\n",
    "# Make the cells are properly spaced\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The beauty of this interface, at least for me, is its simplicity. It's just so easy to understand; you simply define the shape of your grid, pass in the row and column where you want your subplot to begin, and then specify its height and width by passing in the number of rows and columns that it will stretch across. Also, if you have any prior experience with creating tables in HTML, which many of you probably do, you're already intimately familiar with the row and column spanning specifics of this interface. \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion\n",
    "\n",
    "We just saw how to use the `subplot` and `subplots` functions to create grids of plots making it infinitely easier for us to compare different feature sets in our data. \n",
    "\n",
    "This will also wrap up our look at subplotting in matplotlib. You've seen how to create simple grids of subplots using the matplotlib's `subplot` function. You've also seen how to use the simple `subplot` function to put together a fairly complex visualization function called a scatterplot matrix. And, finally, you've seen how to use the `subplot2grid` function to create much more complex and interesting subplot layouts. With the tools you've learned over the past three lessons, you should be ready to tackle just about any subplotting challenge that your research can throw at you."
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}