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",