Support Vector Machines.ipynb

       "\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",
    "data.plot.scatter(x=\"x\", y=\"y\", c=\"source\", colormap='viridis', ax=ax)\n",
    "ax.set(xlabel=\"x\", ylabel=r\"y\", title=\"\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a376636d",
   "metadata": {},
   "source": [
    "The usage of the scikit-learn interface is very standard, and one does not even need to know the details of how the SVM algorithm operates. It is however important to understand the basics, to understand how it operates.\n",
    "\n",
    "The kernel choice is effectively changing the choice for $\\phi(x)$ in the explanation above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "0837b3ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "clf = svm.SVC(kernel=\"linear\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "8798f857",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SVC(kernel='linear')"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clf.fit(data.loc[:, [\"x\", \"y\"]], data.loc[:, \"source\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e928f498",
   "metadata": {},
   "source": [
    "Only a few vectors are needed to choose the decision boundary, since only they contribute to the minimum distance shown before. Those vectors are called the support vectors and give the name to the method. They can be accessed using the following attribute:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "fb5796e5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.21182516,  2.31157495],\n",
       "       [-0.94628217,  1.56916731],\n",
       "       [ 0.49511658,  1.79284285],\n",
       "       [ 0.21544199,  2.05959715],\n",
       "       [ 1.79720291, -0.02534731],\n",
       "       [-0.60494068,  1.88752766],\n",
       "       [ 0.90683768,  0.02059853],\n",
       "       [ 1.07219364,  0.61579079],\n",
       "       [ 0.06496264,  2.03481104],\n",
       "       [-0.36832911,  2.56731479],\n",
       "       [ 0.62529817,  1.72061667],\n",
       "       [ 1.91576719, -0.30539225],\n",
       "       [ 0.36531725,  1.09930045],\n",
       "       [ 0.5836424 ,  1.70300831],\n",
       "       [ 0.01782901,  2.24397973],\n",
       "       [ 1.0717598 , -1.77776273],\n",
       "       [ 0.97767405,  1.23465754],\n",
       "       [ 1.53599348, -0.24527776],\n",
       "       [ 0.3795789 ,  2.02205061],\n",
       "       [ 0.20979651,  2.44648459],\n",
       "       [ 1.0745818 ,  0.35635631],\n",
       "       [ 0.6072389 ,  0.50239065],\n",
       "       [ 1.35881189,  0.69592607],\n",
       "       [-1.20621041,  1.34001722],\n",
       "       [ 0.51173674,  1.40430944],\n",
       "       [ 1.68761639, -0.22626755],\n",
       "       [ 0.427487  ,  1.49996763],\n",
       "       [ 1.03826759,  1.15746819],\n",
       "       [-1.22061729,  1.57485782],\n",
       "       [ 0.59552368,  1.84623625],\n",
       "       [ 0.34745253,  2.19606159],\n",
       "       [-0.25460654,  2.15938193],\n",
       "       [-0.28879334,  2.06559377],\n",
       "       [ 2.64768263, -1.23067633],\n",
       "       [ 1.00168985,  0.6942571 ],\n",
       "       [ 2.16417477, -0.53171722],\n",
       "       [ 0.23770248,  2.17975404],\n",
       "       [ 1.19030762,  0.88976073],\n",
       "       [ 0.08497428,  2.22516187],\n",
       "       [ 1.82315891, -0.82428639],\n",
       "       [ 2.03503212, -0.43966318],\n",
       "       [ 0.36332659,  0.94111582],\n",
       "       [ 0.46560162,  1.3333945 ],\n",
       "       [ 0.24424759,  1.11998107],\n",
       "       [ 0.62730317,  0.87509377],\n",
       "       [ 0.32563058,  0.96268418],\n",
       "       [ 0.43924068,  0.77533282],\n",
       "       [ 1.82455499,  1.13993573],\n",
       "       [ 1.00547526,  0.9470825 ],\n",
       "       [ 0.29246745,  1.03105307],\n",
       "       [ 0.03587892,  1.42900693],\n",
       "       [ 1.38439305,  0.81947032],\n",
       "       [ 0.45601145,  1.07196656],\n",
       "       [ 0.30638323,  0.97711115],\n",
       "       [ 0.45891117,  0.94668418],\n",
       "       [ 0.65236911,  0.86988703],\n",
       "       [ 0.80072879,  0.79872165],\n",
       "       [ 0.56238229,  0.86470356],\n",
       "       [ 0.41837498,  0.97397978],\n",
       "       [ 0.75785897,  1.54233478],\n",
       "       [ 0.61539624,  0.94130748],\n",
       "       [-0.11102726,  1.71542169],\n",
       "       [ 0.812513  ,  0.776661  ],\n",
       "       [ 0.47913657,  1.14766801],\n",
       "       [ 0.60026463,  1.21218269],\n",
       "       [ 0.23554457,  1.21968403],\n",
       "       [ 0.07110031,  1.39395848],\n",
       "       [ 0.60623974,  0.60046301],\n",
       "       [ 0.28530764,  1.22130965],\n",
       "       [ 0.40255384,  1.01645976],\n",
       "       [ 0.72794211,  1.44631683],\n",
       "       [ 0.74914917,  0.90509902],\n",
       "       [ 0.55048689,  0.80809041],\n",
       "       [ 0.33953792,  1.01802976],\n",
       "       [ 0.86791963,  1.10610129],\n",
       "       [ 0.43545804,  0.94008493],\n",
       "       [ 0.37769854,  1.06156196],\n",
       "       [ 0.26890853,  1.09087437],\n",
       "       [ 0.47686887,  0.7498173 ],\n",
       "       [ 0.45791321,  1.14821281],\n",
       "       [ 0.42977444,  1.1675954 ],\n",
       "       [ 0.92787593,  1.35712678],\n",
       "       [ 1.13271067,  0.84080793],\n",
       "       [ 0.6319547 ,  1.20117136],\n",
       "       [ 0.74754794,  0.89002571]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clf.support_vectors_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b54001fc",
   "metadata": {},
   "source": [
    "We can now predict to which class a new data point belongs to using `clf.predict(new_data_samples)`. It is however interesting to visualize the decision boundary itself.\n",
    "\n",
    "(Taken from https://scikit-learn.org/stable/auto_examples/svm/plot_separating_hyperplane.html#sphx-glr-auto-examples-svm-plot-separating-hyperplane-py -- take a look there for more resources and more examples)\n",
    "\n",
    "The code below also highlights the support vectors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "cc8fc1f1",
   "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",
       "        ) {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig['handle_' + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\n",
       "                \"No handler for the '\" + msg_type + \"' message type: \",\n",