Mixture Models.ipynb

       "                );\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",
       "\n",
       "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n",
       "// prettier-ignore\n",
       "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\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.on(\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",
       "    fig.resizeObserverInstance.unobserve(fig.canvas_div);\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",
       "    if (event.target !== this) {\n",
       "        // Ignore bubbled events from children.\n",
       "        return;\n",
       "    }\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:image/png;base64,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\" width=\"1000\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(10, 10), ncols=2)\n",
    "data.plot.scatter(x=\"x\", y=\"y\", c=\"guess_kmeans\", colormap='viridis', ax=ax[0])\n",
    "data.plot.scatter(x=\"x\", y=\"y\", c=\"source\", colormap='viridis', ax=ax[1])\n",
    "ax[0].set(xlabel=\"x\", ylabel=r\"y\", title=\"Guessed source using K-Means\")\n",
    "ax[1].set(xlabel=\"x\", ylabel=r\"y\", title=\"True association\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fe3cad2",
   "metadata": {},
   "source": [
    "## Variational Inference on Gaussian Mixture Models\n",
    "\n",
    "While the Gaussian Mixture Model presented beforehand had a very strong theoretical background, it still assumes that there is a single correct value for the Gaussian parameters. This may not be the case if the Gaussian model is only approximate (as is very often the case!).\n",
    "\n",
    "One improvement to the Gaussian Mixture Models to allow for some uncertainty on the means and covariances would be to assume that also those quantities are random variables which came from some other probability distribution (as with the cluster identification, $z$ previously). In this case, we would obtain an uncertainty for our Gaussian parameters themselves!\n",
    "\n",
    "Optimizing this model becomes even more complicated as the derivation shown before and if we wanted to be fully general, we would need to use very slow algorithms, such as Monte-Carlo sampling to obtain uncertainties with the least amount of extra assumptions. This is often undesirable, since we need fast clustering and often Monte-Carlo sampling is very slow with even more data! An alternative is to assume some underlying prior probability for the means and covariances and find those parameters as well in an optimization algorithm. This is what is done in Variational Inference. Further details can be seen in Bishop (2006), or in a more practical approach, here: https://scikit-learn.org/stable/modules/mixture.html#bgmm\n",
    "\n",
    "We can also easily use this method in our toy data, taking the code from scikit-learn:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "0a8642bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "bgmm = BayesianGaussianMixture(n_components=3)\n",
    "bgmm.fit(data.loc[:, [\"x\", \"y\"]])\n",
    "data.loc[:, \"guess_bgmm\"] = bgmm.predict(data.loc[:, [\"x\", \"y\"]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "ccbf4019",
   "metadata": {},
   "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",
       "\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",
       "    // Apply a ponyfill if ResizeObserver is not implemented by browser.\n",
       "    if (this.ResizeObserver === undefined) {\n",
       "        if (window.ResizeObserver !== undefined) {\n",
       "            this.ResizeObserver = window.ResizeObserver;\n",
       "        } else {\n",
       "            var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n",
       "            this.ResizeObserver = obs.ResizeObserver;\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.resizeObserverInstance = new this.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 (fig.ws.readyState == 1 && width != 0 && height != 0) {\n",
       "                fig.request_resize(width, height);\n",
       "            }\n",
       "        }\n",
       "    });\n",
       "    this.resizeObserverInstance.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",