Supervised classification.ipynb

       "    fig.image_mode = msg['mode'];\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n",
       "    for (var key in msg) {\n",
       "        if (!(key in fig.buttons)) {\n",
       "            continue;\n",
       "        }\n",
       "        fig.buttons[key].disabled = !msg[key];\n",
       "        fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n",
       "    if (msg['mode'] === 'PAN') {\n",
       "        fig.buttons['Pan'].classList.add('active');\n",
       "        fig.buttons['Zoom'].classList.remove('active');\n",
       "    } else if (msg['mode'] === 'ZOOM') {\n",
       "        fig.buttons['Pan'].classList.remove('active');\n",
       "        fig.buttons['Zoom'].classList.add('active');\n",
       "    } else {\n",
       "        fig.buttons['Pan'].classList.remove('active');\n",
       "        fig.buttons['Zoom'].classList.remove('active');\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function () {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message('ack', {});\n",
       "};\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function (fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = 'image/png';\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src\n",
       "                );\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data\n",
       "            );\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        } else if (\n",
       "            typeof evt.data === 'string' &&\n",
       "            evt.data.slice(0, 21) === 'data:image/png;base64'\n",
       "        ) {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig['handle_' + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\n",
       "                \"No handler for the '\" + msg_type + \"' message type: \",\n",
       "                msg\n",
       "            );\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\n",
       "                    \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n",
       "                    e,\n",
       "                    e.stack,\n",
       "                    msg\n",
       "                );\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "};\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function (e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e) {\n",
       "        e = window.event;\n",
       "    }\n",
       "    if (e.target) {\n",
       "        targ = e.target;\n",
       "    } else if (e.srcElement) {\n",
       "        targ = e.srcElement;\n",
       "    }\n",
       "    if (targ.nodeType === 3) {\n",
       "        // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "    }\n",
       "\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    var boundingRect = targ.getBoundingClientRect();\n",
       "    var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n",
       "    var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n",
       "\n",
       "    return { x: x, y: y };\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys(original) {\n",
       "    return Object.keys(original).reduce(function (obj, key) {\n",
       "        if (typeof original[key] !== 'object') {\n",
       "            obj[key] = original[key];\n",
       "        }\n",
       "        return obj;\n",
       "    }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function (event, name) {\n",
       "    var canvas_pos = mpl.findpos(event);\n",
       "\n",
       "    if (name === 'button_press') {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * this.ratio;\n",
       "    var y = canvas_pos.y * this.ratio;\n",
       "\n",
       "    this.send_message(name, {\n",
       "        x: x,\n",
       "        y: y,\n",
       "        button: event.button,\n",
       "        step: event.step,\n",
       "        guiEvent: simpleKeys(event),\n",
       "    });\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.key_event = function (event, name) {\n",
       "    // Prevent repeat events\n",
       "    if (name === 'key_press') {\n",
       "        if (event.which === this._key) {\n",
       "            return;\n",
       "        } else {\n",
       "            this._key = event.which;\n",
       "        }\n",
       "    }\n",
       "    if (name === 'key_release') {\n",
       "        this._key = null;\n",
       "    }\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which !== 17) {\n",
       "        value += 'ctrl+';\n",
       "    }\n",
       "    if (event.altKey && event.which !== 18) {\n",
       "        value += 'alt+';\n",
       "    }\n",
       "    if (event.shiftKey && event.which !== 16) {\n",
       "        value += 'shift+';\n",
       "    }\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n",
       "    return false;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n",
       "    if (name === 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message('toolbar_button', { name: name });\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "\n",
       "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n",
       "// prettier-ignore\n",
       "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";/* global mpl */\n",
       "\n",
       "var comm_websocket_adapter = function (comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function () {\n",
       "        comm.close();\n",
       "    };\n",
       "    ws.send = function (m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function (msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data']);\n",
       "    });\n",
       "    return ws;\n",
       "};\n",
       "\n",
       "mpl.mpl_figure_comm = function (comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = document.getElementById(id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm);\n",
       "\n",
       "    function ondownload(figure, _format) {\n",
       "        window.open(figure.canvas.toDataURL());\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element;\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error('Failed to find cell for figure', id, fig);\n",
       "        return;\n",
       "    }\n",
       "    fig.cell_info[0].output_area.element.on(\n",
       "        'cleared',\n",
       "        { fig: fig },\n",
       "        fig._remove_fig_handler\n",
       "    );\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function (fig, msg) {\n",
       "    var width = fig.canvas.width / fig.ratio;\n",
       "    fig.cell_info[0].output_area.element.off(\n",
       "        'cleared',\n",
       "        fig._remove_fig_handler\n",
       "    );\n",
       "    fig.resizeObserverInstance.unobserve(fig.canvas_div);\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable();\n",
       "    fig.parent_element.innerHTML =\n",
       "        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "    fig.close_ws(fig, msg);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.close_ws = function (fig, msg) {\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width / this.ratio;\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] =\n",
       "        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function () {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message('ack', {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () {\n",
       "        fig.push_to_output();\n",
       "    }, 1000);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function () {\n",
       "    var fig = this;\n",
       "\n",
       "    var toolbar = document.createElement('div');\n",
       "    toolbar.classList = 'btn-toolbar';\n",
       "    this.root.appendChild(toolbar);\n",
       "\n",
       "    function on_click_closure(name) {\n",
       "        return function (_event) {\n",
       "            return fig.toolbar_button_onclick(name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    function on_mouseover_closure(tooltip) {\n",
       "        return function (event) {\n",
       "            if (!event.currentTarget.disabled) {\n",
       "                return fig.toolbar_button_onmouseover(tooltip);\n",
       "            }\n",
       "        };\n",
       "    }\n",
       "\n",
       "    fig.buttons = {};\n",
       "    var buttonGroup = document.createElement('div');\n",
       "    buttonGroup.classList = 'btn-group';\n",
       "    var button;\n",
       "    for (var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            /* Instead of a spacer, we start a new button group. */\n",
       "            if (buttonGroup.hasChildNodes()) {\n",
       "                toolbar.appendChild(buttonGroup);\n",
       "            }\n",
       "            buttonGroup = document.createElement('div');\n",
       "            buttonGroup.classList = 'btn-group';\n",
       "            continue;\n",
       "        }\n",
       "\n",
       "        button = fig.buttons[name] = document.createElement('button');\n",
       "        button.classList = 'btn btn-default';\n",
       "        button.href = '#';\n",
       "        button.title = name;\n",
       "        button.innerHTML = '<i class=\"fa ' + image + ' fa-lg\"></i>';\n",
       "        button.addEventListener('click', on_click_closure(method_name));\n",
       "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
       "        buttonGroup.appendChild(button);\n",
       "    }\n",
       "\n",
       "    if (buttonGroup.hasChildNodes()) {\n",
       "        toolbar.appendChild(buttonGroup);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = document.createElement('span');\n",
       "    status_bar.classList = 'mpl-message pull-right';\n",
       "    toolbar.appendChild(status_bar);\n",
       "    this.message = status_bar;\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = document.createElement('div');\n",
       "    buttongrp.classList = 'btn-group inline pull-right';\n",
       "    button = document.createElement('button');\n",
       "    button.classList = 'btn btn-mini btn-primary';\n",
       "    button.href = '#';\n",
       "    button.title = 'Stop Interaction';\n",
       "    button.innerHTML = '<i class=\"fa fa-power-off icon-remove icon-large\"></i>';\n",
       "    button.addEventListener('click', function (_evt) {\n",
       "        fig.handle_close(fig, {});\n",
       "    });\n",
       "    button.addEventListener(\n",
       "        'mouseover',\n",
       "        on_mouseover_closure('Stop Interaction')\n",
       "    );\n",
       "    buttongrp.appendChild(button);\n",
       "    var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n",
       "    titlebar.insertBefore(buttongrp, titlebar.firstChild);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._remove_fig_handler = function (event) {\n",
       "    var fig = event.data.fig;\n",
       "    if (event.target !== this) {\n",
       "        // Ignore bubbled events from children.\n",
       "        return;\n",
       "    }\n",
       "    fig.close_ws(fig, {});\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function (el) {\n",
       "    el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function (el) {\n",
       "    // this is important to make the div 'focusable\n",
       "    el.setAttribute('tabindex', 0);\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    } else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function (event, _name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager) {\n",
       "        manager = IPython.keyboard_manager;\n",
       "    }\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which === 13) {\n",
       "        this.canvas_div.blur();\n",
       "        // select the cell after this one\n",
       "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
       "        IPython.notebook.select(index + 1);\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_save = function (fig, _msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "};\n",
       "\n",
       "mpl.find_output_cell = function (html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i = 0; i < ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code') {\n",
       "            for (var j = 0; j < cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] === html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "};\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel !== null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target(\n",
       "        'matplotlib',\n",
       "        mpl.mpl_figure_comm\n",
       "    );\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"1000\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(nrows=5, ncols=5, figsize=(10,15))\n",
    "for i in range(5):\n",
    "    for j in range(5):\n",
    "        idx = i*5+j\n",
    "        img = test_dataset[idx][0]\n",
    "        label = test_dataset[idx][1]\n",
    "        logits = network(img[None, ...]) # output\n",
    "        probs = F.softmax(logits, dim=1) # apply softmax to normalize them\n",
    "        predicted = torch.argmax(probs[0, ...]) # index of the highest probability\n",
    "        ax[i, j].imshow(img[0,...].detach().cpu().numpy())\n",
    "        ax[i, j].set(title=f\"True {label}, pred. {predicted}\")\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": "73e79a6d",
   "metadata": {},
   "source": [
    "We can also examine the probability that the network gives for all images in the expected class. That is: what is the predicted probability of the network for all images in the true class 4?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "b447df87",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_loader = torch.utils.data.DataLoader(test_dataset, shuffle=False, batch_size=32)\n",
    "logits = list()\n",
    "label = list()\n",
    "for batch in test_loader:\n",
    "    logits += [network(batch[0])]\n",
    "    label += [batch[1]]\n",
    "logits = torch.cat(logits, dim=0)\n",
    "label = torch.cat(label, dim=0)\n",
    "probs = F.softmax(logits, dim=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "d6df7b33",
   "metadata": {},
   "outputs": [],
   "source": [
    "probs_4 = probs.detach().cpu().numpy()[label.detach().cpu().numpy() == 4]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c850c24a",
   "metadata": {},
   "source": [
    "We can histogram it and see that it did mostly a good job, but sometimes it failed. We can go forward and make a cut in the probability and look at those images to identify which images were incorrectly classified."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "93a5fe94",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "/* global mpl */\n",
       "window.mpl = {};\n",
       "\n",
       "mpl.get_websocket_type = function () {\n",
       "    if (typeof WebSocket !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof MozWebSocket !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert(\n",
       "            'Your browser does not have WebSocket support. ' +\n",
       "                'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "                'Firefox 4 and 5 are also supported but you ' +\n",
       "                'have to enable WebSockets in about:config.'\n",
       "        );\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = this.ws.binaryType !== undefined;\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById('mpl-warnings');\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent =\n",
       "                'This browser does not support binary websocket messages. ' +\n",
       "                'Performance may be slow.';\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = document.createElement('div');\n",
       "    this.root.setAttribute('style', 'display: inline-block');\n",
       "    this._root_extra_style(this.root);\n",
       "\n",
       "    parent_element.appendChild(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen = function () {\n",
       "        fig.send_message('supports_binary', { value: fig.supports_binary });\n",
       "        fig.send_message('send_image_mode', {});\n",
       "        if (fig.ratio !== 1) {\n",
       "            fig.send_message('set_dpi_ratio', { dpi_ratio: fig.ratio });\n",
       "        }\n",
       "        fig.send_message('refresh', {});\n",
       "    };\n",
       "\n",
       "    this.imageObj.onload = function () {\n",
       "        if (fig.image_mode === 'full') {\n",
       "            // Full images could contain transparency (where diff images\n",
       "            // almost always do), so we need to clear the canvas so that\n",
       "            // there is no ghosting.\n",
       "            fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "        }\n",
       "        fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "    };\n",
       "\n",
       "    this.imageObj.onunload = function () {\n",
       "        fig.ws.close();\n",
       "    };\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._init_header = function () {\n",
       "    var titlebar = document.createElement('div');\n",
       "    titlebar.classList =\n",
       "        'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n",
       "    var titletext = document.createElement('div');\n",
       "    titletext.classList = 'ui-dialog-title';\n",
       "    titletext.setAttribute(\n",
       "        'style',\n",
       "        'width: 100%; text-align: center; padding: 3px;'\n",
       "    );\n",
       "    titlebar.appendChild(titletext);\n",
       "    this.root.appendChild(titlebar);\n",
       "    this.header = titletext;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function () {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = (this.canvas_div = document.createElement('div'));\n",
       "    canvas_div.setAttribute(\n",
       "        'style',\n",
       "        'border: 1px solid #ddd;' +\n",
       "            'box-sizing: content-box;' +\n",
       "            'clear: both;' +\n",
       "            'min-height: 1px;' +\n",
       "            'min-width: 1px;' +\n",
       "            'outline: 0;' +\n",
       "            'overflow: hidden;' +\n",
       "            'position: relative;' +\n",
       "            'resize: both;'\n",
       "    );\n",
       "\n",
       "    function on_keyboard_event_closure(name) {\n",
       "        return function (event) {\n",
       "            return fig.key_event(event, name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    canvas_div.addEventListener(\n",
       "        'keydown',\n",
       "        on_keyboard_event_closure('key_press')\n",
       "    );\n",
       "    canvas_div.addEventListener(\n",
       "        'keyup',\n",
       "        on_keyboard_event_closure('key_release')\n",
       "    );\n",
       "\n",
       "    this._canvas_extra_style(canvas_div);\n",
       "    this.root.appendChild(canvas_div);\n",
       "\n",
       "    var canvas = (this.canvas = document.createElement('canvas'));\n",
       "    canvas.classList.add('mpl-canvas');\n",
       "    canvas.setAttribute('style', 'box-sizing: content-box;');\n",
       "\n",
       "    this.context = canvas.getContext('2d');\n",
       "\n",
       "    var backingStore =\n",
       "        this.context.backingStorePixelRatio ||\n",
       "        this.context.webkitBackingStorePixelRatio ||\n",
       "        this.context.mozBackingStorePixelRatio ||\n",
       "        this.context.msBackingStorePixelRatio ||\n",
       "        this.context.oBackingStorePixelRatio ||\n",
       "        this.context.backingStorePixelRatio ||\n",
       "        1;\n",
       "\n",
       "    this.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n",
       "        'canvas'\n",
       "    ));\n",
       "    rubberband_canvas.setAttribute(\n",
       "        'style',\n",
       "        'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n",
       "    );\n",
       "\n",
       "    // Apply a ponyfill if ResizeObserver is not implemented by browser.\n",
       "    if (this.ResizeObserver === undefined) {\n",
       "        if (window.ResizeObserver !== undefined) {\n",
       "            this.ResizeObserver = window.ResizeObserver;\n",
       "        } else {\n",
       "            var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n",
       "            this.ResizeObserver = obs.ResizeObserver;\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n",
       "        var nentries = entries.length;\n",
       "        for (var i = 0; i < nentries; i++) {\n",
       "            var entry = entries[i];\n",
       "            var width, height;\n",
       "            if (entry.contentBoxSize) {\n",
       "                if (entry.contentBoxSize instanceof Array) {\n",
       "                    // Chrome 84 implements new version of spec.\n",
       "                    width = entry.contentBoxSize[0].inlineSize;\n",
       "                    height = entry.contentBoxSize[0].blockSize;\n",
       "                } else {\n",
       "                    // Firefox implements old version of spec.\n",
       "                    width = entry.contentBoxSize.inlineSize;\n",
       "                    height = entry.contentBoxSize.blockSize;\n",
       "                }\n",
       "            } else {\n",
       "                // Chrome <84 implements even older version of spec.\n",
       "                width = entry.contentRect.width;\n",
       "                height = entry.contentRect.height;\n",
       "            }\n",
       "\n",
       "            // Keep the size of the canvas and rubber band canvas in sync with\n",
       "            // the canvas container.\n",
       "            if (entry.devicePixelContentBoxSize) {\n",
       "                // Chrome 84 implements new version of spec.\n",
       "                canvas.setAttribute(\n",
       "                    'width',\n",
       "                    entry.devicePixelContentBoxSize[0].inlineSize\n",
       "                );\n",
       "                canvas.setAttribute(\n",
       "                    'height',\n",
       "                    entry.devicePixelContentBoxSize[0].blockSize\n",
       "                );\n",
       "            } else {\n",
       "                canvas.setAttribute('width', width * fig.ratio);\n",
       "                canvas.setAttribute('height', height * fig.ratio);\n",
       "            }\n",
       "            canvas.setAttribute(\n",
       "                'style',\n",
       "                'width: ' + width + 'px; height: ' + height + 'px;'\n",
       "            );\n",
       "\n",
       "            rubberband_canvas.setAttribute('width', width);\n",
       "            rubberband_canvas.setAttribute('height', height);\n",
       "\n",
       "            // And update the size in Python. We ignore the initial 0/0 size\n",
       "            // that occurs as the element is placed into the DOM, which should\n",
       "            // otherwise not happen due to the minimum size styling.\n",
       "            if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n",
       "                fig.request_resize(width, height);\n",
       "            }\n",
       "        }\n",
       "    });\n",
       "    this.resizeObserverInstance.observe(canvas_div);\n",
       "\n",
       "    function on_mouse_event_closure(name) {\n",
       "        return function (event) {\n",
       "            return fig.mouse_event(event, name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mousedown',\n",
       "        on_mouse_event_closure('button_press')\n",
       "    );\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mouseup',\n",
       "        on_mouse_event_closure('button_release')\n",
       "    );\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mousemove',\n",
       "        on_mouse_event_closure('motion_notify')\n",
       "    );\n",
       "\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mouseenter',\n",
       "        on_mouse_event_closure('figure_enter')\n",
       "    );\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mouseleave',\n",
       "        on_mouse_event_closure('figure_leave')\n",
       "    );\n",
       "\n",
       "    canvas_div.addEventListener('wheel', function (event) {\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        on_mouse_event_closure('scroll')(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.appendChild(canvas);\n",
       "    canvas_div.appendChild(rubberband_canvas);\n",
       "\n",
       "    this.rubberband_context = rubberband_canvas.getContext('2d');\n",
       "    this.rubberband_context.strokeStyle = '#000000';\n",
       "\n",
       "    this._resize_canvas = function (width, height, forward) {\n",
       "        if (forward) {\n",
       "            canvas_div.style.width = width + 'px';\n",
       "            canvas_div.style.height = height + 'px';\n",
       "        }\n",
       "    };\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n",
       "        event.preventDefault();\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus() {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function () {\n",
       "    var fig = this;\n",
       "\n",
       "    var toolbar = document.createElement('div');\n",
       "    toolbar.classList = 'mpl-toolbar';\n",
       "    this.root.appendChild(toolbar);\n",
       "\n",
       "    function on_click_closure(name) {\n",
       "        return function (_event) {\n",
       "            return fig.toolbar_button_onclick(name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    function on_mouseover_closure(tooltip) {\n",
       "        return function (event) {\n",
       "            if (!event.currentTarget.disabled) {\n",
       "                return fig.toolbar_button_onmouseover(tooltip);\n",
       "            }\n",
       "        };\n",
       "    }\n",
       "\n",
       "    fig.buttons = {};\n",
       "    var buttonGroup = document.createElement('div');\n",
       "    buttonGroup.classList = 'mpl-button-group';\n",
       "    for (var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            /* Instead of a spacer, we start a new button group. */\n",
       "            if (buttonGroup.hasChildNodes()) {\n",
       "                toolbar.appendChild(buttonGroup);\n",
       "            }\n",
       "            buttonGroup = document.createElement('div');\n",
       "            buttonGroup.classList = 'mpl-button-group';\n",
       "            continue;\n",
       "        }\n",
       "\n",
       "        var button = (fig.buttons[name] = document.createElement('button'));\n",
       "        button.classList = 'mpl-widget';\n",
       "        button.setAttribute('role', 'button');\n",
       "        button.setAttribute('aria-disabled', 'false');\n",
       "        button.addEventListener('click', on_click_closure(method_name));\n",
       "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
       "\n",
       "        var icon_img = document.createElement('img');\n",
       "        icon_img.src = '_images/' + image + '.png';\n",
       "        icon_img.srcset = '_images/' + image + '_large.png 2x';\n",
       "        icon_img.alt = tooltip;\n",
       "        button.appendChild(icon_img);\n",
       "\n",
       "        buttonGroup.appendChild(button);\n",
       "    }\n",
       "\n",
       "    if (buttonGroup.hasChildNodes()) {\n",
       "        toolbar.appendChild(buttonGroup);\n",
       "    }\n",
       "\n",
       "    var fmt_picker = document.createElement('select');\n",
       "    fmt_picker.classList = 'mpl-widget';\n",
       "    toolbar.appendChild(fmt_picker);\n",
       "    this.format_dropdown = fmt_picker;\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = document.createElement('option');\n",
       "        option.selected = fmt === mpl.default_extension;\n",
       "        option.innerHTML = fmt;\n",
       "        fmt_picker.appendChild(option);\n",
       "    }\n",
       "\n",
       "    var status_bar = document.createElement('span');\n",
       "    status_bar.classList = 'mpl-message';\n",
       "    toolbar.appendChild(status_bar);\n",
       "    this.message = status_bar;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', { width: x_pixels, height: y_pixels });\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.send_message = function (type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function () {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_save = function (fig, _msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function (fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1], msg['forward']);\n",
       "        fig.send_message('refresh', {});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n",
       "    var x0 = msg['x0'] / fig.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n",
       "    var x1 = msg['x1'] / fig.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0,\n",
       "        0,\n",
       "        fig.canvas.width / fig.ratio,\n",
       "        fig.canvas.height / fig.ratio\n",