pfandzelter/bar_chart.ipynb

## bar_chart.ipynb
{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import seaborn, pyplot (for plotting), and pandas (to build the dataframe)\n",
    "import seaborn as sns\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we input our data as the following table:  \n",
    "\n",
    "| | X1 | X2 | X3 |\n",
    "| :------------- | :----------: | :----------: | -----------: |\n",
    "| Test T1 | 36.08911234 | 35.44650908 | 13.28387507 |\n",
    "| Test T2 | 334.0905209 | 332.8183322 | 114.2073644 |\n",
    "| Test T3 | 125.7836401 | 331.9770472 | 132.2351763 |\n",
    "\n",
    "Then, we make a pandas dataframe from it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Experiment Setup         T1          T2          T3\n",
      "0               X1  36.089112  334.090521  125.783640\n",
      "1               X2  35.446509  332.818332  331.977047\n",
      "2               X3  13.283875  114.207364  132.235176\n"
     ]
    }
   ],
   "source": [
    "# input data\n",
    "data = {\"Experiment Setup\":  [\"X1\", \"X2\", \"X3\"],\n",
    "        \"T1\": [36.08911234, 35.44650908, 13.28387507],\n",
    "        \"T2\": [334.0905209, 332.8183322, 114.207364],\n",
    "        \"T3\": [125.7836401, 331.977047, 132.2351763]\n",
    "       }\n",
    "\n",
    "# make a dataframe\n",
    "data = pd.DataFrame(\n",
    "    data, columns=[\"Experiment Setup\", \"T1\", \"T2\", \"T3\"])\n",
    "\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, melt the dataframe to make data easier to handle for seaborn.\n",
    "It will look something like this:  \n",
    "\n",
    "| Test | Experiment Setup | Latency in ms |\n",
    "| :------------- | :----------: | -----------: |\n",
    "| Test T1 | X1 | 36.08911234 |\n",
    "| Test T1 | X2 | 35.44650908 |\n",
    "| Test T1 | X3 | 13.28387507 |\n",
    "| Test T2 | X1 | 334.0905209 |\n",
    "| Test T2 | X2 | 332.8183322 |\n",
    "| Test T2 | X3 | 114.2073644 |\n",
    "| Test T3 | X1 | 125.7836401 |\n",
    "| Test T3 | X2 | 331.9770472 |\n",
    "| Test T3 | X3 | 132.2351763 |\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Experiment Setup Test  Latency in ms\n",
      "0               X1   T1      36.089112\n",
      "1               X2   T1      35.446509\n",
      "2               X3   T1      13.283875\n",
      "3               X1   T2     334.090521\n",
      "4               X2   T2     332.818332\n",
      "5               X3   T2     114.207364\n",
      "6               X1   T3     125.783640\n",
      "7               X2   T3     331.977047\n",
      "8               X3   T3     132.235176\n"
     ]
    }
   ],
   "source": [
    "# transform dataframe\n",
    "\n",
    "data_M = pd.melt(data, id_vars=\"Experiment Setup\", var_name=\"Test\",\n",
    "                  value_name=\"Latency in ms\")\n",
    "\n",
    "print(data_M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set style for seaborn plot\n",
    "sns.set(style=\"whitegrid\", font=\"CMU Sans Serif\")\n",
    "# create a color palette (we only have three different colors for the three different tests T1...T3)\n",
    "pal = sns.color_palette(n_colors=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# let's create a figure for our two plots to live in\n",
    "# we need a lower part (anything below the cutoff), which will be ax2\n",
    "# and an upper part (anything above the cutoff) which will be ax1\n",
    "# because we have only two plots above each other, we set ncols=1 and nrows=2\n",
    "# also, they should share an x axis, which is why we set sharex=True\n",
    "f, (ax1, ax2) = plt.subplots(ncols=1, nrows=2,\n",
    "                             sharex=True)\n",
    "\n",
    "# we want the \"Test\" to appear on the x axis as individual parameters\n",
    "# \"Latency in ms\" should be what is shown on the y axis as a value\n",
    "# hue should be the \"Experiment Setup\"\n",
    "# this will result three ticks on the x axis with X1...X3 and each with three bars for T1...T3\n",
    "# (you could turn this around if you need to, depending on what kind of data you want to show)\n",
    "ax1 = sns.barplot(x=\"Test\", y=\"Latency in ms\",\n",
    "                  hue=\"Experiment Setup\", data=data_M, palette=pal, ax=ax1)\n",
    "\n",
    "# we basically do the same thing again for the second plot\n",
    "ax2 = sns.barplot(x=\"Test\", y=\"Latency in ms\",\n",
    "                  hue=\"Experiment Setup\", data=data_M, palette=pal, ax=ax2)\n",
    "\n",
    "# here is the fun part: setting the limits for the individual y axis\n",
    "# the upper part (ax1) should show only values from 250 to 400\n",
    "# the lower part (ax2) should only show 0 to 150\n",
    "# you can define your own limits, but the range (150) should be the same so scale is the same across both plots\n",
    "# it could be possible to use a different range and then adjust plot height but who knows how that works\n",
    "ax1.set_ylim(250, 400)\n",
    "ax2.set_ylim(0, 150)\n",
    "\n",
    "# the upper part does not need its own x axis as it shares one with the lower part\n",
    "ax1.get_xaxis().set_visible(False)\n",
    "\n",
    "# by default, each part will get its own \"Latency in ms\" label, but we want to set a common for the whole figure\n",
    "# first, remove the y label for both subplots\n",
    "ax1.set_ylabel(\"\")\n",
    "ax2.set_ylabel(\"\")\n",
    "# then, set a new label on the plot (basically just a piece of text) and move it to where it makes sense (requires trial and error)\n",
    "f.text(0.05, 0.55, \"Latency in ms\", va=\"center\", rotation=\"vertical\")\n",
    "\n",
    "# by default, seaborn also gives each subplot its own legend, which makes no sense at all\n",
    "# soe remove both default legends first\n",
    "ax1.get_legend().remove()\n",
    "ax2.get_legend().remove()\n",
    "# then create a new legend and put it to the side of the figure (also requires trial and error)\n",
    "ax2.legend(loc=(1.025, 0.5), title=\"Design\")\n",
    "\n",
    "# let's put some ticks on the top of the upper part and bottom of the lower part for style\n",
    "ax1.xaxis.tick_top()\n",
    "ax2.xaxis.tick_bottom()\n",
    "\n",
    "# finally, adjust everything a bit to make it prettier (this just moves everything, best to try and iterate)\n",
    "f.subplots_adjust(left=0.15, right=0.85, bottom=0.15, top=0.85)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# now for the fun part, this is just copied from https://matplotlib.org/examples/pylab_examples/broken_axis.html\n",
    "# (most of this is, actually)\n",
    "# here, we create these little diagonal lines that bring this chart to a whole new level:\n",
    "\n",
    "# This looks pretty good, and was fairly painless, but you can get that\n",
    "# cut-out diagonal lines look with just a bit more work. The important\n",
    "# thing to know here is that in axes coordinates, which are always\n",
    "# between 0-1, spine endpts are at these locations (0,0), (0,1),\n",
    "# (1,0), and (1,1).  Thus, we just need to put the diagonals in the\n",
    "# appropriate corners of each of our axes, and so long as we use the\n",
    "# right transform and disable clipping.\n",
    "\n",
    "d = .01  # how big to make the diagonal lines in axes coordinates\n",
    "# arguments to pass to plot, just so we don't keep repeating them\n",
    "kwargs = dict(transform=ax1.transAxes, color=\"k\", clip_on=False)\n",
    "ax1.plot((-d, +d), (-d, +d), **kwargs)        # top-left diagonal\n",
    "ax1.plot((1 - d, 1 + d), (-d, +d), **kwargs)  # top-right diagonal\n",
    "\n",
    "kwargs.update(transform=ax2.transAxes)  # switch to the bottom axes\n",
    "ax2.plot((-d, +d), (1 - d, 1 + d), **kwargs)  # bottom-left diagonal\n",
    "ax2.plot((1 - d, 1 + d), (1 - d, 1 + d), **kwargs)  # bottom-right diagonal\n",
    "\n",
    "# display new plot again\n",
    "# https://stackoverflow.com/questions/50452455/plt-show-does-nothing-when-used-for-the-second-time\n",
    "from IPython.display import display\n",
    "display(f)  # Shows plot again"
   ]
  }
 ],
 "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.9.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}