Support Vector Machines.ipynb

       "        ) {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig['handle_' + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\n",
       "                \"No handler for the '\" + msg_type + \"' message type: \",\n",
       "                msg\n",
       "            );\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\n",
       "                    \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n",
       "                    e,\n",
       "                    e.stack,\n",
       "                    msg\n",
       "                );\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "};\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function (e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e) {\n",
       "        e = window.event;\n",
       "    }\n",
       "    if (e.target) {\n",
       "        targ = e.target;\n",
       "    } else if (e.srcElement) {\n",
       "        targ = e.srcElement;\n",
       "    }\n",
       "    if (targ.nodeType === 3) {\n",
       "        // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "    }\n",
       "\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    var boundingRect = targ.getBoundingClientRect();\n",
       "    var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n",
       "    var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n",
       "\n",
       "    return { x: x, y: y };\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys(original) {\n",
       "    return Object.keys(original).reduce(function (obj, key) {\n",
       "        if (typeof original[key] !== 'object') {\n",
       "            obj[key] = original[key];\n",
       "        }\n",
       "        return obj;\n",
       "    }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function (event, name) {\n",
       "    var canvas_pos = mpl.findpos(event);\n",
       "\n",
       "    if (name === 'button_press') {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * this.ratio;\n",
       "    var y = canvas_pos.y * this.ratio;\n",
       "\n",
       "    this.send_message(name, {\n",
       "        x: x,\n",
       "        y: y,\n",
       "        button: event.button,\n",
       "        step: event.step,\n",
       "        guiEvent: simpleKeys(event),\n",
       "    });\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.key_event = function (event, name) {\n",
       "    // Prevent repeat events\n",
       "    if (name === 'key_press') {\n",
       "        if (event.which === this._key) {\n",
       "            return;\n",
       "        } else {\n",
       "            this._key = event.which;\n",
       "        }\n",
       "    }\n",
       "    if (name === 'key_release') {\n",
       "        this._key = null;\n",
       "    }\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which !== 17) {\n",
       "        value += 'ctrl+';\n",
       "    }\n",
       "    if (event.altKey && event.which !== 18) {\n",
       "        value += 'alt+';\n",
       "    }\n",
       "    if (event.shiftKey && event.which !== 16) {\n",
       "        value += 'shift+';\n",
       "    }\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n",
       "    return false;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n",
       "    if (name === 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message('toolbar_button', { name: name });\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "\n",
       "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n",
       "// prettier-ignore\n",
       "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";/* global mpl */\n",
       "\n",
       "var comm_websocket_adapter = function (comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function () {\n",
       "        comm.close();\n",
       "    };\n",
       "    ws.send = function (m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function (msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data']);\n",
       "    });\n",
       "    return ws;\n",
       "};\n",
       "\n",
       "mpl.mpl_figure_comm = function (comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = document.getElementById(id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm);\n",
       "\n",
       "    function ondownload(figure, _format) {\n",
       "        window.open(figure.canvas.toDataURL());\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element;\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error('Failed to find cell for figure', id, fig);\n",
       "        return;\n",
       "    }\n",
       "    fig.cell_info[0].output_area.element.on(\n",
       "        'cleared',\n",
       "        { fig: fig },\n",
       "        fig._remove_fig_handler\n",
       "    );\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function (fig, msg) {\n",
       "    var width = fig.canvas.width / fig.ratio;\n",
       "    fig.cell_info[0].output_area.element.off(\n",
       "        'cleared',\n",
       "        fig._remove_fig_handler\n",
       "    );\n",
       "    fig.resizeObserverInstance.unobserve(fig.canvas_div);\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable();\n",
       "    fig.parent_element.innerHTML =\n",
       "        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "    fig.close_ws(fig, msg);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.close_ws = function (fig, msg) {\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width / this.ratio;\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] =\n",
       "        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function () {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message('ack', {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () {\n",
       "        fig.push_to_output();\n",
       "    }, 1000);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function () {\n",
       "    var fig = this;\n",
       "\n",
       "    var toolbar = document.createElement('div');\n",
       "    toolbar.classList = 'btn-toolbar';\n",
       "    this.root.appendChild(toolbar);\n",
       "\n",
       "    function on_click_closure(name) {\n",
       "        return function (_event) {\n",
       "            return fig.toolbar_button_onclick(name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    function on_mouseover_closure(tooltip) {\n",
       "        return function (event) {\n",
       "            if (!event.currentTarget.disabled) {\n",
       "                return fig.toolbar_button_onmouseover(tooltip);\n",
       "            }\n",
       "        };\n",
       "    }\n",
       "\n",
       "    fig.buttons = {};\n",
       "    var buttonGroup = document.createElement('div');\n",
       "    buttonGroup.classList = 'btn-group';\n",
       "    var button;\n",
       "    for (var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            /* Instead of a spacer, we start a new button group. */\n",
       "            if (buttonGroup.hasChildNodes()) {\n",
       "                toolbar.appendChild(buttonGroup);\n",
       "            }\n",
       "            buttonGroup = document.createElement('div');\n",
       "            buttonGroup.classList = 'btn-group';\n",
       "            continue;\n",
       "        }\n",
       "\n",
       "        button = fig.buttons[name] = document.createElement('button');\n",
       "        button.classList = 'btn btn-default';\n",
       "        button.href = '#';\n",
       "        button.title = name;\n",
       "        button.innerHTML = '<i class=\"fa ' + image + ' fa-lg\"></i>';\n",
       "        button.addEventListener('click', on_click_closure(method_name));\n",
       "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
       "        buttonGroup.appendChild(button);\n",
       "    }\n",
       "\n",
       "    if (buttonGroup.hasChildNodes()) {\n",
       "        toolbar.appendChild(buttonGroup);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = document.createElement('span');\n",
       "    status_bar.classList = 'mpl-message pull-right';\n",
       "    toolbar.appendChild(status_bar);\n",
       "    this.message = status_bar;\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = document.createElement('div');\n",
       "    buttongrp.classList = 'btn-group inline pull-right';\n",
       "    button = document.createElement('button');\n",
       "    button.classList = 'btn btn-mini btn-primary';\n",
       "    button.href = '#';\n",
       "    button.title = 'Stop Interaction';\n",
       "    button.innerHTML = '<i class=\"fa fa-power-off icon-remove icon-large\"></i>';\n",
       "    button.addEventListener('click', function (_evt) {\n",
       "        fig.handle_close(fig, {});\n",
       "    });\n",
       "    button.addEventListener(\n",
       "        'mouseover',\n",
       "        on_mouseover_closure('Stop Interaction')\n",
       "    );\n",
       "    buttongrp.appendChild(button);\n",
       "    var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n",
       "    titlebar.insertBefore(buttongrp, titlebar.firstChild);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._remove_fig_handler = function (event) {\n",
       "    var fig = event.data.fig;\n",
       "    if (event.target !== this) {\n",
       "        // Ignore bubbled events from children.\n",
       "        return;\n",
       "    }\n",
       "    fig.close_ws(fig, {});\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function (el) {\n",
       "    el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function (el) {\n",
       "    // this is important to make the div 'focusable\n",
       "    el.setAttribute('tabindex', 0);\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    } else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function (event, _name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager) {\n",
       "        manager = IPython.keyboard_manager;\n",
       "    }\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which === 13) {\n",
       "        this.canvas_div.blur();\n",
       "        // select the cell after this one\n",
       "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
       "        IPython.notebook.select(index + 1);\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_save = function (fig, _msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "};\n",
       "\n",
       "mpl.find_output_cell = function (html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i = 0; i < ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code') {\n",
       "            for (var j = 0; j < cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] === html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "};\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel !== null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target(\n",
       "        'matplotlib',\n",
       "        mpl.mpl_figure_comm\n",
       "    );\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"800\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "clf_kernel = svm.SVC(kernel=\"rbf\")\n",
    "clf_kernel.fit(data.loc[:, [\"x\", \"y\"]], data.loc[:, \"source\"])\n",
    "\n",
    "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_kernel.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_kernel.support_vectors_[:, 0],\n",
    "    clf_kernel.support_vectors_[:, 1],\n",
    "    s=100,\n",
    "    linewidth=1,\n",
    "    facecolors=\"none\",\n",
    "    edgecolors=\"k\",\n",
    ")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df35963b",
   "metadata": {},
   "source": [
    "### Contact us at the EuXFEL Data Analysis group at any time if you need help analysing your data!\n",
    "\n",
    "#### Data Analysis group: da@xfel.eu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "288d8fe2",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}