06_Visualization.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction and generalities\n",
    "\n",
    "\n",
    "The visualization of the results of an analysis typically tell a lot about the quality of the analysis itself, examples are:\n",
    "   * the discovery of the [higgs boson](https://twiki.cern.ch/twiki/pub/CMSPublic/Hig13002TWiki/HZZ4l_animated.gif)\n",
    "   * is the claim of [superluminal neutrinos](https://arxiv.org/pdf/1109.4897v1.pdf). \n",
    "\n",
    "Graphics should convey as much information as possible in an intuitive way. There are plenty of bad examples (and somethimes affecting you for life[...](https://en.wikipedia.org/wiki/Fabiola_Gianotti)).\n",
    "\n",
    "\n",
    "There are essentially two kinds of plots you'll ever want to make, histograms and scatter plots.\n",
    "\n",
    "### Histograms\n",
    "\n",
    "Histograms represent scalar functions, $f(x): {\\rm I\\!R}^n \\to {\\rm I\\!R}$, where at most $n=2$. They are generally used to display the feature of a data distribution. Histograms are often used for comparison among several distributions, for instance, very importantly, histograms are used to compare measurements with expectations (e.g. simulations). \n",
    "\n",
    "Histograms are \"binned\", i.e. the domain is divided in classes (bins), i.e. for the $i$th bin $x_i<x\\le x_{i+1}$ and the content of the bin (say $h(x)$) is  $h(x)=\\frac{\\int_{x_{i}}^{x_{i+1}} f(x)}{x_{i+1}- x_{i}}$. Bins doesn't need to have the same size, i.e. it could well be that $(x_{i+1}- x_{i}) \\neq (x_{j+1}- x_{j})$ for $i\\neq j$. \n",
    "If the bin size is small, $h(x)\\simeq f(\\frac{x_{i+1}+x_{i}}{2})$.\n",
    "\n",
    "\n",
    "\n",
    "Choosing the number of bins and the bins sizes needs a lot of care. Typically the content of each $i$th bin, $N_i$, should be statistically significant, i.e. the corresponding Poisson uncertainty, $1/\\sqrt{N_i}$, should be small.\n",
    "\n",
    "Often such uncertainty is worth being indicated, especially if the distribution is normalized or if the bin content comes from a simulation (and thus needed to be weighted). \n",
    "\n",
    "\n",
    "#### Shape and Normalization\n",
    "\n",
    "The are essentially two quantities that are conveyed by an histogram:\n",
    "   * The total amount of data, i.e. its normalization\n",
    "   * The shape or differentianl distribution, i.e. the underlying p.d.f\n",
    "   \n",
    "Both quantities can be expressed separately, by quoting $N=\\sum f(x_i)$ the number of entries and displaying\n",
    "$f(x)/N$. Actually the definition of normalization factor could be ambiguous; it could either be $N$ or \n",
    "$I=\\int f(x) dx$. The former is most commonly used (and most useful), but the latter is often the default of built-in methods of several visualization packages.\n",
    "\n",
    "\n",
    "### Scatter plots\n",
    "\n",
    "Scatter plots are used to compare two quantities, mainly aiming at displaying possible correlations between them. \n",
    "\n",
    "Scatter plots can be binned or unbinned, the latter case is often prefered until the number of point isn't too large. In that case the former is preferred, with a color code indicating the \"3rd dimension\", i.e. the relative population of each bin. This can be made into a \"contour plot\", i.e. with smoothened edges and color-coded levels.\n",
    "\n",
    "Display of different population is also possible, marking the data points differently, e.g. with different colors or different markers.\n",
    "\n",
    "Of paramount importance is the condensation of the scatter plots into \"profiles\". The procedure runs as follow: data are binned along the $x$ (if you had to bin on the other variable, just invert the axes), for every bin take the mean and the standard deviation of the corresponding $y$ values, display those as data points and their error.\n",
    "These are also called \"box plots\".\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import Image\n",
    "Image(\"profile.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Other plots\n",
    "\n",
    "Other kind of plots are there too (e.g. pie-charts, networks representation), not treated here though\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Matplotlib (pyplot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "# always useful\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A plot is  a hierarchy of nested Python objects. A Figure object is the outermost container for a matplotlib graphic, which can contain multiple Axes objects. One source of confusion is the name: an Axes actually translates into what we think of as an individual plot or graph (rather than the plural of “axis,” as we might expect).\n",
    "\n",
    "A Figure object is like a container holding one or more Axes (actual plots). Below the Axes in the hierarchy are smaller objects such as tick marks, individual lines, legends, and text boxes. Almost every “element” of a chart is its own manipulable Python object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import Image\n",
    "Image(url='https://files.realpython.com/media/fig_map.bc8c7cabd823.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, _ = plt.subplots()\n",
    "print (type(fig))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "above we created two variables with plt.subplots(). The first is a top-level Figure object. The second is a “throwaway” variable that we don’t need just yet, denoted with an underscore. Using attribute notation, it is easy to traverse down the figure hierarchy and see the first tick of the y axis of the first Axes object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "one_tick = fig.axes[0].yaxis.get_major_ticks()[0]\n",
    "print (type(one_tick))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above, *fig* (a Figure class instance) has multiple Axes (a list, for which we take the first element). Each Axes has a yaxis and xaxis, each of which have a collection of “major ticks,” and we grab the first one.\n",
    "\n",
    "Matplotlib documentation presents this as a figure anatomy, rather than an explicit hierarchy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.ticker import AutoMinorLocator, MultipleLocator, FuncFormatter\n",
    "\n",
    "\n",
    "np.random.seed(19680801)\n",
    "\n",
    "X = np.linspace(0.5, 3.5, 100)\n",
    "Y1 = 3+np.cos(X)\n",
    "Y2 = 1+np.cos(1+X/0.75)/2\n",
    "Y3 = np.random.uniform(Y1, Y2, len(X))\n",
    "\n",
    "fig = plt.figure(figsize=(8, 8))\n",
    "ax = fig.add_subplot(1, 1, 1, aspect=1)\n",
    "\n",
    "\n",
    "def minor_tick(x, pos):\n",
    "    if not x % 1.0:\n",
    "        return \"\"\n",
    "    return \"%.2f\" % x\n",
    "\n",
    "ax.xaxis.set_major_locator(MultipleLocator(1.000))\n",
    "ax.xaxis.set_minor_locator(AutoMinorLocator(4))\n",
    "ax.yaxis.set_major_locator(MultipleLocator(1.000))\n",
    "ax.yaxis.set_minor_locator(AutoMinorLocator(4))\n",
    "ax.xaxis.set_minor_formatter(FuncFormatter(minor_tick))\n",
    "\n",
    "ax.set_xlim(0, 4)\n",
    "ax.set_ylim(0, 4)\n",
    "\n",
    "ax.tick_params(which='major', width=1.0)\n",
    "ax.tick_params(which='major', length=10)\n",
    "ax.tick_params(which='minor', width=1.0, labelsize=10)\n",
    "ax.tick_params(which='minor', length=5, labelsize=10, labelcolor='0.25')\n",
    "\n",
    "ax.grid(linestyle=\"--\", linewidth=0.5, color='.25', zorder=-10)\n",
    "\n",
    "ax.plot(X, Y1, c=(0.25, 0.25, 1.00), lw=2, label=\"Blue signal\", zorder=10)\n",
    "ax.plot(X, Y2, c=(1.00, 0.25, 0.25), lw=2, label=\"Red signal\")\n",
    "ax.plot(X, Y3, linewidth=0,\n",
    "        marker='o', markerfacecolor='w', markeredgecolor='k')\n",
    "\n",
    "ax.set_title(\"Anatomy of a figure\", fontsize=20, verticalalignment='bottom')\n",
    "ax.set_xlabel(\"X axis label\")\n",
    "ax.set_ylabel(\"Y axis label\")\n",
    "\n",
    "ax.legend()\n",
    "\n",
    "\n",
    "def circle(x, y, radius=0.15):\n",
    "    from matplotlib.patches import Circle\n",
    "    from matplotlib.patheffects import withStroke\n",
    "    circle = Circle((x, y), radius, clip_on=False, zorder=10, linewidth=1,\n",
    "                    edgecolor='black', facecolor=(0, 0, 0, .0125),\n",
    "                    path_effects=[withStroke(linewidth=5, foreground='w')])\n",
    "    ax.add_artist(circle)\n",
    "\n",
    "\n",
    "def text(x, y, text):\n",
    "    ax.text(x, y, text, backgroundcolor=\"white\",\n",
    "            ha='center', va='top', weight='bold', color='blue')\n",
    "\n",
    "\n",
    "# Minor tick\n",
    "circle(0.50, -0.10)\n",
    "text(0.50, -0.32, \"Minor tick label\")\n",
    "\n",
    "# Major tick\n",
    "circle(-0.03, 4.00)\n",
    "text(0.03, 3.80, \"Major tick\")\n",
    "\n",
    "# Minor tick\n",
    "circle(0.00, 3.50)\n",
    "text(0.00, 3.30, \"Minor tick\")\n",
    "\n",
    "# Major tick label\n",
    "circle(-0.15, 3.00)\n",
    "text(-0.15, 2.80, \"Major tick label\")\n",
    "\n",
    "# X Label\n",
    "circle(1.80, -0.27)\n",
    "text(1.80, -0.45, \"X axis label\")\n",
    "\n",
    "# Y Label\n",
    "circle(-0.27, 1.80)\n",
    "text(-0.27, 1.6, \"Y axis label\")\n",
    "\n",
    "# Title\n",
    "circle(1.60, 4.13)\n",
    "text(1.60, 3.93, \"Title\")\n",
    "\n",
    "# Blue plot\n",
    "circle(1.75, 2.80)\n",
    "text(1.75, 2.60, \"Line\\n(line plot)\")\n",
    "\n",
    "# Red plot\n",
    "circle(1.20, 0.60)\n",
    "text(1.20, 0.40, \"Line\\n(line plot)\")\n",
    "\n",
    "# Scatter plot\n",
    "circle(3.20, 1.75)\n",
    "text(3.20, 1.55, \"Markers\\n(scatter plot)\")\n",
    "\n",
    "# Grid\n",
    "circle(3.00, 3.00)\n",
    "text(3.00, 2.80, \"Grid\")\n",
    "\n",
    "# Legend\n",
    "circle(3.70, 3.80)\n",
    "text(3.70, 3.60, \"Legend\")\n",
    "\n",
    "# Axes\n",
    "circle(0.5, 0.5)\n",
    "text(0.5, 0.3, \"Axes\")\n",
    "\n",
    "# Figure\n",
    "circle(-0.3, 0.65)\n",
    "text(-0.3, 0.45, \"Figure\")\n",
    "\n",
    "color = 'blue'\n",
    "ax.annotate('Spines', xy=(4.0, 0.35), xycoords='data',\n",
    "            xytext=(3.3, 0.5), textcoords='data',\n",
    "            weight='bold', color=color,\n",
    "            arrowprops=dict(arrowstyle='->',\n",
    "                            connectionstyle=\"arc3\",\n",
    "                            color=color))\n",
    "\n",
    "ax.annotate('', xy=(3.15, 0.0), xycoords='data',\n",
    "            xytext=(3.45, 0.45), textcoords='data',\n",
    "            weight='bold', color=color,\n",
    "            arrowprops=dict(arrowstyle='->',\n",
    "                            connectionstyle=\"arc3\",\n",
    "                            color=color))\n",
    "\n",
    "ax.text(4.0, -0.4, \"Made with http://matplotlib.org\",\n",
    "        fontsize=10, ha=\"right\", color='.5')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Stateful Versus Stateless Approaches\n",
    "\n",
    "There is an important difference between the stateful (state-based, state-machine) and stateless (object-oriented, OO) interfaces.\n",
    "\n",
    "Above, we used import matplotlib.pyplot as plt to import the pyplot module from matplotlib and name it plt.\n",
    "\n",
    "Almost all functions from pyplot, such as plt.plot(), are implicitly either referring to an existing current Figure and current Axes, or creating them anew if none exist.\n",
    "\n",
    "We could say that “plt.plot() is a state-machine interface that implicitly tracks the current figure!” In plain words, this means that:\n",
    "\n",
    "* The stateful interface makes its calls with plt.plot() and other top-level pyplot functions. There is only ever one Figure or Axes that you’re manipulating at a given time, and you don’t need to explicitly refer to it.\n",
    "* Modifying the underlying objects directly is the object-oriented approach. We usually do this by calling methods of an Axes object, which is the object that represents a plot itself.\n",
    "\n",
    "This all boils down to the definition of `plt.plot()` as:\n",
    "``` python\n",
    "# matplotlib/pyplot.py\n",
    "def plot(*args, **kwargs):\n",
    "    \"\"\"An abridged version of plt.plot().\"\"\"\n",
    "    ax = plt.gca()\n",
    "    return ax.plot(*args, **kwargs)\n",
    "\n",
    "def gca(**kwargs):\n",
    "    \"\"\"Get the current Axes of the current Figure.\"\"\"\n",
    "    return plt.gcf().gca(**kwargs)\n",
    "```\n",
    "\n",
    "N.B.: the stateless (object-oriented) approach is typically more customizable and comes in handy as graphs become more complex."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A few simple examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#with plt.xkcd():\n",
    "rng = np.arange(50)\n",
    "rnd = np.random.randint(0, 10, size=(3, rng.size))\n",
    "yrs = 1950 + rng\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(10, 6))\n",
    "ax.stackplot(yrs, rng + rnd, labels=['Eastasia', 'Eurasia', 'Oceania'])\n",
    "ax.set_title('Combined debt growth over time')\n",
    "ax.legend(loc='upper left')\n",
    "ax.set_ylabel('Total debt')\n",
    "ax.set_xlim(left=yrs[0], right=yrs[-1])\n",
    "fig.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In details, that's what has been done above:\n",
    "\n",
    "* After creating three random time series, one Figure (fig) containing one Axes (a plot, ax) has been defined.\n",
    "\n",
    "* methods of ax have been called directly to create a stacked area chart and to add a legend, title, and y-axis label. Under the object-oriented approach, it’s clear that all of these are attributes of ax.\n",
    "\n",
    "* tight_layout() applies to the Figure object as a whole to clean up whitespace padding."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.random.randint(low=1, high=11, size=50)\n",
    "y = x + np.random.randint(1, 5, size=x.size)\n",
    "\n",
    "\n",
    "fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2, figsize=(12, 7))\n",
    "\n",
    "ax1.scatter(x=x, y=y, marker='o', c='r', edgecolor='r')\n",
    "ax1.set_title('Scatter: $x$ versus $y$')\n",
    "ax1.set_xlabel('$x$')\n",
    "ax1.set_ylabel('$y$')\n",
    "\n",
    "\n",
    "data = np.column_stack((x, y))\n",
    "# either this..\n",
    "#ax2.hist(data, bins=np.arange(data.min(), data.max()), label=('x', 'y'))\n",
    "# ..or this\n",
    "ax2.hist(x, bins=np.arange(data.min(), data.max()),label='x', alpha=0.5)\n",
    "ax2.hist(y, bins=np.arange(data.min(), data.max()),label='y', alpha=0.5)\n",
    "\n",
    "ax2.legend(loc=(0.65, 0.8))\n",
    "ax2.set_title('Frequencies of $x$ and $y$')\n",
    "ax2.yaxis.tick_right()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A few comments:\n",
    "\n",
    "* As a “1x2” Figure is created, the returned result of plt.subplots(1, 2) is now a Figure object and a NumPy array of Axes objects. Alternatively:\n",
    "\n",
    "``` python\n",
    "fig, ax = plt.subplots(nrows=1, ncols=2,figsize=(8, 4))\n",
    "# ax is now a numpy array of axes's\n",
    "```\n",
    "\n",
    "* We deal with ax1 and ax2 individually, which would be difficult to do with the stateful approach. The final line is a good illustration of the object hierarchy, where we are modifying the yaxis belonging to the second Axes, placing its ticks and ticklabels to the right.\n",
    "\n",
    "* Text inside dollar signs utilizes TeX markup (you can try fancier TeX stuff)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A more advanced example\n",
    "\n",
    "Let's consider some data from the housing market in California"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from io import BytesIO\n",
    "import tarfile\n",
    "from urllib.request import urlopen\n",
    "\n",
    "url = 'http://www.dcc.fc.up.pt/~ltorgo/Regression/cal_housing.tgz'\n",
    "b = BytesIO(urlopen(url).read())\n",
    "fpath = 'CaliforniaHousing/cal_housing.data'\n",
    "\n",
    "with tarfile.open(mode='r', fileobj=b) as archive:\n",
    "    housing = np.loadtxt(archive.extractfile(fpath), delimiter=',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "housing[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's extract a “response” variable $z$, which is an area’s average home value. $pop$ and $age$ are the area’s population and average house age, respectively:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = housing[:, -1]\n",
    "\n",
    "pop, age = housing[:, [4, 7]].T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's first create a fancy layout by means of `plt.subplot2grid`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gridsize = (3, 2)\n",
    "fig = plt.figure(figsize=(12, 8))\n",
    "\n",
    "ax1 = plt.subplot2grid(gridsize, (0, 0), colspan=2, rowspan=2)\n",
    "scatter = ax1.scatter(x=age, y=pop, c=z, cmap='RdYlGn')\n",
    "plt.colorbar(scatter, ax=ax1, format='$%d')\n",
    "ax1.set_title('Home value as a function of home age & area population', fontsize=14)\n",
    "ax1.set_yscale('log')\n",
    "\n",
    "ax2 = plt.subplot2grid(gridsize, (2, 0))\n",
    "n2, bins2, patches2 = ax2.hist(age, bins='auto')\n",
    "\n",
    "ax3 = plt.subplot2grid(gridsize, (2, 1))\n",
    "n3, bins3, patches3 = ax3.hist(pop, bins='auto', log=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Seaborn\n",
    "\n",
    "Seaborn is a wrapper around matplotlib which makes it better, with a better graphics and advanced functionalities, especially with what concerns statistical analysis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "#sns.set(style=\"darkgrid\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scatter plots\n",
    "\n",
    "Let's load some data and start play with it. (Seaborn is nice as it comes with plenty of example datasets you can load as pandas DataFrame)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tips = sns.load_dataset(\"tips\")\n",
    "tips.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's look at some example of scatter plot in seaborn. `sns.replot()` is most commonly used, which refers to `sns.scatterplot()`, also available.\n",
    "\n",
    "Essentialy we want to play with the \"extra dimensions\" it allows to display. Bear in mind that the more dimensions you put in there, the more difficult the plot results to read.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.relplot(x=\"total_bill\", y=\"tip\", hue=\"smoker\", data=tips);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.relplot(x=\"total_bill\", y=\"tip\", hue=\"smoker\", style=\"time\", data=tips);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Not only categorical but also quantitative \"3rd dimension\" is of course possible"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.relplot(x=\"total_bill\", y=\"tip\", hue=\"size\", data=tips);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.relplot(x=\"total_bill\", y=\"tip\", size=\"size\", sizes=(15, 200), data=tips);\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Histograms\n",
    "\n",
    "Seaborn does plenty of things with histograms, not just in terms of graphics, but in terms of statistical analysis too. The `distplot()` method by default plots the kernel density estimate ([KDE](https://en.wikipedia.org/wiki/Kernel_density_estimation))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.random.randn(100)\n",
    "sns.displot(x, kde=True);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# with unbinned distribution too\n",
    "sns.distplot(x, kde=False, rug=True);\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy import stats\n",
    "x = np.random.gamma(6, size=200)\n",
    "sns.distplot(x, kde=False, fit=stats.gamma);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scatter plots and projections\n",
    "\n",
    "`sns.jointplot()` allows to visualize at the same time both the (cor-)relation between two quantities and "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "mean, cov = [0, 1], [(1, .5), (.5, 1)]\n",
    "data = np.random.multivariate_normal(mean, cov, 500)\n",
    "df = pd.DataFrame(data, columns=[\"x\", \"y\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.jointplot(x=\"x\", y=\"y\", data=df);\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f, ax = plt.subplots(figsize=(6, 6))\n",
    "cmap = sns.cubehelix_palette(as_cmap=True, dark=0, light=1, reverse=True)\n",
    "sns.kdeplot(df.x, df.y, cmap=cmap, n_levels=60, shade=True);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g = sns.jointplot(\"total_bill\", \"tip\", data=tips, kind=\"hex\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g = sns.jointplot(\"total_bill\", \"tip\", data=tips, kind=\"reg\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris = sns.load_dataset(\"iris\")\n",
    "\n",
    "g = sns.jointplot(\"sepal_width\", \"petal_length\", data=iris,kind=\"kde\", space=0, color=\"g\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Chasing correlations\n",
    "\n",
    "Seaborn allows you to look for correlations systematically checking pair-wise your dataset's features\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.pairplot(iris);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g= sns.PairGrid(iris)\n",
    "g.map_diag(sns.kdeplot)\n",
    "g.map_offdiag(sns.kdeplot, n_levels=6);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot accessibility (Bokeh, Plotly, etc.)\n",
    "\n",
    "More often than not plots needs to be accessible from remote, thus ways of publishing on web servers results extremely useful. In the following an example from Bokeh is shown.\n",
    "Other tools like [Dash](https://plot.ly/products/dash/) are extremely powerful and worth checking out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from bokeh.plotting import figure, output_file, show\n",
    "\n",
    "# prepare some data\n",
    "x = [0.1, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0]\n",
    "y0 = [i**2 for i in x]\n",
    "y1 = [10**i for i in x]\n",
    "y2 = [10**(i**2) for i in x]\n",
    "\n",
    "# output to static HTML file\n",
    "output_file(\"log_lines.html\")\n",
    "\n",
    "# create a new plot\n",
    "p = figure(\n",
    "   tools=\"pan,box_zoom,reset,save\",\n",
    "   y_axis_type=\"log\", y_range=[0.001, 10**11], title=\"log axis example\",\n",
    "   x_axis_label='sections', y_axis_label='particles'\n",
    ")\n",
    "\n",
    "# add some renderers\n",
    "p.line(x, x, legend=\"y=x\")\n",
    "p.circle(x, x, legend=\"y=x\", fill_color=\"white\", size=8)\n",
    "p.line(x, y0, legend=\"y=x^2\", line_width=3)\n",
    "p.line(x, y1, legend=\"y=10^x\", line_color=\"red\")\n",
    "p.circle(x, y1, legend=\"y=10^x\", fill_color=\"red\", line_color=\"red\", size=6)\n",
    "p.line(x, y2, legend=\"y=10^x^2\", line_color=\"orange\", line_dash=\"4 4\")\n",
    "\n",
    "# show the results\n",
    "show(p)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In whatever we played with above, try adding:\n",
    "```python\n",
    "with plt.xkcd():\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}