Support Vector Machines.ipynb

       "            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=\"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",