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 the usaeg of prior knowledge (a prior) on the parameters to be discovered. This helps us, for instance, to determine the ideal number of components automatically, since the number of components itself can be fit with it.\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",