Supervised regression.ipynb

       "    // 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=\"640\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "ax.scatter(train_data[:, 0], train_data[:, 1])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e517975c",
   "metadata": {},
   "source": [
    "And now let us define the neural network. In PyTorch, neural networks always extend `nn.Module`. They define their sub-parts in their constructor, which are convolutional layers and fully connected linear layers in this case, and the method `forward` is expected to receive an input image and output the network target.\n",
    "\n",
    "The network parameters are the weights of the `Conv2d` and `Linear` layers, which are conveniently hidden here, but can be accessed if you try to access their `weights` elements.\n",
    "\n",
    "We will not directly output the label probabilities, since we do not actually need it to optimize the neural network: we need only the logits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d908ef86",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Network(nn.Module):\n",
    "    \"\"\"\n",
    "        This is our parametrized function.\n",
    "        It stores all the parametrized weights theta inside the model object.\n",
    "        For such a simple example data, it was not necessary to have such a complex model:\n",
    "        this was only done here to show the interface provided by PyTorch.\n",
    "        The forward function receives the x values and outputs an estimate of the target.\n",
    "        \n",
    "        The nn.Sequential object allows one to apply each step in the given list of parameter\n",
    "        in a sequential way. An alternative would be to create each of these layers manually\n",
    "        and apply them one after the other in the forward method.\n",
    "    \"\"\"\n",
    "    def __init__(self, input_dimension: int=1, output_dimension: int=1):\n",
    "        \"\"\"\n",
    "        Constructor. Here we initialize the weights.\n",
    "        \"\"\"\n",
    "        super().__init__()\n",
    "\n",
    "        hidden_layer = 100\n",
    "        self.model = nn.Sequential(\n",
    "                                   nn.Linear(input_dimension, hidden_layer),\n",
    "                                   nn.ReLU(),\n",
    "                                   nn.Linear(hidden_layer, output_dimension)\n",
    "                                    )\n",
    "\n",
    "    def forward(self, x):\n",
    "        \"\"\"\n",
    "        This function is called when one does my_network(x) and it represents the action\n",
    "        of our parametrized function in the input.\n",
    "        \"\"\"\n",
    "        return self.model(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c5620dc",
   "metadata": {},
   "source": [
    "Let us create one instance of this network. We also create an instance of PyTorch's `DataLoader`, which has the task of taking a given number of data elements and outputing it in a single object. This \"mini-batch\" of data is used during training, so that we do not need to load the entire data in memory during the optimization procedure.\n",
    "\n",
    "We also create an instance of the Adam optimizer, which is used to tune the parameters of the network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "988e1979",
   "metadata": {},
   "outputs": [],
   "source": [
    "network = Network()\n",
    "B = 10\n",
    "loader = torch.utils.data.DataLoader(my_dataset, batch_size=B)\n",
    "optimizer = torch.optim.Adam(network.parameters(), lr=1e-3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ee54520",
   "metadata": {},
   "source": [
    "Now we actually repeatedly try to optimize the network parameters. Each time we go through all the data we have, we go through one \"epoch\". For each epoch, we take several \"mini-batches\" of data (given by the `DataLoader` in `loader`) and use it to make one training step."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d15d655d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 0/100: average loss 378.81588\n",
      "Epoch 1/100: average loss 275.14966\n",
      "Epoch 2/100: average loss 209.67680\n",
      "Epoch 3/100: average loss 177.45487\n",
      "Epoch 4/100: average loss 161.36641\n",
      "Epoch 5/100: average loss 151.22071\n",
      "Epoch 6/100: average loss 143.62892\n",
      "Epoch 7/100: average loss 137.58497\n",
      "Epoch 8/100: average loss 132.61164\n",
      "Epoch 9/100: average loss 128.38996\n",
      "Epoch 10/100: average loss 124.72414\n",
      "Epoch 11/100: average loss 121.49631\n",
      "Epoch 12/100: average loss 118.62273\n",
      "Epoch 13/100: average loss 116.04727\n",
      "Epoch 14/100: average loss 113.73365\n",
      "Epoch 15/100: average loss 111.67534\n",
      "Epoch 16/100: average loss 109.85956\n",
      "Epoch 17/100: average loss 108.26555\n",
      "Epoch 18/100: average loss 106.88248\n",
      "Epoch 19/100: average loss 105.69173\n",
      "Epoch 20/100: average loss 104.67635\n",
      "Epoch 21/100: average loss 103.80502\n",
      "Epoch 22/100: average loss 103.06343\n",
      "Epoch 23/100: average loss 102.43223\n",
      "Epoch 24/100: average loss 101.89756\n",
      "Epoch 25/100: average loss 101.43507\n",
      "Epoch 26/100: average loss 101.03641\n",
      "Epoch 27/100: average loss 100.68191\n",
      "Epoch 28/100: average loss 100.35821\n",
      "Epoch 29/100: average loss 100.06578\n",
      "Epoch 30/100: average loss 99.79758\n",
      "Epoch 31/100: average loss 99.54630\n",
      "Epoch 32/100: average loss 99.31432\n",
      "Epoch 33/100: average loss 99.08812\n",
      "Epoch 34/100: average loss 98.87219\n",
      "Epoch 35/100: average loss 98.67368\n",
      "Epoch 36/100: average loss 98.48651\n",
      "Epoch 37/100: average loss 98.31420\n",
      "Epoch 38/100: average loss 98.15310\n",
      "Epoch 39/100: average loss 97.99930\n",
      "Epoch 40/100: average loss 97.85031\n",
      "Epoch 41/100: average loss 97.71002\n",
      "Epoch 42/100: average loss 97.57293\n",
      "Epoch 43/100: average loss 97.44047\n",
      "Epoch 44/100: average loss 97.31417\n",
      "Epoch 45/100: average loss 97.18990\n",
      "Epoch 46/100: average loss 97.07419\n",
      "Epoch 47/100: average loss 96.96548\n",
      "Epoch 48/100: average loss 96.86184\n",
      "Epoch 49/100: average loss 96.76805\n",
      "Epoch 50/100: average loss 96.67791\n",
      "Epoch 51/100: average loss 96.59360\n",
      "Epoch 52/100: average loss 96.51472\n",
      "Epoch 53/100: average loss 96.43937\n",
      "Epoch 54/100: average loss 96.36539\n",
      "Epoch 55/100: average loss 96.29459\n",
      "Epoch 56/100: average loss 96.22356\n",
      "Epoch 57/100: average loss 96.15634\n",
      "Epoch 58/100: average loss 96.08934\n",
      "Epoch 59/100: average loss 96.02401\n",
      "Epoch 60/100: average loss 95.96307\n",
      "Epoch 61/100: average loss 95.90349\n",
      "Epoch 62/100: average loss 95.84973\n",
      "Epoch 63/100: average loss 95.79636\n",
      "Epoch 64/100: average loss 95.74215\n",
      "Epoch 65/100: average loss 95.69529\n",
      "Epoch 66/100: average loss 95.64951\n",
      "Epoch 67/100: average loss 95.60449\n",
      "Epoch 68/100: average loss 95.56373\n",
      "Epoch 69/100: average loss 95.52165\n",
      "Epoch 70/100: average loss 95.48233\n",
      "Epoch 71/100: average loss 95.44179\n",
      "Epoch 72/100: average loss 95.39826\n",
      "Epoch 73/100: average loss 95.35763\n",
      "Epoch 74/100: average loss 95.31944\n",
      "Epoch 75/100: average loss 95.27754\n",
      "Epoch 76/100: average loss 95.23919\n",
      "Epoch 77/100: average loss 95.20086\n",
      "Epoch 78/100: average loss 95.16258\n",
      "Epoch 79/100: average loss 95.12233\n",
      "Epoch 80/100: average loss 95.08201\n",
      "Epoch 81/100: average loss 95.04595\n",
      "Epoch 82/100: average loss 95.01281\n",
      "Epoch 83/100: average loss 94.97996\n",
      "Epoch 84/100: average loss 94.94827\n",
      "Epoch 85/100: average loss 94.91624\n",
      "Epoch 86/100: average loss 94.88639\n",
      "Epoch 87/100: average loss 94.85546\n",
      "Epoch 88/100: average loss 94.82733\n",
      "Epoch 89/100: average loss 94.79647\n",
      "Epoch 90/100: average loss 94.77049\n",
      "Epoch 91/100: average loss 94.74167\n",
      "Epoch 92/100: average loss 94.71930\n",
      "Epoch 93/100: average loss 94.69341\n",
      "Epoch 94/100: average loss 94.66904\n",
      "Epoch 95/100: average loss 94.64581\n",
      "Epoch 96/100: average loss 94.61936\n",
      "Epoch 97/100: average loss 94.59652\n",
      "Epoch 98/100: average loss 94.57301\n",
      "Epoch 99/100: average loss 94.55085\n"
     ]
    }
   ],
   "source": [
    "epochs = 100\n",
    "# for each epoch\n",
    "for epoch in range(epochs):\n",
    "    losses = list()\n",
    "    # for each mini-batch given by the loader:\n",
    "    for batch in loader:\n",
    "        # get the input in the mini-batch\n",
    "        # this has size (B, C)\n",
    "        # where B is the mini-batch size\n",
    "        # C is the number of features (1 in this case)\n",
    "        features = batch[\"data\"]\n",
    "        # get the targets in the mini-batch (there shall be B of them)\n",
    "        target = batch[\"target\"]\n",
    "        # get the output of the neural network:\n",
    "        prediction = network(features)\n",
    "        \n",
    "        # calculate the loss function being minimized\n",
    "        # in this case, it is the mean-squared error between the prediction and the target values\n",
    "        loss = F.mse_loss(prediction, target)\n",
    "        # exactly equivalent to:\n",
    "        #loss = ((prediction - target)**2).mean()\n",
    "\n",
    "        # clean the optimizer temporary gradient storage\n",
    "        optimizer.zero_grad()\n",
    "        # calculate the gradient of the loss function as a function of the gradients\n",
    "        loss.backward()\n",
    "        # ask the Adam optimizer to change the parameters in the direction of - gradient\n",
    "        # Adam scales the gradient by a constant which is adaptively tuned\n",
    "        # take a look at the Adam paper for more details: https://arxiv.org/abs/1412.6980\n",
    "        optimizer.step()\n",
    "        losses.append(loss.detach().cpu().item())\n",
    "    avg_loss = np.mean(np.array(losses))\n",
    "    print(f\"Epoch {epoch}/{epochs}: average loss {avg_loss:.5f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4980bf4",
   "metadata": {},
   "source": [
    "Let us check what the network says about some new data it has never seen before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "09646d29",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_data = generate_data(N=1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e315b5dc",
   "metadata": {},
   "source": [
    "And now we can plot again the new images, now showing what the network tells us about it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "7a06a4c0",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "predicted = network(torch.from_numpy(test_data[:,0:1])).detach().numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "bab0ce43",
   "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",
       "    rubberband_canvas.addEventListener(\n",
       "        'dblclick',\n",
       "        on_mouse_event_closure('dblclick')\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",