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.36806\n",
      "Epoch 1/10: average loss 0.11563\n",
      "Epoch 2/10: average loss 0.07839\n",
      "Epoch 3/10: average loss 0.05962\n",
      "Epoch 4/10: average loss 0.04747\n",
      "Epoch 5/10: average loss 0.03930\n",
      "Epoch 6/10: average loss 0.03396\n",
      "Epoch 7/10: average loss 0.02854\n",
      "Epoch 8/10: average loss 0.02372\n",
      "Epoch 9/10: average loss 0.02109\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",