Mixture Models.ipynb

       "                    \"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\", 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\")\n",
    "ax[1].set(xlabel=\"x\", ylabel=r\"y\", title=\"True association\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b1363ec",
   "metadata": {},
   "source": [
    "Note that if the sample clusters were not \"blobs\" of data, but were in concentric circles, the assumption of this method would be false and the method would simply not work well. This is why it is important to understand the underlying assumptions made in the method."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7076f779",
   "metadata": {},
   "source": [
    "## K-Means\n",
    "\n",
    "Another common method used for clustering is the K-Means, on which one simply tries to find the cluster centers which minimize in-cluster distances (in an Euclidean sense) while maximizing distances between the centers. It can be shown that this method is a special case of the Gaussian Mixture Model when the covariance matrices are diagonal, which would mean that within each blob, there is no correlation between the variables (see https://en.wikipedia.org/wiki/K-means_clustering#Gaussian_mixture_model and references).\n",
    "\n",
    "While this is an approximation of the GMM model, it is still a very useful approach, since there are faster algorithms to achieve the clustering than for GMMs.\n",
    "\n",
    "The scikit-learn module also provides an easy-to-use implementation of this algorithm:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "2f280e1d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "KMeans(n_clusters=3)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kmeans = KMeans(n_clusters=3)\n",
    "kmeans.fit(data.loc[:, [\"x\", \"y\"]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "950a7eec",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.loc[:, \"guess_kmeans\"] = kmeans.predict(data.loc[:, [\"x\", \"y\"]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "16a56489",
   "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",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function (fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = 'image/png';\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src\n",