vis-intro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "(vis-intro)=\n",
    "# Intro to Data Visualisation\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    "In this chapter, you'll get a bit of background on data visualisation and lots of pointers to both further chapters and other visualisation resources.\n",
    "\n",
    "There are a plethora of options (and packages) for data visualisation using code. First, though a note about the different *philosophies* of data visualisation. There are broadly two categories of approach to using code to create data visualisations: *imperative*, where you build what you want, and *declarative*, where you say what you want. Choosing which to use involves a trade-off: imperative libraries offer you flexibility but at the cost of some verbosity; declarative libraries offer you a quick way to plot your data, but only if it's in the right format to begin with, and customisation may be more difficult.\n",
    "\n",
    "There are also different purposes of data visualisation. It can be useful to bear in mind the three broad categories of visualisation that are out there:\n",
    "\n",
    "- exploratory\n",
    "\n",
    "- scientific\n",
    "\n",
    "- narrative\n",
    "\n",
    "Python excels at exploratory and scientific visualisation. The tools for narrative visualisation are not as good as they could be for making common chart types efficiently, but did receive a big boost with the release of the **lets-plot** library, which is covered in Chapter {ref}`vis-letsplot`. And Python is blessed with perhaps the most powerfully flexible data visualisation package anywhere, **matplotlib**, in which you can always get the effect you want (with some work). **matplotlib** is covered in Chapter {ref}`vis-matplotlib`.\n",
    "\n",
    "### Exploratory Visualisation\n",
    "\n",
    "The first of the three kinds of vis, *exploratory visualisation*, is the kind that you do when you're looking and data and trying to understand it. Just plotting the data is a really good strategy for getting a feel for any issues there might be. This is perhaps most famously demonstrated by *Anscombe's quartet*: four different datasets with the same mean, standard deviation, and correlation but *very* different data distributions.\n",
    "\n",
    "(First let's import the packages we'll need:)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Set seed for random numbers\n",
    "seed_for_prng = 78557\n",
    "prng = np.random.default_rng(seed_for_prng)  # prng=probabilistic random number generator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "51a55374",
   "metadata": {
    "tags": [
     "remove-cell"
    ]
   },
   "outputs": [],
   "source": [
    "import matplotlib_inline.backend_inline\n",
    "\n",
    "# Plot settings\n",
    "plt.style.use(\n",
    "    \"https://github.com/aeturrell/coding-for-economists/raw/main/plot_style.txt\"\n",
    ")\n",
    "matplotlib_inline.backend_inline.set_matplotlib_formats(\"svg\")\n",
    "\n",
    "# Set max rows displayed for readability\n",
    "pd.set_option(\"display.max_rows\", 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Anscombe's quartet*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "remove-input"
    ]
   },
   "outputs": [],
   "source": [
    "x = [10, 8, 13, 9, 11, 14, 6, 4, 12, 7, 5]\n",
    "y1 = [8.04, 6.95, 7.58, 8.81, 8.33, 9.96, 7.24, 4.26, 10.84, 4.82, 5.68]\n",
    "y2 = [9.14, 8.14, 8.74, 8.77, 9.26, 8.10, 6.13, 3.10, 9.13, 7.26, 4.74]\n",
    "y3 = [7.46, 6.77, 12.74, 7.11, 7.81, 8.84, 6.08, 5.39, 8.15, 6.42, 5.73]\n",
    "x4 = [8, 8, 8, 8, 8, 8, 8, 19, 8, 8, 8]\n",
    "y4 = [6.58, 5.76, 7.71, 8.84, 8.47, 7.04, 5.25, 12.50, 5.56, 7.91, 6.89]\n",
    "\n",
    "datasets = {\"I\": (x, y1), \"II\": (x, y2), \"III\": (x, y3), \"IV\": (x4, y4)}\n",
    "\n",
    "fig, axs = plt.subplots(\n",
    "    2,\n",
    "    2,\n",
    "    sharex=True,\n",
    "    sharey=True,\n",
    "    figsize=(10, 6),\n",
    "    gridspec_kw={\"wspace\": 0.08, \"hspace\": 0.08},\n",
    ")\n",
    "axs[0, 0].set(xlim=(0, 20), ylim=(2, 14))\n",
    "axs[0, 0].set(xticks=(0, 10, 20), yticks=(4, 8, 12))\n",
    "\n",
    "for ax, (label, (x, y)) in zip(axs.flat, datasets.items()):\n",
    "    ax.text(0.1, 0.9, label, fontsize=20, transform=ax.transAxes, va=\"top\")\n",
    "    ax.tick_params(direction=\"in\", top=True, right=True)\n",
    "    ax.plot(x, y, \"o\")\n",
    "\n",
    "    # linear regression\n",
    "    p1, p0 = np.polyfit(x, y, deg=1)  # slope, intercept\n",
    "    ax.axline(xy1=(0, p0), slope=p1, color=\"r\", lw=2)\n",
    "\n",
    "    # add text box for the statistics\n",
    "    stats = (\n",
    "        f\"$\\\\mu$ = {np.mean(y):.2f}\\n\"\n",
    "        f\"$\\\\sigma$ = {np.std(y):.2f}\\n\"\n",
    "        f\"$r$ = {np.corrcoef(x, y)[0][1]:.2f}\"\n",
    "    )\n",
    "    bbox = dict(boxstyle=\"round\", fc=\"blanchedalmond\", ec=\"orange\", alpha=0.5)\n",
    "    ax.text(\n",
    "        0.95,\n",
    "        0.07,\n",
    "        stats,\n",
    "        fontsize=9,\n",
    "        bbox=bbox,\n",
    "        transform=ax.transAxes,\n",
    "        horizontalalignment=\"right\",\n",
    "    )\n",
    "\n",
    "plt.suptitle(\"Anscombe's Quartet\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exploratory visualisation is usually quick and dirty, and flexible too. Some exploratory data viz can be automated, and some of the packages you'll see later in the chapter on {ref}`data-exploratory-analysis` can do this. Beyond you and perhaps your co-authors/collaborators, not many other people should be seeing your exploratory visualisation.\n",
    "\n",
    "### Scientific Visualisation\n",
    "\n",
    "The second kind, scientific visualisation, is the prime cut of your exploratory visualisation. It's the kind of plot you might include in a more technical paper, the picture that says a thousand words. I often think of the first image of a black hole by {cite:t}`akiyama2019first` as a prime example of this (made with **matplotlib**!) You can get away with having a high density of information in a scientific plot and, in short format journals, you may need to. The journal *Physical Review Letters*, which has an 8 page limit, has a classic of this genre in more or less every issue. Ensuring that important values can be accurately read from the plot is especially important in these kinds of charts. But they can also be the kind of plot that presents the killer results in a study; they might not be exciting to people who don't look at charts for a living, but they might be exciting and, just as importantly, understandable by your peers.\n",
    "\n",
    "### Narrative Visualisation\n",
    "\n",
    "The third and final kind is narrative visualisation. This is the one that requires the most thought in the step where you go from the first view to the end product. It's a visualisation that doesn't just show a picture, but gives an insight. These are the kind of visualisations that you might see in the *Financial Times*, *The Economist*, or on the BBC News website. They come with aids that help the viewer focus on the aspects that the creator wanted them to (you can think of these aids or focuses as doing for visualisation what bold font does for text). They're well worth using in your work, especially if you're trying to communicate a particular narrative, and especially if the people you're communicating with don't have deep knowledge of the topic. You might use them in a paper that you hope will have a wide readership, in a blog post summarising your work, or in a report intended for a policymaker.\n",
    "\n",
    "You can find more information on the topic in the {ref}`vis-narrative` chapter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quick guide to data visualisation\n",
    "\n",
    "Addressing data visualisation, a huge topic in itself, is definitely out of scope for this book! But it's worth discussing a few general pointers at the outset that will serve you very well if you follow them.\n",
    "\n",
    "A picture may tell a 1000 words, but you've got to be a bit careful about what those words are. The first question you should ask yourself when it comes to data visualisation is 'what does this plot tell the viewer?', ie what do you want people to take away from your chart. That nugget of information should be as apparent as possible from the plot. Then you want to ensure that people *do* take away what you meant them to; the viewer should be left in little doubt about what you are saying.\n",
    "\n",
    "Another factor to bear in mind is that papers typically don't have more than, say, ten plots in them--and frequently fewer than that. So each one must count and advance the narrative of your work somehow. (Easier to say, hard to do in practice.) As an example, if you have data that are normally distributed, and you want to show this, it's probably not worth showing it on a plot. But if you had two distributions whose differences were important for the overall story you were telling, that might be something to highlight.\n",
    "\n",
    "Then there are more practical matters: is this plot better done as a scatter plot or a line? Should I stack my bar chart or split out the contributions? Those questions address the *type* of plot you're creating. For example, if you have observations that are independent from one another, with no auto-correlation along the x-axis, a scatter plot is more appropriate than a line chart. However, for time series, which tend to exhibit a high degree of auto-correlation, a line chart could be just the thing. As well as the overall type, for example scatter plot, you can think about adding more information through the use of colours, shapes, sizes, and so on. But my advice is always to be sparing with extra dimensions of information as it very quickly becomes difficult to read. In most cases, an x-axis, a y-axis, and, usually, one other dimension (eg colour) will be the best option.\n",
    "\n",
    "Once you've decided on the *type* of chart, you can then think about smaller details. Unfortunately, lack of labels is endemic in economics (\"percent of what!?\", I cry at least three times a day). Always make what you're plotting clear and, if it has units, express them (eg \"Salary (2015 USD)\"). Think carefully about the tick labels to use too; you'll want something quite different for linear versus log plots. Titles can be helpful too, if the axes labels and the chart by themselves don't tell the whole story. \n",
    "\n",
    "Then, if there are very specific features you'd like to draw attention to, you can achieve this with text labels (as used liberally in the data visualisations you'll see in newspapers like the *Financial Times*), greying out all but the most interesting data point, etc.; anything that singles out one part of the chart as the interesting one. A common trick is to plot the less important features with greater transparency and the important line/point/bar with solid colour. These all have the effect of drawing the eye straight to where it should spend the most time.\n",
    "\n",
    "This is just the briefest of brief overviews of what you should bear in mind for good visualisation; I highly recommend the short and delightful [Fundamentals of Data visualisation](https://clauswilke.com/dataviz/) if you'd like to know more.\n",
    "\n",
    "In terms of further resources to help you choose the right plot for the occassion, you can't go too far wrong than the [*Financial Times* Visual Vocabulary of charts](https://github.com/ft-interactive/chart-doctor/tree/master/visual-vocabulary). And, please, please use [vector graphics](https://clauswilke.com/dataviz/image-file-formats.html) whenever you can!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Colour\n",
    "\n",
    "This section has benefitted from this [blog piece](https://blog.datawrapper.de/which-color-scale-to-use-in-data-vis/) on visualisation and colour, and you can find more information there.\n",
    "\n",
    "Colours often make a chart come alive, but, when encoding differences with colour, think carefully about what would serve your audience and message best. It's best not to use colour randomly, but to choose colours that either add information to the chart or get out of the way of the message. Often, you'll want to draw your colours from a 'colour palette', a collection of different colours that work together to create a particular effect. The best colour palettes take into account that colour blindness is a problem for many people, and they remain informative even when converted to greyscale.\n",
    "\n",
    "One of the most popular Python visualisation libraries, **matplotlib**, comes with a wide range of colour palettes available [here](https://matplotlib.org/3.1.0/tutorials/colors/colormaps.html) and you can find another good package for colour palettes [here](https://colorcet.holoviz.org/).\n",
    "\n",
    "#### Categorical Data\n",
    "\n",
    "For (unordered) categorical data, visually distinct colour palettes (also known as qualitative palettes) are better. The basic rule is that you should use distinct hues when your values don’t have an inherent order or range. Note that this does not include Likert scales (“strongly agree, agree, neutral, disagree, strongly disagree”), because even though there are distinct categories, there is an order to the possible responses.\n",
    "\n",
    "Here are some examples of the qualitative hues available in the visualisation package **matplotlib**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "remove-input"
    ]
   },
   "outputs": [],
   "source": [
    "# remove-input\n",
    "cmaps = [\n",
    "    (\n",
    "        \"Perceptually Uniform Sequential\",\n",
    "        [\"viridis\", \"plasma\", \"inferno\", \"magma\", \"cividis\"],\n",
    "    ),\n",
    "    (\n",
    "        \"Sequential\",\n",
    "        [\n",
    "            \"Greys\",\n",
    "            \"Purples\",\n",
    "            \"Blues\",\n",
    "            \"Greens\",\n",
    "            \"Oranges\",\n",
    "            \"Reds\",\n",
    "            \"YlOrBr\",\n",
    "            \"YlOrRd\",\n",
    "            \"OrRd\",\n",
    "            \"PuRd\",\n",
    "            \"RdPu\",\n",
    "            \"BuPu\",\n",
    "            \"GnBu\",\n",
    "            \"PuBu\",\n",
    "            \"YlGnBu\",\n",
    "            \"PuBuGn\",\n",
    "            \"BuGn\",\n",
    "            \"YlGn\",\n",
    "        ],\n",
    "    ),\n",
    "    (\n",
    "        \"Sequential (2)\",\n",
    "        [\n",
    "            \"binary\",\n",
    "            \"gist_yarg\",\n",
    "            \"gist_gray\",\n",
    "            \"gray\",\n",
    "            \"bone\",\n",
    "            \"pink\",\n",
    "            \"spring\",\n",
    "            \"summer\",\n",
    "            \"autumn\",\n",
    "            \"winter\",\n",
    "            \"cool\",\n",
    "            \"Wistia\",\n",
    "            \"hot\",\n",
    "            \"afmhot\",\n",
    "            \"gist_heat\",\n",
    "            \"copper\",\n",
    "        ],\n",
    "    ),\n",
    "    (\n",
    "        \"Diverging\",\n",
    "        [\n",
    "            \"PiYG\",\n",
    "            \"PRGn\",\n",
    "            \"BrBG\",\n",
    "            \"PuOr\",\n",
    "            \"RdGy\",\n",
    "            \"RdBu\",\n",
    "            \"RdYlBu\",\n",
    "            \"RdYlGn\",\n",
    "            \"Spectral\",\n",
    "            \"coolwarm\",\n",
    "            \"bwr\",\n",
    "            \"seismic\",\n",
    "        ],\n",
    "    ),\n",
    "    (\"Cyclic\", [\"twilight\", \"twilight_shifted\", \"hsv\"]),\n",
    "    (\n",
    "        \"Qualitative\",\n",
    "        [\n",
    "            \"Pastel1\",\n",
    "            \"Pastel2\",\n",
    "            \"Paired\",\n",
    "            \"Accent\",\n",
    "            \"Dark2\",\n",
    "            \"Set1\",\n",
    "            \"Set2\",\n",
    "            \"Set3\",\n",
    "            \"tab10\",\n",
    "            \"tab20\",\n",
    "            \"tab20b\",\n",
    "            \"tab20c\",\n",
    "        ],\n",
    "    ),\n",
    "    (\n",
    "        \"Miscellaneous\",\n",
    "        [\n",
    "            \"flag\",\n",
    "            \"prism\",\n",
    "            \"ocean\",\n",
    "            \"gist_earth\",\n",
    "            \"terrain\",\n",
    "            \"gist_stern\",\n",
    "            \"gnuplot\",\n",
    "            \"gnuplot2\",\n",
    "            \"CMRmap\",\n",
    "            \"cubehelix\",\n",
    "            \"brg\",\n",
    "            \"gist_rainbow\",\n",
    "            \"rainbow\",\n",
    "            \"jet\",\n",
    "            \"turbo\",\n",
    "            \"nipy_spectral\",\n",
    "            \"gist_ncar\",\n",
    "        ],\n",
    "    ),\n",
    "]\n",
    "\n",
    "\n",
    "gradient = np.linspace(0, 1, 256)\n",
    "gradient = np.vstack((gradient, gradient))\n",
    "\n",
    "\n",
    "def plot_color_gradients(cmap_category, cmap_list):\n",
    "    # Create figure and adjust figure height to number of colormaps\n",
    "    with plt.style.context(\"default\"):\n",
    "        nrows = len(cmap_list)\n",
    "        figh = 0.35 + 0.15 + (nrows + (nrows - 1) * 0.1) * 0.22\n",
    "        fig, axs = plt.subplots(nrows=nrows, figsize=(6.4, figh))\n",
    "        fig.subplots_adjust(top=1 - 0.35 / figh, bottom=0.15 / figh, left=0.2, right=0.99)\n",
    "\n",
    "        axs[0].set_title(cmap_category + \" colormaps\", fontsize=14)\n",
    "\n",
    "        for ax, name in zip(axs, cmap_list):\n",
    "            ax.imshow(gradient, aspect=\"auto\", cmap=plt.get_cmap(name))\n",
    "            ax.text(\n",
    "                -0.01,\n",
    "                0.5,\n",
    "                name,\n",
    "                va=\"center\",\n",
    "                ha=\"right\",\n",
    "                fontsize=10,\n",
    "                transform=ax.transAxes,\n",
    "            )\n",
    "\n",
    "        # Turn off *all* ticks & spines, not just the ones with colormaps.\n",
    "        for ax in axs:\n",
    "            ax.set_axis_off()\n",
    "        plt.show()\n",
    "\n",
    "\n",
    "for cmap_category, cmap_list in cmaps[5:6]:\n",
    "    plot_color_gradients(cmap_category, cmap_list)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Continuous Colour Scales\n",
    "\n",
    "Continuously varying data need a sequential colour scale, but there are two types: *sequential* and *diverging*\n",
    "\n",
    "For data that vary from low to high, you can use a sequential colourmap. Best practice is to use a sequential colourmap that is perceptually uniform. The authors of the Python package **matplotlib** [developed](https://bids.github.io/colormap/) several perceptually uniform colourmaps that are now widely used, not just in Python, but in other languages and contexts too {cite:ps}`nunez2018optimizing`. These are the ones built-in to **matplotlib**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "remove-input"
    ]
   },
   "outputs": [],
   "source": [
    "# remove input\n",
    "for cmap_category, cmap_list in cmaps[:1]:\n",
    "    plot_color_gradients(cmap_category, cmap_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Do not use the JET colourmap: it is very much not perceptually uniform. If you do want a rainbow-like sequential and perceptually uniform colourmap, then turbo, [developed by Google](https://ai.googleblog.com/2019/08/turbo-improved-rainbow-colormap-for.html), is as good a choice as you're going to find. You can find turbo within matplotlib."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "remove-input"
    ]
   },
   "outputs": [],
   "source": [
    "# remove-input\n",
    "def show_one_colourmap(cmap):\n",
    "    fig, ax = plt.subplots(figsize=(6.4, 0.3))\n",
    "    ax.text(\n",
    "        -0.01, 0.5, cmap, va=\"center\", ha=\"right\", fontsize=10, transform=ax.transAxes\n",
    "    )\n",
    "    ax.imshow(gradient, aspect=\"auto\", cmap=plt.get_cmap(cmap))\n",
    "    ax.set_axis_off()\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "show_one_colourmap(\"turbo\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes a *diverging* colourmap will be more appropriate for your data. These are also called bipolar or double-ended color scales and, instead of just going from low to high, they tend to have a default middle value (often brighter) with values either side that are darker in different hues. Diverging color scales are often used to visualise negative and positive differences relative to zero, election results, or Likert scales (for example, “strongly agree, agree, neutral, disagree, strongly disagree”).\n",
    "\n",
    "These are the built-in ones in **matplotlib**:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "remove-input"
    ]
   },
   "outputs": [],
   "source": [
    "# remove input\n",
    "for cmap_category, cmap_list in cmaps[3:4]:\n",
    "    plot_color_gradients(cmap_category, cmap_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So how do you choose between a diverging or sequential colour scale? Divering colour scales work better when i) there’s a meaningful middle point, ii) there are extremes that you want to emphasise, iii) when differences are more of the story than levels, and iv) when you don't mind that people will have to put in a bit of extra effort to understand the chart relative to the typically more intuitive sequential colour scale."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, this book uses a colour-blind friendly qualitative scheme (you can find the list of colours in [this](https://github.com/aeturrell/coding-for-economists/blob/main/plot_style.txt) file)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "remove-input"
    ]
   },
   "outputs": [],
   "source": [
    "# remove input\n",
    "from matplotlib.colors import LinearSegmentedColormap\n",
    "\n",
    "colours = plt.rcParams[\"axes.prop_cycle\"].by_key()[\"color\"]\n",
    "cmap = LinearSegmentedColormap.from_list(\n",
    "    \"coding for economists: qualitative colourmap\", colours, N=len(colours)\n",
    ")\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(6.4, 0.3))\n",
    "ax.imshow(gradient, aspect=\"auto\", cmap=plt.get_cmap(cmap))\n",
    "ax.text(\n",
    "    -0.01,\n",
    "    0.5,\n",
    "    \"Coding for Economists\",\n",
    "    va=\"center\",\n",
    "    ha=\"right\",\n",
    "    fontsize=10,\n",
    "    transform=ax.transAxes,\n",
    ")\n",
    "ax.set_axis_off()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Libraries for Data Visualisation\n",
    "\n",
    "In subsequent chapters, we'll take a look at making visualisations with several of these libraries. Our overall advice is to use **lets-plot** for declarative plotting and **matplotlib** for imperative plotting due to their high quality, flexibility, and likelihood of long term support. You can find lots of examples of the kinds of visualisations these packages produce side-by-side over in {ref}`vis-common-plots`.\n",
    "\n",
    "The most important and widely used data visualisation library in Python is [**matplotlib**](https://matplotlib.org/). It was used to make the first image of a black hole by {cite:t}`akiyama2019first` and to image the first empirical evidence of gravitational waves by {cite:t}`abbott2016observation`. **matplotlib** is an imperative visualisation library: you specify each part of what you want individually to build up an entire picture. It's perhaps the easiest to get started with and the most difficult to master. As well as making plots, it can also be used to make diagrams, animations, and 3D visualisations (which you should use sparingly, if at all). Reach for it if you like to have very fine-grained control over your plots, for example, you're making a bespoke or unusual chart, you need to control the look of a chart very carefully, you're making something that requires more graphical design, or you prefer to build up your plots from elemental pieces. You can explore it further in {ref}`vis-matplotlib`.\n",
    "\n",
    "[**lets-plot**](https://lets-plot.org/) is a fantastic and extremely high-quality declarative library that works especially well with data that are in a *tidy* format (one row per observation, one column per variable). It adopts a *grammar of graphics* approach. What this means is that *all* visualisations begin with the same command, `ggplot`, and are combinations of layers that address different aspects of a plot, for example points or lines, scale, labels, and so on. Use it if you want one of a long list of standard charts produced quickly and to a high standard, and if your data are in a tidy format. You can find out more about it in {ref}`vis-letsplot`.\n",
    "\n",
    "[**plotly** express](https://plotly.com/python/plotly-express/) is another declarative-leaning library that's suited to web apps and dashboards.\n",
    "\n",
    "[**seaborn**](https://seaborn.pydata.org) is a popular declarative library that builds on **maplotlib** and works especially well with data that are in a *tidy* format (one row per observation, one column per variable). **seaborn** is still a work in progress, but you can find information on it in {ref}`vis-seaborn`.\n",
    "\n",
    "[**plotnine**](https://plotnine.readthedocs.io) is another declarative plotting library that adopts a *grammar of graphics* approach and uses a `ggplot` command, but it's not quite as full featured as **lets-plot**. You can read more about it in {ref}`vis-plotnine`.\n",
    "\n",
    "[**altair**](https://altair-viz.github.io/) is yet another declarative plotting library for Python! It's most suited to interactive graphics on the web, and produces really beautiful charts. Under the hood, it calls a javascript library named **Vega-Lite** that's the sort of thing newspaper data visualisation units might use to make their infographics.\n",
    "\n",
    "**pandas** also has [built-in plotting functions](https://pandas.pydata.org/pandas-docs/stable/user_guide/visualization.html) that you will have seen in the data analysis part of this book. They are of the form `df.plot.*` where `*` could be, for example, `scatter`. These are convenience functions for making a quick plot of your data and they actually use **matplotlib**; we won't see much of these here but you can find them in the data analysis chapter.\n",
    "\n",
    "We're going to start this chapter by finding out a little bit more about each of these data visualisation libraries before looking at some examples of how to make specific plots with all the main libraries. We'll end by looking at some more interesting and advanced plots."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Other Data Visualisation Tools\n",
    "\n",
    "There are tons of data visualisation libraries in Python, so many that most cannot be featured in great detail. Here are a few more that may be worth looking into depending on what you need."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's a quick run down of the other libraries that are available:\n",
    "\n",
    "- [**proplot**](https://proplot.readthedocs.io/en/latest/index.html) aims to be \"A lightweight matplotlib wrapper for making beautiful, publication-quality graphics\", though the style is more similar to how people might make plots in the hard sciences rather than the social sciences. The point of this library is to take some of the verbosity out of **matplotlib**.\n",
    "- if you're using very big data in machine learning models, it might be worth looking at Facebook's [**hiplot**](https://github.com/facebookresearch/hiplot)\n",
    "- [Seaborn image](https://seaborn-image.readthedocs.io/en/latest/) does for image data what **seaborn** does for numerical and categorical data\n",
    "- [Lit](https://pair-code.github.io/lit/) provides an open-source platform for visualization and understanding of NLP models (very impressive)\n",
    "- [Wordcloud](https://github.com/amueller/word_cloud) does exactly what you'd expect (but use word clouds *very* sparingly!)\n",
    "- [VisPy](http://vispy.org) for very large datasets plotted with WebGL and GPU acceleration.\n",
    "- [PyQtGraph](http://www.pyqtgraph.org/), a pure-Python graphics library for PyQt5/PySide2 and intended for use in (heavy) mathematics / scientific / engineering applications (not very user friendly).\n",
    "- [bokeh](https://docs.bokeh.org/en/latest/index.html#) offers interactive web plotting in Python.\n",
    "- [HoloViews](https://holoviews.org/), a library dsigned to make data analysis and visualization seamless and simple with very concise commands (builds on bokeh and matplotlib).\n",
    "- [YellowBrick](https://www.scikit-yb.org/en/latest/) for visualisations of machine learning models and metrics.\n",
    "- [facets](https://pair-code.github.io/facets/) for quickly visualising machine learning features (aka regressors). Also useful for exploratory data analysis.\n",
    "- [chartify](https://github.com/spotify/chartify), Spotify's quick plotting library for data scientists.\n",
    "- [scienceplots](https://github.com/garrettj403/SciencePlots) provides scientific plotting styles--some associated with specific journals--for Matplotlib.\n",
    "- [colour](https://www.colour-science.org/) provides professional level colour tools for Python.\n",
    "- [palettable](https://jiffyclub.github.io/palettable/) has extra colour palettes that work well with Matplotlib.\n",
    "- [colorcet](https://colorcet.holoviz.org/) is a collection of perceptually uniform colourmaps.\n",
    "- [missingno](https://github.com/ResidentMario/missingno) for visualization of missing data.\n",
    "\n",
    "You can see an overview of all Python plotting tools at [PyViz](https://pyviz.org/tools.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Review\n",
    "\n",
    "If you know:\n",
    "\n",
    "- ✅ a little bit about how to use data visualisation; and\n",
    "- ✅ what some of the most popular libraries for data vis are in Python\n",
    "\n",
    "then you are well on your way to being a whizz with data vis!"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Tags",
  "kernelspec": {
   "display_name": "Python 3.10.12 ('codeforecon')",
   "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.10.13"
  },
  "vscode": {
   "interpreter": {
    "hash": "c4570b151692b3082981c89d172815ada9960dee4eb0bedb37dc10c95601d3bd"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}