Thompson_sampling_algorithm.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Maximizing revenues of online retail with Thompson sampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Artificial Intelligence for Business\n",
    "# Importing the libraries\n",
    "import numpy as np\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import random"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Define the environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 287,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Setting the parameters\n",
    "N = 10000   # number of rounds - customer visiting web page with Ad\n",
    "d = 9       # number of strategies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 288,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating the simulation (for 9 strategies here)\n",
    "# These are unknown in a real business case - for simulation only\n",
    "#conversion_rates = [0.05,0.13,0.09,0.19,0.11,0.04,0.20,0.08,0.01]\n",
    "conversion_rates = [0.05,0.13,0.09,0.16,0.11,0.04,0.20,0.08,0.01]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 289,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the reward matrix (num of rounds x result for each strategy)\n",
    "rewards = np.zeros((N,d))\n",
    "# populate matrix according to the conversion rates\n",
    "for i in range(N):\n",
    "    for j in range(d):\n",
    "        if np.random.rand() <= conversion_rates[j]:   # np.random.rand(d0, d1, ..., dn) returns Random values [0,1[ in a given shape d0xd1x...\n",
    "            rewards[i,j] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 290,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 1. 0.]\n",
      " [0. 1. 0. ... 0. 0. 0.]\n",
      " ...\n",
      " [0. 0. 0. ... 1. 0. 0.]\n",
      " [0. 1. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]]\n",
      "(10000, 9)\n"
     ]
    }
   ],
   "source": [
    "print(rewards)\n",
    "print(rewards.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Implement random strategy and Thompson Sampling for comparison"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 291,
   "metadata": {},
   "outputs": [],
   "source": [
    "selected_strategies_random = []\n",
    "selected_strategies_thompson = []\n",
    "total_rewards_random = 0\n",
    "total_rewards_thompson = 0\n",
    "numbers_of_rewards_1 = np.zeros(d)\n",
    "numbers_of_rewards_0 = np.zeros(d)\n",
    "reward_per_strategy = np.zeros(d)\n",
    "regret_curve_random = []\n",
    "regret_curve_thompson = []\n",
    "\n",
    "for n in range(N):\n",
    "    \n",
    "    # Random strategy\n",
    "    selected_strategy_random = random.randrange(d)\n",
    "    selected_strategies_random.append(selected_strategy_random)\n",
    "    total_rewards_random+= rewards[n,selected_strategy_random]\n",
    "    \n",
    "    # Thompson Sampling Strategy\n",
    "    max_random_beta = 0\n",
    "    startegy_with_max_beta = 0\n",
    "    \n",
    "    # for each strategy, random draw from beta distribution with 2 parameters then select highest\n",
    "    for i in range(d):\n",
    "        random_beta = random.betavariate(numbers_of_rewards_1[i]+1, numbers_of_rewards_0[i]+1) # return value in range 0,1\n",
    "        if random_beta > max_random_beta:\n",
    "            max_random_beta = random_beta\n",
    "            startegy_with_max_beta_draw = i\n",
    "    \n",
    "    # Update Beta distribution parameters of selected strategy\n",
    "    if rewards[n,startegy_with_max_beta_draw]==1:\n",
    "        numbers_of_rewards_1[startegy_with_max_beta_draw]+=1\n",
    "    else:\n",
    "        numbers_of_rewards_0[startegy_with_max_beta_draw]+=1\n",
    "        \n",
    "    # Update Thompson sampling strategy KPIs\n",
    "    selected_strategies_thompson.append(startegy_with_max_beta_draw)\n",
    "    total_rewards_thompson += rewards[n,startegy_with_max_beta_draw]\n",
    "    \n",
    "    # Score per strategy\n",
    "    for i in range(d):\n",
    "        reward_per_strategy[i] +=rewards[n, i]\n",
    "    \n",
    "    # Regret as the difference between slected strategy and best strategy\n",
    "    regret = max(reward_per_strategy) - total_rewards_random\n",
    "    regret_curve_random.append(regret)\n",
    "    regret = max(reward_per_strategy) - total_rewards_thompson\n",
    "    regret_curve_thompson.append(regret)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Measure performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 292,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Computing the Absolute and Relative Return\n",
    "# in absolute monetary value assuming 1K€ extra revenue for each premium plan\n",
    "absolute_return = (total_rewards_thompson - total_rewards_random) * 1\n",
    "# profit increase in % vs random strategy\n",
    "relative_return = (total_rewards_thompson - total_rewards_random) / total_rewards_random * 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 293,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Performance achieved over 10000 samples and the assumed strategy conversion rate:\n",
      "Absolute return: 961K€ extra profits\n",
      "Relative return: 98 % profit increase\n"
     ]
    }
   ],
   "source": [
    "print(f'Performance achieved over {N} samples and the assumed strategy conversion rate:')\n",
    "print('Absolute return: {:.0f}K€ extra profits'.format(absolute_return))\n",
    "print('Relative return: {:.0f} % profit increase'.format(relative_return))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plot histogram of selected strategies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 294,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "plt.hist(selected_strategies_thompson, align='mid', rwidth=0.5)\n",
    "plt.title('Histogram of selected strategies')\n",
    "plt.xlabel('Strategy')\n",
    "plt.ylabel('Times strategy is selected')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 295,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x2b3ec46fec8>"
      ]
     },
     "execution_count": 295,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(range(1000), selected_strategies_thompson[:1000], marker='.', alpha=0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 296,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_scatter(k):\n",
    "    plt.scatter(range(10*k,10*k+10), selected_strategies_thompson[10*k:10*k+10], marker='.', c='b', alpha=0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 297,
   "metadata": {},
   "outputs": [],
   "source": [
    "# initialize a writer which uses ffmpeg and records at 20 fps with a bitrate of 1800\n",
    "import matplotlib.animation as animation\n",
    "Writer = animation.writers['ffmpeg']\n",
    "writer = Writer(fps=5, metadata=dict(artist='Me'), bitrate=1800)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 298,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 299,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "/* global mpl */\n",
       "window.mpl = {};\n",
       "\n",
       "mpl.get_websocket_type = function () {\n",
       "    if (typeof WebSocket !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof MozWebSocket !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert(\n",
       "            'Your browser does not have WebSocket support. ' +\n",
       "                'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "                'Firefox 4 and 5 are also supported but you ' +\n",
       "                'have to enable WebSockets in about:config.'\n",
       "        );\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = this.ws.binaryType !== undefined;\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById('mpl-warnings');\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent =\n",
       "                'This browser does not support binary websocket messages. ' +\n",
       "                'Performance may be slow.';\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = document.createElement('div');\n",
       "    this.root.setAttribute('style', 'display: inline-block');\n",
       "    this._root_extra_style(this.root);\n",
       "\n",
       "    parent_element.appendChild(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen = function () {\n",
       "        fig.send_message('supports_binary', { value: fig.supports_binary });\n",
       "        fig.send_message('send_image_mode', {});\n",
       "        if (fig.ratio !== 1) {\n",
       "            fig.send_message('set_dpi_ratio', { dpi_ratio: fig.ratio });\n",
       "        }\n",
       "        fig.send_message('refresh', {});\n",
       "    };\n",
       "\n",
       "    this.imageObj.onload = function () {\n",
       "        if (fig.image_mode === 'full') {\n",
       "            // Full images could contain transparency (where diff images\n",
       "            // almost always do), so we need to clear the canvas so that\n",
       "            // there is no ghosting.\n",
       "            fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "        }\n",
       "        fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "    };\n",
       "\n",
       "    this.imageObj.onunload = function () {\n",
       "        fig.ws.close();\n",
       "    };\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._init_header = function () {\n",
       "    var titlebar = document.createElement('div');\n",
       "    titlebar.classList =\n",
       "        'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n",
       "    var titletext = document.createElement('div');\n",
       "    titletext.classList = 'ui-dialog-title';\n",
       "    titletext.setAttribute(\n",
       "        'style',\n",
       "        'width: 100%; text-align: center; padding: 3px;'\n",
       "    );\n",
       "    titlebar.appendChild(titletext);\n",
       "    this.root.appendChild(titlebar);\n",
       "    this.header = titletext;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function () {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = (this.canvas_div = document.createElement('div'));\n",
       "    canvas_div.setAttribute(\n",
       "        'style',\n",
       "        'border: 1px solid #ddd;' +\n",
       "            'box-sizing: content-box;' +\n",
       "            'clear: both;' +\n",
       "            'min-height: 1px;' +\n",
       "            'min-width: 1px;' +\n",
       "            'outline: 0;' +\n",
       "            'overflow: hidden;' +\n",
       "            'position: relative;' +\n",
       "            'resize: both;'\n",
       "    );\n",
       "\n",
       "    function on_keyboard_event_closure(name) {\n",
       "        return function (event) {\n",
       "            return fig.key_event(event, name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    canvas_div.addEventListener(\n",
       "        'keydown',\n",
       "        on_keyboard_event_closure('key_press')\n",
       "    );\n",
       "    canvas_div.addEventListener(\n",
       "        'keyup',\n",
       "        on_keyboard_event_closure('key_release')\n",
       "    );\n",
       "\n",
       "    this._canvas_extra_style(canvas_div);\n",
       "    this.root.appendChild(canvas_div);\n",
       "\n",
       "    var canvas = (this.canvas = document.createElement('canvas'));\n",
       "    canvas.classList.add('mpl-canvas');\n",
       "    canvas.setAttribute('style', 'box-sizing: content-box;');\n",
       "\n",
       "    this.context = canvas.getContext('2d');\n",
       "\n",
       "    var backingStore =\n",
       "        this.context.backingStorePixelRatio ||\n",
       "        this.context.webkitBackingStorePixelRatio ||\n",
       "        this.context.mozBackingStorePixelRatio ||\n",
       "        this.context.msBackingStorePixelRatio ||\n",
       "        this.context.oBackingStorePixelRatio ||\n",
       "        this.context.backingStorePixelRatio ||\n",
       "        1;\n",
       "\n",
       "    this.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "    if (this.ratio !== 1) {\n",
       "        fig.send_message('set_dpi_ratio', { dpi_ratio: this.ratio });\n",
       "    }\n",
       "\n",
       "    var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n",
       "        'canvas'\n",
       "    ));\n",
       "    rubberband_canvas.setAttribute(\n",
       "        'style',\n",
       "        'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n",
       "    );\n",
       "\n",
       "    var resizeObserver = new ResizeObserver(function (entries) {\n",
       "        var nentries = entries.length;\n",
       "        for (var i = 0; i < nentries; i++) {\n",
       "            var entry = entries[i];\n",
       "            var width, height;\n",
       "            if (entry.contentBoxSize) {\n",
       "                if (entry.contentBoxSize instanceof Array) {\n",
       "                    // Chrome 84 implements new version of spec.\n",
       "                    width = entry.contentBoxSize[0].inlineSize;\n",
       "                    height = entry.contentBoxSize[0].blockSize;\n",
       "                } else {\n",
       "                    // Firefox implements old version of spec.\n",
       "                    width = entry.contentBoxSize.inlineSize;\n",
       "                    height = entry.contentBoxSize.blockSize;\n",
       "                }\n",
       "            } else {\n",
       "                // Chrome <84 implements even older version of spec.\n",
       "                width = entry.contentRect.width;\n",
       "                height = entry.contentRect.height;\n",
       "            }\n",
       "\n",
       "            // Keep the size of the canvas and rubber band canvas in sync with\n",
       "            // the canvas container.\n",
       "            if (entry.devicePixelContentBoxSize) {\n",
       "                // Chrome 84 implements new version of spec.\n",
       "                canvas.setAttribute(\n",
       "                    'width',\n",
       "                    entry.devicePixelContentBoxSize[0].inlineSize\n",
       "                );\n",
       "                canvas.setAttribute(\n",
       "                    'height',\n",
       "                    entry.devicePixelContentBoxSize[0].blockSize\n",
       "                );\n",
       "            } else {\n",
       "                canvas.setAttribute('width', width * fig.ratio);\n",
       "                canvas.setAttribute('height', height * fig.ratio);\n",
       "            }\n",
       "            canvas.setAttribute(\n",
       "                'style',\n",
       "                'width: ' + width + 'px; height: ' + height + 'px;'\n",
       "            );\n",
       "\n",
       "            rubberband_canvas.setAttribute('width', width);\n",
       "            rubberband_canvas.setAttribute('height', height);\n",
       "\n",
       "            // And update the size in Python. We ignore the initial 0/0 size\n",
       "            // that occurs as the element is placed into the DOM, which should\n",
       "            // otherwise not happen due to the minimum size styling.\n",
       "            if (width != 0 && height != 0) {\n",
       "                fig.request_resize(width, height);\n",
       "            }\n",
       "        }\n",
       "    });\n",
       "    resizeObserver.observe(canvas_div);\n",
       "\n",
       "    function on_mouse_event_closure(name) {\n",
       "        return function (event) {\n",
       "            return fig.mouse_event(event, name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mousedown',\n",
       "        on_mouse_event_closure('button_press')\n",
       "    );\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mouseup',\n",
       "        on_mouse_event_closure('button_release')\n",
       "    );\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mousemove',\n",
       "        on_mouse_event_closure('motion_notify')\n",
       "    );\n",
       "\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mouseenter',\n",
       "        on_mouse_event_closure('figure_enter')\n",
       "    );\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mouseleave',\n",
       "        on_mouse_event_closure('figure_leave')\n",
       "    );\n",
       "\n",
       "    canvas_div.addEventListener('wheel', function (event) {\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        on_mouse_event_closure('scroll')(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.appendChild(canvas);\n",
       "    canvas_div.appendChild(rubberband_canvas);\n",
       "\n",
       "    this.rubberband_context = rubberband_canvas.getContext('2d');\n",
       "    this.rubberband_context.strokeStyle = '#000000';\n",
       "\n",
       "    this._resize_canvas = function (width, height, forward) {\n",
       "        if (forward) {\n",
       "            canvas_div.style.width = width + 'px';\n",
       "            canvas_div.style.height = height + 'px';\n",
       "        }\n",
       "    };\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n",
       "        event.preventDefault();\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus() {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function () {\n",
       "    var fig = this;\n",
       "\n",
       "    var toolbar = document.createElement('div');\n",
       "    toolbar.classList = 'mpl-toolbar';\n",
       "    this.root.appendChild(toolbar);\n",
       "\n",
       "    function on_click_closure(name) {\n",
       "        return function (_event) {\n",
       "            return fig.toolbar_button_onclick(name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    function on_mouseover_closure(tooltip) {\n",
       "        return function (event) {\n",
       "            if (!event.currentTarget.disabled) {\n",
       "                return fig.toolbar_button_onmouseover(tooltip);\n",
       "            }\n",
       "        };\n",
       "    }\n",
       "\n",
       "    fig.buttons = {};\n",
       "    var buttonGroup = document.createElement('div');\n",
       "    buttonGroup.classList = 'mpl-button-group';\n",
       "    for (var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            /* Instead of a spacer, we start a new button group. */\n",
       "            if (buttonGroup.hasChildNodes()) {\n",
       "                toolbar.appendChild(buttonGroup);\n",
       "            }\n",
       "            buttonGroup = document.createElement('div');\n",
       "            buttonGroup.classList = 'mpl-button-group';\n",
       "            continue;\n",
       "        }\n",
       "\n",
       "        var button = (fig.buttons[name] = document.createElement('button'));\n",
       "        button.classList = 'mpl-widget';\n",
       "        button.setAttribute('role', 'button');\n",
       "        button.setAttribute('aria-disabled', 'false');\n",
       "        button.addEventListener('click', on_click_closure(method_name));\n",
       "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
       "\n",
       "        var icon_img = document.createElement('img');\n",
       "        icon_img.src = '_images/' + image + '.png';\n",
       "        icon_img.srcset = '_images/' + image + '_large.png 2x';\n",
       "        icon_img.alt = tooltip;\n",
       "        button.appendChild(icon_img);\n",
       "\n",
       "        buttonGroup.appendChild(button);\n",
       "    }\n",
       "\n",
       "    if (buttonGroup.hasChildNodes()) {\n",
       "        toolbar.appendChild(buttonGroup);\n",
       "    }\n",
       "\n",
       "    var fmt_picker = document.createElement('select');\n",
       "    fmt_picker.classList = 'mpl-widget';\n",
       "    toolbar.appendChild(fmt_picker);\n",
       "    this.format_dropdown = fmt_picker;\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = document.createElement('option');\n",
       "        option.selected = fmt === mpl.default_extension;\n",
       "        option.innerHTML = fmt;\n",
       "        fmt_picker.appendChild(option);\n",
       "    }\n",
       "\n",
       "    var status_bar = document.createElement('span');\n",
       "    status_bar.classList = 'mpl-message';\n",
       "    toolbar.appendChild(status_bar);\n",
       "    this.message = status_bar;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', { width: x_pixels, height: y_pixels });\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.send_message = function (type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function () {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_save = function (fig, _msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function (fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1], msg['forward']);\n",
       "        fig.send_message('refresh', {});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n",
       "    var x0 = msg['x0'] / fig.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n",
       "    var x1 = msg['x1'] / fig.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0,\n",
       "        0,\n",
       "        fig.canvas.width / fig.ratio,\n",
       "        fig.canvas.height / fig.ratio\n",
       "    );\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch (cursor) {\n",
       "        case 0:\n",
       "            cursor = 'pointer';\n",
       "            break;\n",
       "        case 1:\n",
       "            cursor = 'default';\n",
       "            break;\n",
       "        case 2:\n",
       "            cursor = 'crosshair';\n",
       "            break;\n",
       "        case 3:\n",
       "            cursor = 'move';\n",
       "            break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_message = function (fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n",
       "    for (var key in msg) {\n",
       "        if (!(key in fig.buttons)) {\n",
       "            continue;\n",
       "        }\n",
       "        fig.buttons[key].disabled = !msg[key];\n",
       "        fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n",
       "    if (msg['mode'] === 'PAN') {\n",
       "        fig.buttons['Pan'].classList.add('active');\n",
       "        fig.buttons['Zoom'].classList.remove('active');\n",
       "    } else if (msg['mode'] === 'ZOOM') {\n",
       "        fig.buttons['Pan'].classList.remove('active');\n",
       "        fig.buttons['Zoom'].classList.add('active');\n",
       "    } else {\n",
       "        fig.buttons['Pan'].classList.remove('active');\n",
       "        fig.buttons['Zoom'].classList.remove('active');\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function () {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message('ack', {});\n",
       "};\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function (fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = 'image/png';\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src\n",
       "                );\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data\n",
       "            );\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        } else if (\n",
       "            typeof evt.data === 'string' &&\n",
       "            evt.data.slice(0, 21) === 'data:image/png;base64'\n",
       "        ) {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig['handle_' + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\n",
       "                \"No handler for the '\" + msg_type + \"' message type: \",\n",
       "                msg\n",
       "            );\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\n",
       "                    \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n",
       "                    e,\n",
       "                    e.stack,\n",
       "                    msg\n",
       "                );\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "};\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function (e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e) {\n",
       "        e = window.event;\n",
       "    }\n",
       "    if (e.target) {\n",
       "        targ = e.target;\n",
       "    } else if (e.srcElement) {\n",
       "        targ = e.srcElement;\n",
       "    }\n",
       "    if (targ.nodeType === 3) {\n",
       "        // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "    }\n",
       "\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    var boundingRect = targ.getBoundingClientRect();\n",
       "    var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n",
       "    var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n",
       "\n",
       "    return { x: x, y: y };\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys(original) {\n",
       "    return Object.keys(original).reduce(function (obj, key) {\n",
       "        if (typeof original[key] !== 'object') {\n",
       "            obj[key] = original[key];\n",
       "        }\n",
       "        return obj;\n",
       "    }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function (event, name) {\n",
       "    var canvas_pos = mpl.findpos(event);\n",
       "\n",
       "    if (name === 'button_press') {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * this.ratio;\n",
       "    var y = canvas_pos.y * this.ratio;\n",
       "\n",
       "    this.send_message(name, {\n",
       "        x: x,\n",
       "        y: y,\n",
       "        button: event.button,\n",
       "        step: event.step,\n",
       "        guiEvent: simpleKeys(event),\n",
       "    });\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.key_event = function (event, name) {\n",
       "    // Prevent repeat events\n",
       "    if (name === 'key_press') {\n",
       "        if (event.which === this._key) {\n",
       "            return;\n",
       "        } else {\n",
       "            this._key = event.which;\n",
       "        }\n",
       "    }\n",
       "    if (name === 'key_release') {\n",
       "        this._key = null;\n",
       "    }\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which !== 17) {\n",
       "        value += 'ctrl+';\n",
       "    }\n",
       "    if (event.altKey && event.which !== 18) {\n",
       "        value += 'alt+';\n",
       "    }\n",
       "    if (event.shiftKey && event.which !== 16) {\n",
       "        value += 'shift+';\n",
       "    }\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n",
       "    return false;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n",
       "    if (name === 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message('toolbar_button', { name: name });\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";/* global mpl */\n",
       "\n",
       "var comm_websocket_adapter = function (comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function () {\n",
       "        comm.close();\n",
       "    };\n",
       "    ws.send = function (m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function (msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data']);\n",
       "    });\n",
       "    return ws;\n",
       "};\n",
       "\n",
       "mpl.mpl_figure_comm = function (comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = document.getElementById(id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm);\n",
       "\n",
       "    function ondownload(figure, _format) {\n",
       "        window.open(figure.canvas.toDataURL());\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element;\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error('Failed to find cell for figure', id, fig);\n",
       "        return;\n",
       "    }\n",
       "    fig.cell_info[0].output_area.element.one(\n",
       "        'cleared',\n",
       "        { fig: fig },\n",
       "        fig._remove_fig_handler\n",
       "    );\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function (fig, msg) {\n",
       "    var width = fig.canvas.width / fig.ratio;\n",
       "    fig.cell_info[0].output_area.element.off(\n",
       "        'cleared',\n",
       "        fig._remove_fig_handler\n",
       "    );\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable();\n",
       "    fig.parent_element.innerHTML =\n",
       "        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "    fig.close_ws(fig, msg);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.close_ws = function (fig, msg) {\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width / this.ratio;\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] =\n",
       "        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function () {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message('ack', {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () {\n",
       "        fig.push_to_output();\n",
       "    }, 1000);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function () {\n",
       "    var fig = this;\n",
       "\n",
       "    var toolbar = document.createElement('div');\n",
       "    toolbar.classList = 'btn-toolbar';\n",
       "    this.root.appendChild(toolbar);\n",
       "\n",
       "    function on_click_closure(name) {\n",
       "        return function (_event) {\n",
       "            return fig.toolbar_button_onclick(name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    function on_mouseover_closure(tooltip) {\n",
       "        return function (event) {\n",
       "            if (!event.currentTarget.disabled) {\n",
       "                return fig.toolbar_button_onmouseover(tooltip);\n",
       "            }\n",
       "        };\n",
       "    }\n",
       "\n",
       "    fig.buttons = {};\n",
       "    var buttonGroup = document.createElement('div');\n",
       "    buttonGroup.classList = 'btn-group';\n",
       "    var button;\n",
       "    for (var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            /* Instead of a spacer, we start a new button group. */\n",
       "            if (buttonGroup.hasChildNodes()) {\n",
       "                toolbar.appendChild(buttonGroup);\n",
       "            }\n",
       "            buttonGroup = document.createElement('div');\n",
       "            buttonGroup.classList = 'btn-group';\n",
       "            continue;\n",
       "        }\n",
       "\n",
       "        button = fig.buttons[name] = document.createElement('button');\n",
       "        button.classList = 'btn btn-default';\n",
       "        button.href = '#';\n",
       "        button.title = name;\n",
       "        button.innerHTML = '<i class=\"fa ' + image + ' fa-lg\"></i>';\n",
       "        button.addEventListener('click', on_click_closure(method_name));\n",
       "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
       "        buttonGroup.appendChild(button);\n",
       "    }\n",
       "\n",
       "    if (buttonGroup.hasChildNodes()) {\n",
       "        toolbar.appendChild(buttonGroup);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = document.createElement('span');\n",
       "    status_bar.classList = 'mpl-message pull-right';\n",
       "    toolbar.appendChild(status_bar);\n",
       "    this.message = status_bar;\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = document.createElement('div');\n",
       "    buttongrp.classList = 'btn-group inline pull-right';\n",
       "    button = document.createElement('button');\n",
       "    button.classList = 'btn btn-mini btn-primary';\n",
       "    button.href = '#';\n",
       "    button.title = 'Stop Interaction';\n",
       "    button.innerHTML = '<i class=\"fa fa-power-off icon-remove icon-large\"></i>';\n",
       "    button.addEventListener('click', function (_evt) {\n",
       "        fig.handle_close(fig, {});\n",
       "    });\n",
       "    button.addEventListener(\n",
       "        'mouseover',\n",
       "        on_mouseover_closure('Stop Interaction')\n",
       "    );\n",
       "    buttongrp.appendChild(button);\n",
       "    var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n",
       "    titlebar.insertBefore(buttongrp, titlebar.firstChild);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._remove_fig_handler = function (event) {\n",
       "    var fig = event.data.fig;\n",
       "    fig.close_ws(fig, {});\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function (el) {\n",
       "    el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function (el) {\n",
       "    // this is important to make the div 'focusable\n",
       "    el.setAttribute('tabindex', 0);\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    } else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function (event, _name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager) {\n",
       "        manager = IPython.keyboard_manager;\n",
       "    }\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which === 13) {\n",
       "        this.canvas_div.blur();\n",
       "        // select the cell after this one\n",
       "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
       "        IPython.notebook.select(index + 1);\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_save = function (fig, _msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "};\n",
       "\n",
       "mpl.find_output_cell = function (html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i = 0; i < ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code') {\n",
       "            for (var j = 0; j < cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] === html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "};\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel !== null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target(\n",
       "        'matplotlib',\n",
       "        mpl.mpl_figure_comm\n",
       "    );\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:,\" width=\"0\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Selected strategy')"
      ]
     },
     "execution_count": 299,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(8,5))\n",
    "plt.xlabel('Steps',fontsize=10)\n",
    "plt.title('Convergence of Strategy selection by Thompson Sampling',fontsize=10)\n",
    "plt.ylabel('Selected strategy',fontsize=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 300,
   "metadata": {},
   "outputs": [],
   "source": [
    "ani = matplotlib.animation.FuncAnimation(fig, plot_scatter, frames=100, repeat=True)\n",
    "#plt.show()\n",
    "ani.save('thompsonsampling.mp4', writer=writer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Regret curves"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 306,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "plt.plot(regret_curve_random, label='Random strategy')\n",
    "plt.plot(regret_curve_thompson, label='Thompson Sampling')\n",
    "plt.title('Regret Curves')\n",
    "plt.legend(loc='upper left')\n",
    "plt.xlabel('steps')\n",
    "plt.ylabel('gap with best strategy at each step')\n",
    "plt.savefig('random.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Thompson Sampling is converging very well towards the best strategy\n",
    "- No convergence of the Random Strategy towards the Best Strategy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 305,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(range(N), regret_curve_thompson, color='orange')\n",
    "plt.title('Regret Curve Thompson Sampling strategy')\n",
    "plt.xlabel('steps')\n",
    "plt.ylabel('gap with best strategy at each step')\n",
    "plt.savefig('thompson.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tensorflow_py37",
   "language": "python",
   "name": "tensorflow_py37"
  },
  "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}