Supervised classification.ipynb

       "    });\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=\"1000\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(nrows=5, ncols=5, figsize=(10,10))\n",
    "for i in range(5):\n",
    "    for j in range(5):\n",
    "        idx = i*5+j\n",
    "        img = my_dataset[idx][0]\n",
    "        label = my_dataset[idx][1]\n",
    "        ax[i, j].imshow(img[0,...].detach().cpu().numpy())\n",
    "        ax[i, j].set(title=f\"Im. {idx}, true {label}\")\n",
    "        ax[i, j].set_xticklabels([])\n",
    "        ax[i, j].set_yticklabels([])\n",
    "plt.subplots_adjust(hspace=0.2,wspace=0)\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": 8,
   "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 conv1, conv2, fc1 and fc2 objects.\n",
    "        The forward function receives an image and outputs a vector.\n",
    "        \n",
    "        The intuition is that the i-th component of the vector represents the probability that\n",
    "        the probability that the image belongs to the i-th class however\n",
    "        we do not normalize the output to be in the range [0,1] and to sum to 1. The reason is\n",
    "        that this normalization is done later, in the training step, where the numerical error in it can be\n",
    "        minimized by calculating directly log(probability) instead of calculating first the probability\n",
    "        and then the log of it. Keep in mind therefore, that to get probabilities\n",
    "        from this object one should do F.softmax(my_network(x), dim=1).\n",
    "        \n",
    "        The code has been written like this, as this is a common optimization done in classification problems.\n",
    "    \"\"\"\n",
    "    def __init__(self):\n",
    "        \"\"\"\n",
    "        Constructor. Here we initialize the weights.\n",
    "        \"\"\"\n",
    "        super().__init__()\n",
    "\n",
    "        # define parameters\n",
    "        \n",
    "        # all these steps are purely linear (affine if one considers the bias)\n",
    "        # the forward function adds a non-linearity through the ReLU to allow this to do more than\n",
    "        # simple linear filters\n",
    "        \n",
    "        self.conv1 = nn.Conv2d(in_channels=1, out_channels=6, kernel_size=5)\n",
    "        self.conv2 = nn.Conv2d(in_channels=6, out_channels=12, kernel_size=5)\n",
    "\n",
    "        self.fc1 = nn.Linear(in_features=12*4*4, out_features=120)\n",
    "        self.fc2 = nn.Linear(in_features=120, out_features=60)\n",
    "        self.out = nn.Linear(in_features=60, out_features=10)\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 image, outputting the probabilities for that image as\n",
    "        a column vector. The input x has shape (B, C, H, W) (ie: batch dimension, channels, height and width).\n",
    "        The output has shape (B, K), where K is the number of classes.\n",
    "        Each row of the output has the probability for each class as a column vector.\n",
    "        Each column of the output has the probability for a single class for all images B given as an input.\n",
    "        \"\"\"\n",
    "\n",
    "        # first convolution\n",
    "        t = self.conv1(x)\n",
    "        # non-linearity\n",
    "        t = F.relu(t)\n",
    "        # reduce size of the image in width and height by taking the maximum\n",
    "        # pixel value in each 2x2 pixel matrix (kernel_size) and skipping one pixel (stride)\n",
    "        # the convolution receives one channel and outputs more\n",
    "        # the goal of the max_pool layer is to reduce the image size, so we\n",
    "        # can get more images in several channels which are smaller in size\n",
    "        # this is a trade off between memory and compute\n",
    "        t = F.max_pool2d(t, kernel_size=2, stride=2)\n",
    "\n",
    "        # second convolution\n",
    "        t = self.conv2(t)\n",
    "        # non-linearity\n",
    "        t = F.relu(t)\n",
    "        # reduce the size of the image in width and height again\n",
    "        t = F.max_pool2d(t, kernel_size=2, stride=2)\n",
    "\n",
    "        # transform images into a single vector using reshape\n",
    "        # this puts all pixel values in a single vector\n",
    "        t = t.reshape(-1, 12*4*4)\n",
    "        \n",
    "        # apply a linear transformation\n",
    "        t = self.fc1(t)\n",
    "        # add a non-linearity\n",
    "        t = F.relu(t)\n",
    "\n",
    "        # another linear transformation\n",
    "        t = self.fc2(t)\n",
    "        # another non-linearity\n",
    "        t = F.relu(t)\n",
    "\n",
    "        # final linear transformation\n",
    "        # the output of this has been set to 10 features, so the output will have the size\n",
    "        # (B, 10)\n",
    "        t = self.out(t)\n",
    "\n",
    "        # note: while we want the function to output a probability,\n",
    "        # we do not actually do any effort to normalize these numbers so that they are in [0, 1]\n",
    "        # and so that their sum is 1\n",
    "        # this would often be done by applying a transformation called Softmax(t) = exp(t)/sum(exp(t))\n",
    "        # however, this will be done internally by PyTorch in the function F.cross_entropy\n",
    "        # which we will call later on when training\n",
    "\n",
    "        return t"
   ]
  },
  {
   "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": 9,
   "id": "988e1979",
   "metadata": {},
   "outputs": [],
   "source": [
    "network = Network()\n",
    "B = 64\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": 10,
   "id": "d15d655d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 0/10: average loss 0.35421\n",
      "Epoch 1/10: average loss 0.10931\n",
      "Epoch 2/10: average loss 0.07470\n",
      "Epoch 3/10: average loss 0.05767\n",
      "Epoch 4/10: average loss 0.04682\n",
      "Epoch 5/10: average loss 0.03882\n",
      "Epoch 6/10: average loss 0.03285\n",
      "Epoch 7/10: average loss 0.02714\n",
      "Epoch 8/10: average loss 0.02437\n",
      "Epoch 9/10: average loss 0.02176\n"
     ]
    }
   ],
   "source": [
    "epochs = 10\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 images in the mini-batch\n",
    "        # this has size (B, C, H, W)\n",
    "        # where B is the mini-batch size\n",
    "        # C is the number of channels in the image (1 for grayscale)\n",
    "        # H is the height of the image\n",
    "        # W is the width of the image\n",
    "        images = batch[0]\n",
    "        # get the labels in the mini-batch (there shall be B of them)\n",
    "        labels = batch[1]\n",
    "        # get the output of the neural network:\n",
    "        logits = network(images)\n",
    "        \n",
    "        # note: the network does not output probabilities directly: it outputs logits\n",
    "        # to get probabilities from it we would need to do F.softmax(logits, dim=1)\n",
    "        # however, this is done inside F.cross_entropy below and we therefore should\n",
    "        # not do it twice here\n",
    "        # the reason it is done internally, in F.cross_entropy, is that what we really\n",
    "        # need is log(probability) and we can reduce the numerical error\n",
    "        # in its calculation by calculating log(softmax(.)) in one go\n",
    "        # (remember softmax(x) = exp(x)/sum(exp(x)), so log(softmax(x)) = x - log(sum(exp(x))))\n",
    "        \n",
    "        # calculate the loss function being minimized\n",
    "        # in this case, it is the cross-entropy between the logits and the true labels\n",
    "        loss = F.cross_entropy(logits, labels)\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 (note that we set `train` to `False`, to take a statistically independent part of the dataset)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "09646d29",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_dataset = torchvision.datasets.MNIST(\n",
    "    root = './data/MNIST',\n",
    "    train = False,\n",
    "    download = True,\n",
    "    transform = transforms.Compose([\n",
    "        transforms.ToTensor()                                 \n",
    "    ])\n",
    ")"
   ]
  },
  {
   "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": 12,
   "id": "7a06a4c0",
   "metadata": {
    "scrolled": false
   },
   "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",