Support Vector Machines.ipynb

       "                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=\"800\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(8, 8))\n",
    "plt.scatter(data.loc[:, \"x\"], data.loc[:, \"y\"], c=data.loc[:, \"source\"], s=30, cmap=plt.cm.Paired)\n",
    "\n",
    "# plot the decision function\n",
    "ax = plt.gca()\n",
    "xlim = ax.get_xlim()\n",
    "ylim = ax.get_ylim()\n",
    "\n",
    "# create grid to evaluate model\n",
    "xx = np.linspace(xlim[0], xlim[1], 30)\n",
    "yy = np.linspace(ylim[0], ylim[1], 30)\n",
    "YY, XX = np.meshgrid(yy, xx)\n",
    "xy = np.vstack([XX.ravel(), YY.ravel()]).T\n",
    "Z = clf.decision_function(xy).reshape(XX.shape)\n",
    "\n",
    "# plot decision boundary and margins\n",
    "ax.contour(\n",
    "    XX, YY, Z, colors=\"k\", levels=[-1, 0, 1], alpha=0.5, linestyles=[\"--\", \"-\", \"--\"]\n",
    ")\n",
    "# plot support vectors\n",
    "ax.scatter(\n",
    "    clf.support_vectors_[:, 0],\n",
    "    clf.support_vectors_[:, 1],\n",
    "    s=100,\n",
    "    linewidth=1,\n",
    "    facecolors=\"none\",\n",
    "    edgecolors=\"k\",\n",
    ")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ee97208",
   "metadata": {},
   "source": [
    "Try the same using another kernel to see how the decision boundary changes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "d98ececa",
   "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",
       "                );\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",