life_and_death.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Life expectancy versus GDP per capita from 1952 - 2007"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Function definitions for animated bubble plot (to be run once, but not to be changed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define a function to set the colour of the points for each category."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def colour_scheme(category, colourscheme):\n",
    "    # return colour corresponding to category\n",
    "    for i in range(0, len(colourscheme.iloc[:,0])):\n",
    "        if (colourscheme.iloc[i,0] == category):\n",
    "            return colourscheme.iloc[i,1]\n",
    "    \n",
    "    # if no match return black\n",
    "    return 'black'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define function to create animation of atomic bomb tests, with points coloured by country and sized by bomb yield. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import numbers\n",
    "from datetime import datetime\n",
    "import plotly.offline as py\n",
    "import plotly.graph_objs as go\n",
    "\n",
    "def bubble_animation(dataset, colourscheme, filename, variable_x, variable_y, variable_category, variable_size, \\\n",
    "                variable_time, variable_hover=None, logscale_x=False, logscale_y=False):\n",
    "    # check if x variable is an accepted format\n",
    "    if not isinstance(dataset[variable_x][0], (numbers.Real, datetime)):\n",
    "        if logscale_x==False:\n",
    "            try:\n",
    "                for i in range(0, len(dataset[variable_x])):\n",
    "                    dataset[variable_x][i] = datetime.strptime(dataset[variable_x][i], '%H:%M')\n",
    "            except:\n",
    "                print('variable_x is not a continuous variable or an accepted time format')\n",
    "                return\n",
    "        else:\n",
    "            print('variable_x is not a continuous variable or an accepted time format')\n",
    "            return            \n",
    "    # check if y variable is an accepted format\n",
    "    if not isinstance(dataset[variable_y][0], numbers.Real):\n",
    "        print('variable_y is not a continuous variable')\n",
    "        return  \n",
    "    # check if size variable is an accepted format\n",
    "    if not isinstance(dataset[variable_y][0], numbers.Real):\n",
    "        print('variable_size is not a continuous variable')\n",
    "        return  \n",
    "    \n",
    "    # make list of times\n",
    "    times = []\n",
    "    for time in dataset[variable_time]:\n",
    "        if time not in times:\n",
    "            times.append(time)\n",
    "    # make list of categories\n",
    "    categories = []\n",
    "    for category in dataset[variable_category]:\n",
    "        if category not in categories:\n",
    "            categories.append(category)\n",
    "    # derive typical point size to scale bubbles\n",
    "    sizeref = 0.005*np.quantile(dataset[variable_size], 0.95)\n",
    "  \n",
    "    # define figure contents using a dictionary\n",
    "    fig_dict = {\n",
    "        \"data\": [],\n",
    "        \"layout\": {},\n",
    "        \"frames\": []\n",
    "    }\n",
    "\n",
    "    # fill in most of the layout\n",
    "    if logscale_x == True:\n",
    "        xmin = np.log10(np.quantile(dataset[variable_x], 0.005))\n",
    "        xmax = np.log10(np.quantile(dataset[variable_x], 0.995))\n",
    "        fig_dict[\"layout\"][\"xaxis\"] = {\"range\": [xmin - 0.1*(xmax - xmin), \\\n",
    "                        xmax + 0.1*(xmax - xmin)], \"zeroline\": False, \"title\": variable_x, \"type\": \"log\"}\n",
    "    else:\n",
    "        if isinstance(dataset[variable_x][0], datetime):\n",
    "            xmin = min(dataset[variable_x])\n",
    "            xmax = max(dataset[variable_x])\n",
    "            fig_dict[\"layout\"][\"xaxis\"] = {\"range\": [xmin - 0.1*(xmax - xmin), \\\n",
    "                            xmax + 0.1*(xmax - xmin)], \"zeroline\": False, \"title\": variable_x, \"tickformat\": \"%H:%M\"}\n",
    "        else:\n",
    "            xmin = np.quantile(dataset[variable_x], 0.005)\n",
    "            xmax = np.quantile(dataset[variable_x], 0.995)\n",
    "            fig_dict[\"layout\"][\"xaxis\"] = {\"range\": [xmin - 0.1*(xmax - xmin), \\\n",
    "                            xmax + 0.1*(xmax - xmin)], \"zeroline\": False, \"title\": variable_x}            \n",
    "    if logscale_y == True:\n",
    "        ymin = np.log10(np.quantile(dataset[variable_y], 0.005))\n",
    "        ymax = np.log10(np.quantile(dataset[variable_y], 0.995))\n",
    "        fig_dict[\"layout\"][\"yaxis\"] = {\"range\": [ymin - 0.1*(ymax - ymin), \\\n",
    "                        ymax + 0.1*(ymax - ymin)], \"zeroline\": False, \"title\": variable_y, \"type\": \"log\"}\n",
    "    else:\n",
    "        ymin = np.quantile(dataset[variable_y], 0.005)\n",
    "        ymax = np.quantile(dataset[variable_y], 0.995)\n",
    "        fig_dict[\"layout\"][\"yaxis\"] = {\"range\": [ymin - 0.1*(ymax - ymin), \\\n",
    "                        ymax + 0.1*(ymax - ymin)], \"zeroline\": False, \"title\": variable_y}\n",
    "    fig_dict[\"layout\"][\"hovermode\"] = \"closest\"\n",
    "    fig_dict[\"layout\"][\"plot_bgcolor\"] = \"white\"\n",
    "    fig_dict[\"layout\"][\"sliders\"] = {\n",
    "        \"args\": [\"transition\", {\"duration\": 400, \"easing\": \"cubic-in-out\"}],\n",
    "        \"initialValue\": min(times), \"plotlycommand\": \"animate\", \"values\": dataset[variable_time], \\\n",
    "        \"visible\": True\n",
    "    }\n",
    "    fig_dict[\"layout\"][\"updatemenus\"] = [\n",
    "        {\n",
    "            \"buttons\": [\n",
    "                {\n",
    "                    \"args\": [None, {\"frame\": {\"duration\": 500, \"redraw\": False}, \"fromcurrent\": False, \\\n",
    "                                    \"transition\": {\"duration\": 300, \"easing\": \"quadratic-in-out\"}}],\n",
    "                    \"label\": \"Play\",\n",
    "                    \"method\": \"animate\"\n",
    "                },\n",
    "                {\n",
    "                    \"args\": [[None], {\"frame\": {\"duration\": 0, \"redraw\": False}, \"mode\": \"immediate\", \\\n",
    "                                      \"transition\": {\"duration\": 0}}],\n",
    "                    \"label\": \"Pause\",\n",
    "                    \"method\": \"animate\"\n",
    "                }\n",
    "            ],\n",
    "            \"direction\": \"left\", \"pad\": {\"r\": 10, \"t\": 87}, \"showactive\": True, \"type\": \"buttons\", \\\n",
    "            \"x\": 0.1, \"xanchor\": \"right\", \"y\": 0, \"yanchor\": \"top\"\n",
    "        }\n",
    "    ]\n",
    "    \n",
    "    prefix = variable_time+':'\n",
    "    sliders_dict = {\n",
    "        \"active\": 0, \"yanchor\": \"top\", \"xanchor\": \"left\",\n",
    "        \"currentvalue\": {\n",
    "            \"font\": {\"size\": 18},\n",
    "            \"prefix\": prefix,\n",
    "            \"visible\": True,\n",
    "            \"xanchor\": \"right\"\n",
    "        },\n",
    "        \"transition\": {\"duration\": 300, \"easing\": \"cubic-in-out\"},\n",
    "        \"pad\": {\"b\": 10, \"t\": 50}, \"len\": 0.9, \"x\": 0.1, \"y\": 0, \"steps\": []\n",
    "    }\n",
    "\n",
    "    # make 'fake' data for first year to set up plot correctly\n",
    "    if not isinstance(time, (numbers.Real, datetime)):\n",
    "        time = times[0]\n",
    "    else:\n",
    "        time = min(times)    \n",
    "    for category in categories:\n",
    "        dataset_by_time_and_category = dataset[(dataset[variable_time] == time) & \\\n",
    "                        (dataset[variable_category] == category)]\n",
    "        if variable_hover == None:\n",
    "            hovertext = False\n",
    "        else:\n",
    "            hovertext = np.insert(dataset_by_time_and_category[variable_hover].values, 0, -999999).tolist()\n",
    "        data_dict = {\n",
    "            \"x\": np.insert(dataset_by_time_and_category[variable_x].values.astype(type(dataset[variable_x])), \\\n",
    "                            0, dataset[variable_x][0]).tolist(),\n",
    "            \"y\": np.insert(dataset_by_time_and_category[variable_y].values.astype(type(dataset[variable_y])), \\\n",
    "                            0, -999999).tolist(),\n",
    "            \"mode\": \"markers\",\n",
    "            \"text\": np.insert(dataset_by_time_and_category[variable_time].values, 0, -999999).tolist(),\n",
    "            \"hovertext\": hovertext,\n",
    "            \"marker\": {\n",
    "                \"sizemode\": \"area\",\n",
    "                \"sizeref\": sizeref,\n",
    "                \"size\": np.fmax(np.insert(dataset_by_time_and_category[variable_size].values.astype(float), \\\n",
    "                                0, -999999), 10*sizeref).tolist(),\n",
    "                \"color\": colour_scheme(category, colourscheme)\n",
    "            },\n",
    "            \"name\": category\n",
    "        }\n",
    "        fig_dict[\"data\"].append(data_dict)\n",
    "\n",
    "    # make frames for each year of the animation\n",
    "    for time in times:\n",
    "        frame = {\"data\": [], \"name\": str(time)}\n",
    "        for category in categories:\n",
    "            dataset_by_time_and_category = dataset[(dataset[variable_time] == time) & \\\n",
    "                            (dataset[variable_category] == category)]\n",
    "            if variable_hover == None:\n",
    "                hovertext = False\n",
    "            else:\n",
    "                hovertext = np.insert(dataset_by_time_and_category[variable_hover].values, 0, -999999).tolist()\n",
    "            data_dict = {\n",
    "                \"x\": np.insert(dataset_by_time_and_category[variable_x].values.astype(type(dataset[variable_x])), \\\n",
    "                               0, dataset[variable_x][0]).tolist(),\n",
    "                \"y\": np.insert(dataset_by_time_and_category[variable_y].values.astype(type(dataset[variable_y])), \\\n",
    "                               0, -999999).tolist(),\n",
    "                \"mode\": \"markers\",\n",
    "                \"text\": np.insert(dataset_by_time_and_category[variable_time].values, 0, -999999).tolist(),\n",
    "                \"hovertext\": hovertext,\n",
    "                \"marker\": {\n",
    "                    \"sizemode\": \"area\",\n",
    "                    \"sizeref\": sizeref,\n",
    "                    \"size\": np.fmax(np.insert(dataset_by_time_and_category[variable_size].values.astype(float), \\\n",
    "                                    0, -999999), 10*sizeref).tolist(),\n",
    "                    \"color\": colour_scheme(category, colourscheme)\n",
    "                },\n",
    "                \"name\": category\n",
    "            }\n",
    "            frame[\"data\"].append(data_dict)\n",
    "\n",
    "        fig_dict[\"frames\"].append(frame)\n",
    "        slider_step = {\"args\": [\n",
    "            [time],\n",
    "            {\"frame\": {\"duration\": 500, \"redraw\": False}, \"mode\": \"immediate\", \"transition\": {\"duration\": 300}}\n",
    "        ],\n",
    "            \"label\": time, \"method\": \"animate\"}\n",
    "        sliders_dict[\"steps\"].append(slider_step)\n",
    "\n",
    "    fig_dict[\"layout\"][\"sliders\"] = [sliders_dict]\n",
    "\n",
    "    # plot the figure\n",
    "    fig = go.Figure(data=fig_dict) # for scatter plot\n",
    "    py.plot(fig, config={'scrollzoom': False}, filename=filename)\n",
    "    fig.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Import bubble plot timeseries dataset, and colourscheme to apply to each category (change file location as desired)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import the Life and Death timeseires dataset from `github` repository into a `pandas` dataframe. Note this reads in the `.csv` version of the dataset directly from `github`.\n",
    "\n",
    "This dataset must include at least three numerical variables, a categorical variable, and a time variable. The column headers are used as function inputs to specify which variable will be plotted along which axis etc. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "# read-in the dataset from github into a pandas dataframe\n",
    "url = \"https://raw.githubusercontent.com/xbr209/tutorials/master/Life_and_death_timeseries.csv\"\n",
    "dataset = pd.read_csv(url)\n",
    "\n",
    "# print out the pandas dataframe to screen\n",
    "dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import the Life and Death colourscheme dataset from `github` repository into a `pandas` dataframe.\n",
    "\n",
    "This dataset is formatted so that the first column is the category name (used in the main dataset) and the second column is the colour name to be used for that group. The colour name must be in a format recognised by `plotly`; the full range of colours can be found at https://matplotlib.org/3.1.0/gallery/color/named_colors.html."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# read-in colour scheme for each group from github into a pandas dataframe\n",
    "url = \"https://raw.githubusercontent.com/xbr209/tutorials/master/Life_and_death_colourscheme.csv\"\n",
    "colourscheme = pd.read_csv(url)\n",
    "\n",
    "colourscheme"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Produce network plot from input dataset and colour scheme"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create the animated bubble plot of the life expectancy as a function of GDP per capita, with the population as the point size, the continent as the colour, and the year as the time variable.\n",
    "\n",
    "The 'bubble_animation' function takes the dataset, colourscheme and output filename as parameters, then the names of the x variable, y variable, categorical variable, point size variable, time series variable. The function also takes three optional parameters, the name of an addition column of text to display upon hovering over points, and two true/false variables that state whether the x and y axes are log scale or not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bubble_animation(dataset, colourscheme, 'bubble_animation', variable_x='GDP per capita', \\\n",
    "                variable_y='Life expectancy at birth, total (years)', variable_category='Continent', \\\n",
    "                variable_size='Population', variable_time='Year', variable_hover='Country', \\\n",
    "                logscale_x=True, logscale_y=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}