Supervised regression.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",
       "            var img = evt.data;\n",
       "            if (img.type !== 'image/png') {\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",
       "                img.type = 'image/png';\n",
       "            }\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",
       "                img\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.key === this._key) {\n",
       "            return;\n",
       "        } else {\n",
       "            this._key = event.key;\n",
       "        }\n",
       "    }\n",
       "    if (name === 'key_release') {\n",
       "        this._key = null;\n",
       "    }\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.key !== 'Control') {\n",
       "        value += 'ctrl+';\n",
       "    }\n",
       "    else if (event.altKey && event.key !== 'Alt') {\n",
       "        value += 'alt+';\n",
       "    }\n",
       "    else if (event.shiftKey && event.key !== 'Shift') {\n",
       "        value += 'shift+';\n",
       "    }\n",
       "\n",
       "    value += 'k' + event.key;\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\", \"pgf\", \"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.binaryType = comm.kernel.ws.binaryType;\n",
       "    ws.readyState = comm.kernel.ws.readyState;\n",
       "    function updateReadyState(_event) {\n",
       "        if (comm.kernel.ws) {\n",
       "            ws.readyState = comm.kernel.ws.readyState;\n",
       "        } else {\n",
       "            ws.readyState = 3; // Closed state.\n",
       "        }\n",
       "    }\n",
       "    comm.kernel.ws.addEventListener('open', updateReadyState);\n",
       "    comm.kernel.ws.addEventListener('close', updateReadyState);\n",
       "    comm.kernel.ws.addEventListener('error', updateReadyState);\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",
       "        var data = msg['content']['data'];\n",
       "        if (data['blob'] !== undefined) {\n",
       "            data = {\n",
       "                data: new Blob(msg['buffers'], { type: data['blob'] }),\n",
       "            };\n",
       "        }\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(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=\"640\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "ax.scatter(test_data[:, 0], test_data[:, 1], label=\"Test data\")\n",
    "ax.scatter(test_data[:, 0], predicted, label=\"Predicted\")\n",
    "ax.set(xlabel=\"$x$\", ylabel=\"$f(x)$\")\n",
    "#ax.set_yscale('log')\n",
    "plt.legend(frameon=False)\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {
    "elbo.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "6bd7c62d",
   "metadata": {},
   "source": [
    "## What about an uncertainty?!\n",
    "\n",
    "The method shown before finds the neural network parameters which maximize the log-likelihood of the data. But not all parameters are equally likely and we can estimate an uncertainty for them.\n",
    "\n",
    "With an uncertainty for the parameters, we can propagate the uncertainty through the neural network and obtain an uncertainty on the prediction of the regression output.\n",
    "\n",
    "This can be done assuming each weight in the network function has a given probability distribution and instead of fitting a single value for the weight, we fit the parameters of this probability distribution. For the example shown here, we assume that the probability distribution of the weights is Gaussian and we aim to obtain the mean and variance of the Gaussian.\n",
    "\n",
    "We are going to include the epistemic uncertainty through the variation of the weights. That is, the fact that the weights vary and lead to different effective functions allow us to model different $f(x)$ dependence relationships and this is attributed to the epistemic uncertainty.\n",
    "\n",
    "We additionally assume that the data collected has some aleatoric uncertainty, which means that every point is uncertain by some fixed unknown amount. To model this effect, we assume that the likelihood function $p(\\text{data}|\\theta)$ can be modelled by a Gaussian distribution with a certain standard deviation $\\sigma_a$. This standard deviation will be used to model the aleatoric uncertainty.\n",
    "\n",
    "The final loss function to be optimised here is:\n",
    "\n",
    "$\\mathcal{L} = -\\mathbb{E}_{\\text{data}}\\left[\\log p(\\text{data}|\\text{weights})\\right] + \\frac{1}{M} KL(\\text{weights}|\\text{prior})$\n",
    "\n",
    "The first term is assumed to be a Gaussian with the standard deviation given by the aleatoric uncertainty (assumed to be the same for every data point, but this could be changed to be data-point specific as well!). The second term corresponds to a penalty for varying the weights away from the prior assumption that the weights are Gaussian with a mean zero and standard deviation 0.1. In this equation, $M$ is the number of batches used.\n",
    "\n",
    "It can be shown that by minimizing this loss function, we obtain weights mean and standard deviations that approximately optimize the posterior probability given by the Bayes rule: $p(\\text{weights}|\\text{data}) = \\frac{p(\\text{data}|\\text{weights}) p(\\text{weights})}{p(\\text{data})}$. The proof follows by algebraically trying to minimize the Kullback-Leibler divergence between the true posterior given by the Bayes rule and the approximate posterior, on which the weights are assumed to be Gaussian and the likelihood is assumed to be Gaussian.\n",
    "\n",
    "![elbo.png](attachment:elbo.png)\n",
    "\n",
    "The details of the derivation can be consulted in the following paper:\n",
    "\n",
    "https://arxiv.org/pdf/1505.05424.pdf\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "f8d501ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "class BayesianNetwork(nn.Module):\n",
    "    \"\"\"\n",
    "        A model Bayesian Neural network.\n",
    "        Each weight is represented by a Gaussian with a mean and a standard deviation.\n",
    "        Each evaluation of forward leads to a different choice of the weights, so running\n",
    "        forward several times we can check the effect of the weights variation on the same input.\n",
    "        The nll function implements the negative log likelihood to be used as the first part of the loss\n",
    "        function (the second shall be the Kullback-Leibler divergence).\n",
    "        The negative log-likelihood is simply the negative log likelihood of a Gaussian\n",
    "        between the prediction and the true value. The standard deviation of the Gaussian is left as a\n",
    "        parameter to be fit: sigma.\n",
    "    \"\"\"\n",
    "    def __init__(self, input_dimension: int=1, output_dimension: int=1):\n",
    "        super(BayesianNetwork, self).__init__()\n",
    "        hidden_dimension = 100\n",
    "        self.model = nn.Sequential(\n",
    "                                   bnn.BayesLinear(prior_mu=0,\n",
    "                                                   prior_sigma=0.1,\n",
    "                                                   in_features=input_dimension,\n",
    "                                                   out_features=hidden_dimension),\n",
    "                                   nn.ReLU(),\n",
    "                                   bnn.BayesLinear(prior_mu=0,\n",
    "                                                   prior_sigma=0.1,\n",
    "                                                   in_features=hidden_dimension,\n",
    "                                                   out_features=hidden_dimension),\n",
    "                                   nn.ReLU(),\n",
    "                                   bnn.BayesLinear(prior_mu=0,\n",
    "                                                   prior_sigma=0.1,\n",
    "                                                   in_features=hidden_dimension,\n",
    "                                                   out_features=output_dimension)\n",
    "                                    )\n",
    "        self.log_sigma2 = nn.Parameter(torch.ones(1), requires_grad=True)\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"\n",
    "        Calculate the result f(x) applied on the input x.\n",
    "        \"\"\"\n",
    "        return self.model(x)\n",
    "\n",
    "    def nll(self, prediction: torch.Tensor, target: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"\n",
    "        Calculate the negative log-likelihood (divided by the batch size, since we take the mean).\n",
    "        \"\"\"\n",
    "        error = prediction - target\n",
    "        squared_error = error**2\n",
    "        sigma2 = torch.exp(self.log_sigma2)[0]\n",
    "        norm_error = 0.5*squared_error/sigma2\n",
    "        norm_term = 0.5*(np.log(2*np.pi) + self.log_sigma2[0])\n",
    "        return norm_error.mean() + norm_term\n",
    "\n",
    "    def aleatoric_uncertainty(self) -> torch.Tensor:\n",
    "        \"\"\"\n",
    "            Get the aleatoric component of the uncertainty.\n",
    "        \"\"\"\n",
    "        return torch.exp(0.5*self.log_sigma2[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "7b9beb21",
   "metadata": {},
   "outputs": [],
   "source": [
    "# create the neural network:\n",
    "b_network = BayesianNetwork()\n",
    "\n",
    "# create the object to load the data:\n",
    "B = 10\n",
    "loader = torch.utils.data.DataLoader(my_dataset, batch_size=B)\n",
    "\n",
    "# create the optimizer to be used \n",
    "optimizer = torch.optim.Adam(b_network.parameters(), lr=0.001)\n",
    "\n",
    "# the Kullback-Leibler divergence should be scaled by 1/number_of_batches\n",
    "# see https://arxiv.org/abs/1505.05424 for more information on this\n",
    "number_of_batches = len(my_dataset)/float(B)\n",
    "weight_kl = 1.0/float(number_of_batches)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c68ba2e2",
   "metadata": {},
   "source": [
    "The criteria for finding the optimal weights are based on the Bayes' theorem, on which the posterior probability of the weights is proportional to the likelihood of the data given the weights and to the prior probability of the weights. We assume the prior probability of the weights is Gaussian corresponding to a unit Gaussian centred at zero and with standard deviation 0.1. This prior has a regularizing effect, preventing overtraining.\n",
    "\n",
    "We can translate the Bayes theorem and the assumption that the final posterior distribution is also Gaussian into an optimization procedure to find the posterior mean and variance of the posterior distribution. The function optimized to obtain the mean and variances of the Gaussians for the weights is the sum between the mean-squared-error (corresponding to a Gaussian log-likelihood of the data) and the Kullback-Leibler divergence between the weights distribution and the prior Gaussian."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "fbea6b0c",
   "metadata": {},
   "outputs": [],
   "source": [
    "kl_loss = bnn.BKLLoss(reduction='mean', last_layer_only=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "b92ed4b0",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 0/500  total: 58.60563, -LL: 29.30297, prior: 0.49401, aleatoric unc.: 1.70738\n",
      "Epoch 1/500  total: 29.89883, -LL: 22.77377, prior: 0.51578, aleatoric unc.: 1.74675\n",
      "Epoch 2/500  total: 24.01581, -LL: 19.56905, prior: 0.54058, aleatoric unc.: 1.78531\n",
      "Epoch 3/500  total: 20.88541, -LL: 15.23512, prior: 0.56686, aleatoric unc.: 1.82458\n",
      "Epoch 4/500  total: 18.42086, -LL: 12.56114, prior: 0.59138, aleatoric unc.: 1.86375\n",
      "Epoch 5/500  total: 16.78540, -LL: 11.47957, prior: 0.61184, aleatoric unc.: 1.90320\n",
      "Epoch 6/500  total: 15.74639, -LL: 10.39981, prior: 0.63168, aleatoric unc.: 1.94387\n",
      "Epoch 7/500  total: 15.23265, -LL: 10.92122, prior: 0.64618, aleatoric unc.: 1.98676\n",
      "Epoch 8/500  total: 14.43628, -LL: 14.04801, prior: 0.65764, aleatoric unc.: 2.03084\n",
      "Epoch 9/500  total: 13.75567, -LL: 9.28419, prior: 0.66495, aleatoric unc.: 2.07617\n",
      "Epoch 10/500  total: 13.46332, -LL: 9.24567, prior: 0.67066, aleatoric unc.: 2.12401\n",
      "Epoch 11/500  total: 12.68328, -LL: 8.02405, prior: 0.68236, aleatoric unc.: 2.17244\n",
      "Epoch 12/500  total: 12.16965, -LL: 10.14399, prior: 0.69100, aleatoric unc.: 2.22149\n",
      "Epoch 13/500  total: 11.89046, -LL: 10.02692, prior: 0.69707, aleatoric unc.: 2.27265\n",
      "Epoch 14/500  total: 11.31826, -LL: 8.22698, prior: 0.70348, aleatoric unc.: 2.32503\n",
      "Epoch 15/500  total: 11.15097, -LL: 8.46218, prior: 0.70463, aleatoric unc.: 2.37917\n",
      "Epoch 16/500  total: 10.78811, -LL: 6.91465, prior: 0.70900, aleatoric unc.: 2.43505\n",
      "Epoch 17/500  total: 10.27545, -LL: 7.55249, prior: 0.70822, aleatoric unc.: 2.49083\n",
      "Epoch 18/500  total: 9.88403, -LL: 7.78374, prior: 0.70896, aleatoric unc.: 2.54750\n",
      "Epoch 19/500  total: 9.49734, -LL: 6.96424, prior: 0.71104, aleatoric unc.: 2.60481\n",
      "Epoch 20/500  total: 9.18567, -LL: 6.83609, prior: 0.71782, aleatoric unc.: 2.66279\n",
      "Epoch 21/500  total: 8.77549, -LL: 6.85847, prior: 0.72051, aleatoric unc.: 2.72092\n",
      "Epoch 22/500  total: 8.64839, -LL: 6.52611, prior: 0.71736, aleatoric unc.: 2.78174\n",
      "Epoch 23/500  total: 8.43415, -LL: 7.78695, prior: 0.71795, aleatoric unc.: 2.84376\n",
      "Epoch 24/500  total: 8.17714, -LL: 6.13595, prior: 0.72104, aleatoric unc.: 2.90688\n",
      "Epoch 25/500  total: 7.70156, -LL: 6.61542, prior: 0.72217, aleatoric unc.: 2.96854\n",
      "Epoch 26/500  total: 7.61942, -LL: 6.63054, prior: 0.72667, aleatoric unc.: 3.03244\n",
      "Epoch 27/500  total: 7.42529, -LL: 5.76781, prior: 0.72993, aleatoric unc.: 3.09773\n",
      "Epoch 28/500  total: 7.29471, -LL: 6.51807, prior: 0.72927, aleatoric unc.: 3.16509\n",
      "Epoch 29/500  total: 7.12159, -LL: 5.48303, prior: 0.73176, aleatoric unc.: 3.23374\n",
      "Epoch 30/500  total: 6.79870, -LL: 6.10557, prior: 0.73237, aleatoric unc.: 3.30124\n",
      "Epoch 31/500  total: 6.60342, -LL: 5.65072, prior: 0.73511, aleatoric unc.: 3.36955\n",
      "Epoch 32/500  total: 6.63333, -LL: 6.37231, prior: 0.73616, aleatoric unc.: 3.44177\n",
      "Epoch 33/500  total: 6.25342, -LL: 5.67089, prior: 0.73999, aleatoric unc.: 3.51138\n",
      "Epoch 34/500  total: 6.25324, -LL: 5.80523, prior: 0.74006, aleatoric unc.: 3.58479\n",
      "Epoch 35/500  total: 6.06724, -LL: 4.63822, prior: 0.73928, aleatoric unc.: 3.65814\n",
      "Epoch 36/500  total: 5.97354, -LL: 4.87066, prior: 0.73962, aleatoric unc.: 3.73306\n",
      "Epoch 37/500  total: 5.75250, -LL: 5.21252, prior: 0.74361, aleatoric unc.: 3.80782\n",
      "Epoch 38/500  total: 5.70047, -LL: 4.60235, prior: 0.74538, aleatoric unc.: 3.88453\n",
      "Epoch 39/500  total: 5.65181, -LL: 5.21456, prior: 0.74527, aleatoric unc.: 3.96423\n",
      "Epoch 40/500  total: 5.43323, -LL: 4.63033, prior: 0.74861, aleatoric unc.: 4.04155\n",
      "Epoch 41/500  total: 5.28977, -LL: 5.04850, prior: 0.74891, aleatoric unc.: 4.11915\n",
      "Epoch 42/500  total: 5.24329, -LL: 5.24680, prior: 0.74535, aleatoric unc.: 4.19924\n",
      "Epoch 43/500  total: 5.17848, -LL: 4.70368, prior: 0.75037, aleatoric unc.: 4.28055\n",
      "Epoch 44/500  total: 5.16991, -LL: 4.86729, prior: 0.74977, aleatoric unc.: 4.36667\n",
      "Epoch 45/500  total: 5.00426, -LL: 4.76213, prior: 0.74627, aleatoric unc.: 4.45042\n",
      "Epoch 46/500  total: 4.96309, -LL: 4.31775, prior: 0.75200, aleatoric unc.: 4.53622\n",
      "Epoch 47/500  total: 4.89156, -LL: 4.62450, prior: 0.75400, aleatoric unc.: 4.62413\n",
      "Epoch 48/500  total: 4.77733, -LL: 4.33423, prior: 0.75599, aleatoric unc.: 4.71083\n",
      "Epoch 49/500  total: 4.70859, -LL: 4.23383, prior: 0.75542, aleatoric unc.: 4.79768\n",
      "Epoch 50/500  total: 4.61107, -LL: 4.23617, prior: 0.75896, aleatoric unc.: 4.88461\n",
      "Epoch 51/500  total: 4.53410, -LL: 4.05732, prior: 0.76156, aleatoric unc.: 4.97112\n",
      "Epoch 52/500  total: 4.53218, -LL: 4.03225, prior: 0.76646, aleatoric unc.: 5.06118\n",
      "Epoch 53/500  total: 4.47935, -LL: 4.09978, prior: 0.76704, aleatoric unc.: 5.15256\n",
      "Epoch 54/500  total: 4.39028, -LL: 3.94386, prior: 0.76755, aleatoric unc.: 5.24289\n",
      "Epoch 55/500  total: 4.38337, -LL: 4.36773, prior: 0.76699, aleatoric unc.: 5.33596\n",
      "Epoch 56/500  total: 4.35281, -LL: 4.11247, prior: 0.77196, aleatoric unc.: 5.43080\n",
      "Epoch 57/500  total: 4.29956, -LL: 3.87602, prior: 0.77093, aleatoric unc.: 5.52630\n",
      "Epoch 58/500  total: 4.23197, -LL: 4.01298, prior: 0.77028, aleatoric unc.: 5.62054\n",
      "Epoch 59/500  total: 4.24475, -LL: 3.99289, prior: 0.77126, aleatoric unc.: 5.71866\n",
      "Epoch 60/500  total: 4.16691, -LL: 3.89405, prior: 0.77055, aleatoric unc.: 5.81574\n",
      "Epoch 61/500  total: 4.16522, -LL: 3.96328, prior: 0.76699, aleatoric unc.: 5.91432\n",
      "Epoch 62/500  total: 4.11586, -LL: 3.69259, prior: 0.76921, aleatoric unc.: 6.01400\n",
      "Epoch 63/500  total: 4.07180, -LL: 3.89622, prior: 0.77077, aleatoric unc.: 6.11181\n",
      "Epoch 64/500  total: 4.07462, -LL: 3.86786, prior: 0.77294, aleatoric unc.: 6.21290\n",
      "Epoch 65/500  total: 4.01141, -LL: 3.77488, prior: 0.77207, aleatoric unc.: 6.31128\n",
      "Epoch 66/500  total: 3.99999, -LL: 3.65617, prior: 0.77586, aleatoric unc.: 6.41138\n",
      "Epoch 67/500  total: 4.02086, -LL: 3.71232, prior: 0.77457, aleatoric unc.: 6.51647\n",
      "Epoch 68/500  total: 3.96727, -LL: 3.82445, prior: 0.77131, aleatoric unc.: 6.61852\n",
      "Epoch 69/500  total: 3.91331, -LL: 3.59059, prior: 0.77492, aleatoric unc.: 6.71576\n",
      "Epoch 70/500  total: 3.92368, -LL: 3.87038, prior: 0.77663, aleatoric unc.: 6.81692\n",
      "Epoch 71/500  total: 3.91091, -LL: 3.71611, prior: 0.77434, aleatoric unc.: 6.91915\n",
      "Epoch 72/500  total: 3.90254, -LL: 3.84058, prior: 0.77568, aleatoric unc.: 7.02362\n",
      "Epoch 73/500  total: 3.86610, -LL: 3.79804, prior: 0.77613, aleatoric unc.: 7.12259\n",
      "Epoch 74/500  total: 3.86877, -LL: 3.67038, prior: 0.77967, aleatoric unc.: 7.22509\n",
      "Epoch 75/500  total: 3.83692, -LL: 3.71282, prior: 0.78043, aleatoric unc.: 7.32391\n",
      "Epoch 76/500  total: 3.84445, -LL: 3.81955, prior: 0.77407, aleatoric unc.: 7.42552\n",
      "Epoch 77/500  total: 3.82880, -LL: 3.67313, prior: 0.77377, aleatoric unc.: 7.52656\n",
      "Epoch 78/500  total: 3.81437, -LL: 3.66513, prior: 0.77432, aleatoric unc.: 7.62591\n",
      "Epoch 79/500  total: 3.78821, -LL: 3.75625, prior: 0.77875, aleatoric unc.: 7.71907\n",
      "Epoch 80/500  total: 3.83347, -LL: 3.61354, prior: 0.77968, aleatoric unc.: 7.82734\n",
      "Epoch 81/500  total: 3.78359, -LL: 3.59515, prior: 0.77631, aleatoric unc.: 7.92300\n",
      "Epoch 82/500  total: 3.78367, -LL: 3.67180, prior: 0.77953, aleatoric unc.: 8.01834\n",
      "Epoch 83/500  total: 3.75569, -LL: 3.61895, prior: 0.78101, aleatoric unc.: 8.10435\n",
      "Epoch 84/500  total: 3.76833, -LL: 3.55765, prior: 0.78393, aleatoric unc.: 8.19697\n",
      "Epoch 85/500  total: 3.76053, -LL: 3.68451, prior: 0.78236, aleatoric unc.: 8.28731\n",
      "Epoch 86/500  total: 3.76217, -LL: 3.74953, prior: 0.78270, aleatoric unc.: 8.37660\n",
      "Epoch 87/500  total: 3.73655, -LL: 3.64136, prior: 0.77914, aleatoric unc.: 8.45761\n",
      "Epoch 88/500  total: 3.75396, -LL: 3.62085, prior: 0.77929, aleatoric unc.: 8.54510\n",
      "Epoch 89/500  total: 3.74527, -LL: 3.68434, prior: 0.77997, aleatoric unc.: 8.62806\n",
      "Epoch 90/500  total: 3.75304, -LL: 3.66249, prior: 0.77914, aleatoric unc.: 8.71503\n",
      "Epoch 91/500  total: 3.72325, -LL: 3.60384, prior: 0.77980, aleatoric unc.: 8.78583\n",
      "Epoch 92/500  total: 3.74192, -LL: 3.59396, prior: 0.78044, aleatoric unc.: 8.86492\n",
      "Epoch 93/500  total: 3.71866, -LL: 3.61358, prior: 0.78299, aleatoric unc.: 8.93002\n",
      "Epoch 94/500  total: 3.72444, -LL: 3.58171, prior: 0.78235, aleatoric unc.: 8.99536\n",
      "Epoch 95/500  total: 3.72439, -LL: 3.60700, prior: 0.77858, aleatoric unc.: 9.05974\n",
      "Epoch 96/500  total: 3.73727, -LL: 3.67353, prior: 0.77897, aleatoric unc.: 9.13145\n",
      "Epoch 97/500  total: 3.73587, -LL: 3.65088, prior: 0.78041, aleatoric unc.: 9.19960\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 98/500  total: 3.72790, -LL: 3.58224, prior: 0.78028, aleatoric unc.: 9.25964\n",
      "Epoch 99/500  total: 3.71771, -LL: 3.66020, prior: 0.77745, aleatoric unc.: 9.31000\n",
      "Epoch 100/500  total: 3.72549, -LL: 3.62102, prior: 0.77761, aleatoric unc.: 9.36518\n",
      "Epoch 101/500  total: 3.71956, -LL: 3.57595, prior: 0.77925, aleatoric unc.: 9.41201\n",
      "Epoch 102/500  total: 3.72677, -LL: 3.57028, prior: 0.77652, aleatoric unc.: 9.46463\n",
      "Epoch 103/500  total: 3.72387, -LL: 3.65744, prior: 0.77754, aleatoric unc.: 9.50802\n",
      "Epoch 104/500  total: 3.71402, -LL: 3.60348, prior: 0.77234, aleatoric unc.: 9.54170\n",
      "Epoch 105/500  total: 3.72198, -LL: 3.63285, prior: 0.77360, aleatoric unc.: 9.58104\n",
      "Epoch 106/500  total: 3.71737, -LL: 3.64993, prior: 0.77597, aleatoric unc.: 9.61322\n",
      "Epoch 107/500  total: 3.71005, -LL: 3.56981, prior: 0.77387, aleatoric unc.: 9.63459\n",
      "Epoch 108/500  total: 3.71906, -LL: 3.58226, prior: 0.77644, aleatoric unc.: 9.66549\n",
      "Epoch 109/500  total: 3.72139, -LL: 3.63789, prior: 0.77184, aleatoric unc.: 9.69481\n",
      "Epoch 110/500  total: 3.70912, -LL: 3.60181, prior: 0.77226, aleatoric unc.: 9.71032\n",
      "Epoch 111/500  total: 3.71838, -LL: 3.63031, prior: 0.77578, aleatoric unc.: 9.73120\n",
      "Epoch 112/500  total: 3.71506, -LL: 3.61052, prior: 0.77374, aleatoric unc.: 9.74926\n",
      "Epoch 113/500  total: 3.71562, -LL: 3.72471, prior: 0.77285, aleatoric unc.: 9.76058\n",
      "Epoch 114/500  total: 3.71990, -LL: 3.74557, prior: 0.76846, aleatoric unc.: 9.78141\n",
      "Epoch 115/500  total: 3.72581, -LL: 3.67777, prior: 0.76765, aleatoric unc.: 9.80824\n",
      "Epoch 116/500  total: 3.72395, -LL: 3.66619, prior: 0.76687, aleatoric unc.: 9.82927\n",
      "Epoch 117/500  total: 3.72196, -LL: 3.67000, prior: 0.76839, aleatoric unc.: 9.84076\n",
      "Epoch 118/500  total: 3.70945, -LL: 3.61228, prior: 0.76902, aleatoric unc.: 9.84046\n",
      "Epoch 119/500  total: 3.71781, -LL: 3.57591, prior: 0.77380, aleatoric unc.: 9.84767\n",
      "Epoch 120/500  total: 3.70874, -LL: 3.66554, prior: 0.77551, aleatoric unc.: 9.83665\n",
      "Epoch 121/500  total: 3.72752, -LL: 3.65136, prior: 0.77845, aleatoric unc.: 9.86153\n",
      "Epoch 122/500  total: 3.73040, -LL: 3.62794, prior: 0.77837, aleatoric unc.: 9.88645\n",
      "Epoch 123/500  total: 3.71462, -LL: 3.68275, prior: 0.78350, aleatoric unc.: 9.88238\n",
      "Epoch 124/500  total: 3.71511, -LL: 3.59032, prior: 0.78381, aleatoric unc.: 9.87697\n",
      "Epoch 125/500  total: 3.72409, -LL: 3.58439, prior: 0.78439, aleatoric unc.: 9.89114\n",
      "Epoch 126/500  total: 3.71711, -LL: 3.66987, prior: 0.78606, aleatoric unc.: 9.88819\n",
      "Epoch 127/500  total: 3.71188, -LL: 3.63467, prior: 0.78302, aleatoric unc.: 9.87889\n",
      "Epoch 128/500  total: 3.72376, -LL: 3.58284, prior: 0.78485, aleatoric unc.: 9.88960\n",
      "Epoch 129/500  total: 3.71365, -LL: 3.66670, prior: 0.78087, aleatoric unc.: 9.88381\n",
      "Epoch 130/500  total: 3.72456, -LL: 3.66885, prior: 0.78370, aleatoric unc.: 9.89316\n",
      "Epoch 131/500  total: 3.71323, -LL: 3.62470, prior: 0.78227, aleatoric unc.: 9.88930\n",
      "Epoch 132/500  total: 3.71856, -LL: 3.66937, prior: 0.78154, aleatoric unc.: 9.88618\n",
      "Epoch 133/500  total: 3.71670, -LL: 3.64594, prior: 0.77825, aleatoric unc.: 9.88424\n",
      "Epoch 134/500  total: 3.72210, -LL: 3.60950, prior: 0.77902, aleatoric unc.: 9.89171\n",
      "Epoch 135/500  total: 3.71507, -LL: 3.59651, prior: 0.77877, aleatoric unc.: 9.88918\n",
      "Epoch 136/500  total: 3.71900, -LL: 3.65212, prior: 0.78622, aleatoric unc.: 9.89051\n",
      "Epoch 137/500  total: 3.71307, -LL: 3.61388, prior: 0.78563, aleatoric unc.: 9.88130\n",
      "Epoch 138/500  total: 3.71602, -LL: 3.60536, prior: 0.78637, aleatoric unc.: 9.88007\n",
      "Epoch 139/500  total: 3.72967, -LL: 3.64175, prior: 0.78606, aleatoric unc.: 9.89858\n",
      "Epoch 140/500  total: 3.71805, -LL: 3.57543, prior: 0.78286, aleatoric unc.: 9.90221\n",
      "Epoch 141/500  total: 3.71457, -LL: 3.60350, prior: 0.78505, aleatoric unc.: 9.89543\n",
      "Epoch 142/500  total: 3.71818, -LL: 3.66506, prior: 0.79071, aleatoric unc.: 9.89198\n",
      "Epoch 143/500  total: 3.70745, -LL: 3.66879, prior: 0.79167, aleatoric unc.: 9.87098\n",
      "Epoch 144/500  total: 3.71752, -LL: 3.59973, prior: 0.79228, aleatoric unc.: 9.87335\n",
      "Epoch 145/500  total: 3.71323, -LL: 3.68346, prior: 0.78821, aleatoric unc.: 9.86594\n",
      "Epoch 146/500  total: 3.69810, -LL: 3.62257, prior: 0.79184, aleatoric unc.: 9.83553\n",
      "Epoch 147/500  total: 3.70289, -LL: 3.60558, prior: 0.79325, aleatoric unc.: 9.81485\n",
      "Epoch 148/500  total: 3.71252, -LL: 3.67221, prior: 0.79652, aleatoric unc.: 9.81311\n",
      "Epoch 149/500  total: 3.73219, -LL: 3.57769, prior: 0.79471, aleatoric unc.: 9.85562\n",
      "Epoch 150/500  total: 3.72208, -LL: 3.67267, prior: 0.78948, aleatoric unc.: 9.87345\n",
      "Epoch 151/500  total: 3.71389, -LL: 3.65466, prior: 0.79006, aleatoric unc.: 9.87153\n",
      "Epoch 152/500  total: 3.72419, -LL: 3.67915, prior: 0.79090, aleatoric unc.: 9.87917\n",
      "Epoch 153/500  total: 3.71665, -LL: 3.62692, prior: 0.79997, aleatoric unc.: 9.88276\n",
      "Epoch 154/500  total: 3.72019, -LL: 3.58589, prior: 0.79751, aleatoric unc.: 9.88690\n",
      "Epoch 155/500  total: 3.71445, -LL: 3.61408, prior: 0.80268, aleatoric unc.: 9.88311\n",
      "Epoch 156/500  total: 3.70221, -LL: 3.68263, prior: 0.80404, aleatoric unc.: 9.85331\n",
      "Epoch 157/500  total: 3.70698, -LL: 3.70702, prior: 0.80339, aleatoric unc.: 9.83723\n",
      "Epoch 158/500  total: 3.72310, -LL: 3.59278, prior: 0.80445, aleatoric unc.: 9.85699\n",
      "Epoch 159/500  total: 3.71378, -LL: 3.73156, prior: 0.80416, aleatoric unc.: 9.85512\n",
      "Epoch 160/500  total: 3.70706, -LL: 3.63655, prior: 0.80595, aleatoric unc.: 9.84014\n",
      "Epoch 161/500  total: 3.71271, -LL: 3.57877, prior: 0.80410, aleatoric unc.: 9.84335\n",
      "Epoch 162/500  total: 3.71768, -LL: 3.63120, prior: 0.80659, aleatoric unc.: 9.85032\n",
      "Epoch 163/500  total: 3.71903, -LL: 3.65138, prior: 0.80638, aleatoric unc.: 9.85763\n",
      "Epoch 164/500  total: 3.71713, -LL: 3.64704, prior: 0.80705, aleatoric unc.: 9.86186\n",
      "Epoch 165/500  total: 3.71419, -LL: 3.64462, prior: 0.80874, aleatoric unc.: 9.86155\n",
      "Epoch 166/500  total: 3.70272, -LL: 3.60857, prior: 0.80695, aleatoric unc.: 9.83837\n",
      "Epoch 167/500  total: 3.71688, -LL: 3.60935, prior: 0.81090, aleatoric unc.: 9.84529\n",
      "Epoch 168/500  total: 3.70292, -LL: 3.60577, prior: 0.80637, aleatoric unc.: 9.82553\n",
      "Epoch 169/500  total: 3.71970, -LL: 3.63841, prior: 0.80866, aleatoric unc.: 9.83715\n",
      "Epoch 170/500  total: 3.71758, -LL: 3.67275, prior: 0.81033, aleatoric unc.: 9.84604\n",
      "Epoch 171/500  total: 3.72500, -LL: 3.59006, prior: 0.81392, aleatoric unc.: 9.86759\n",
      "Epoch 172/500  total: 3.70126, -LL: 3.64450, prior: 0.81116, aleatoric unc.: 9.84247\n",
      "Epoch 173/500  total: 3.72101, -LL: 3.64824, prior: 0.81156, aleatoric unc.: 9.84976\n",
      "Epoch 174/500  total: 3.71152, -LL: 3.69934, prior: 0.81262, aleatoric unc.: 9.84919\n",
      "Epoch 175/500  total: 3.71467, -LL: 3.68428, prior: 0.81517, aleatoric unc.: 9.85176\n",
      "Epoch 176/500  total: 3.70291, -LL: 3.63773, prior: 0.81583, aleatoric unc.: 9.83082\n",
      "Epoch 177/500  total: 3.70896, -LL: 3.66547, prior: 0.81045, aleatoric unc.: 9.82290\n",
      "Epoch 178/500  total: 3.71117, -LL: 3.68764, prior: 0.81337, aleatoric unc.: 9.82000\n",
      "Epoch 179/500  total: 3.70928, -LL: 3.61341, prior: 0.81607, aleatoric unc.: 9.81955\n",
      "Epoch 180/500  total: 3.70466, -LL: 3.65554, prior: 0.81575, aleatoric unc.: 9.80751\n",
      "Epoch 181/500  total: 3.70420, -LL: 3.64272, prior: 0.81693, aleatoric unc.: 9.79344\n",
      "Epoch 182/500  total: 3.71046, -LL: 3.64984, prior: 0.81584, aleatoric unc.: 9.79500\n",
      "Epoch 183/500  total: 3.71474, -LL: 3.66882, prior: 0.81325, aleatoric unc.: 9.80760\n",
      "Epoch 184/500  total: 3.71527, -LL: 3.61031, prior: 0.81348, aleatoric unc.: 9.82014\n",
      "Epoch 185/500  total: 3.70042, -LL: 3.66272, prior: 0.81257, aleatoric unc.: 9.80154\n",
      "Epoch 186/500  total: 3.71282, -LL: 3.61934, prior: 0.81781, aleatoric unc.: 9.80770\n",
      "Epoch 187/500  total: 3.71327, -LL: 3.67081, prior: 0.81615, aleatoric unc.: 9.81168\n",
      "Epoch 188/500  total: 3.70315, -LL: 3.66320, prior: 0.81042, aleatoric unc.: 9.80011\n",
      "Epoch 189/500  total: 3.69962, -LL: 3.63048, prior: 0.81293, aleatoric unc.: 9.78159\n",
      "Epoch 190/500  total: 3.71830, -LL: 3.68563, prior: 0.81299, aleatoric unc.: 9.80476\n",
      "Epoch 191/500  total: 3.71706, -LL: 3.64913, prior: 0.81458, aleatoric unc.: 9.81613\n",
      "Epoch 192/500  total: 3.70988, -LL: 3.62455, prior: 0.81865, aleatoric unc.: 9.81723\n",
      "Epoch 193/500  total: 3.70870, -LL: 3.63595, prior: 0.81586, aleatoric unc.: 9.81325\n",
      "Epoch 194/500  total: 3.71062, -LL: 3.63609, prior: 0.81832, aleatoric unc.: 9.81209\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 195/500  total: 3.72410, -LL: 3.62442, prior: 0.81648, aleatoric unc.: 9.83962\n",
      "Epoch 196/500  total: 3.71915, -LL: 3.66803, prior: 0.81624, aleatoric unc.: 9.84151\n",
      "Epoch 197/500  total: 3.71432, -LL: 3.64483, prior: 0.81001, aleatoric unc.: 9.85190\n",
      "Epoch 198/500  total: 3.71493, -LL: 3.59165, prior: 0.81170, aleatoric unc.: 9.85324\n",
      "Epoch 199/500  total: 3.70331, -LL: 3.60793, prior: 0.80896, aleatoric unc.: 9.83340\n",
      "Epoch 200/500  total: 3.70812, -LL: 3.59062, prior: 0.81499, aleatoric unc.: 9.82334\n",
      "Epoch 201/500  total: 3.71478, -LL: 3.62452, prior: 0.81519, aleatoric unc.: 9.82977\n",
      "Epoch 202/500  total: 3.71517, -LL: 3.56803, prior: 0.81508, aleatoric unc.: 9.83826\n",
      "Epoch 203/500  total: 3.69960, -LL: 3.63084, prior: 0.81742, aleatoric unc.: 9.81023\n",
      "Epoch 204/500  total: 3.70639, -LL: 3.66974, prior: 0.81871, aleatoric unc.: 9.80200\n",
      "Epoch 205/500  total: 3.70826, -LL: 3.62572, prior: 0.81504, aleatoric unc.: 9.79858\n",
      "Epoch 206/500  total: 3.71623, -LL: 3.64392, prior: 0.81659, aleatoric unc.: 9.81016\n",
      "Epoch 207/500  total: 3.71774, -LL: 3.65070, prior: 0.81498, aleatoric unc.: 9.82834\n",
      "Epoch 208/500  total: 3.69666, -LL: 3.65249, prior: 0.81455, aleatoric unc.: 9.79752\n",
      "Epoch 209/500  total: 3.70594, -LL: 3.67450, prior: 0.81606, aleatoric unc.: 9.79126\n",
      "Epoch 210/500  total: 3.69925, -LL: 3.68792, prior: 0.81400, aleatoric unc.: 9.77435\n",
      "Epoch 211/500  total: 3.70082, -LL: 3.60530, prior: 0.81230, aleatoric unc.: 9.76606\n",
      "Epoch 212/500  total: 3.71195, -LL: 3.64706, prior: 0.81609, aleatoric unc.: 9.77611\n",
      "Epoch 213/500  total: 3.70414, -LL: 3.64134, prior: 0.81544, aleatoric unc.: 9.77201\n",
      "Epoch 214/500  total: 3.71389, -LL: 3.63395, prior: 0.81622, aleatoric unc.: 9.78563\n",
      "Epoch 215/500  total: 3.71683, -LL: 3.66099, prior: 0.81664, aleatoric unc.: 9.80171\n",
      "Epoch 216/500  total: 3.72204, -LL: 3.66836, prior: 0.81515, aleatoric unc.: 9.82727\n",
      "Epoch 217/500  total: 3.70703, -LL: 3.63465, prior: 0.81890, aleatoric unc.: 9.82033\n",
      "Epoch 218/500  total: 3.70247, -LL: 3.71451, prior: 0.81721, aleatoric unc.: 9.80064\n",
      "Epoch 219/500  total: 3.71433, -LL: 3.63672, prior: 0.82165, aleatoric unc.: 9.80686\n",
      "Epoch 220/500  total: 3.70779, -LL: 3.61201, prior: 0.82151, aleatoric unc.: 9.80850\n",
      "Epoch 221/500  total: 3.72726, -LL: 3.65804, prior: 0.82183, aleatoric unc.: 9.83772\n",
      "Epoch 222/500  total: 3.71228, -LL: 3.65686, prior: 0.81864, aleatoric unc.: 9.84025\n",
      "Epoch 223/500  total: 3.72339, -LL: 3.64982, prior: 0.82202, aleatoric unc.: 9.85690\n",
      "Epoch 224/500  total: 3.70915, -LL: 3.63755, prior: 0.81988, aleatoric unc.: 9.85046\n",
      "Epoch 225/500  total: 3.70552, -LL: 3.63990, prior: 0.82102, aleatoric unc.: 9.82943\n",
      "Epoch 226/500  total: 3.70323, -LL: 3.64443, prior: 0.82060, aleatoric unc.: 9.81781\n",
      "Epoch 227/500  total: 3.70019, -LL: 3.65555, prior: 0.82249, aleatoric unc.: 9.79478\n",
      "Epoch 228/500  total: 3.71216, -LL: 3.69579, prior: 0.82333, aleatoric unc.: 9.79841\n",
      "Epoch 229/500  total: 3.71140, -LL: 3.62137, prior: 0.82447, aleatoric unc.: 9.80692\n",
      "Epoch 230/500  total: 3.70575, -LL: 3.64446, prior: 0.82529, aleatoric unc.: 9.79880\n",
      "Epoch 231/500  total: 3.71456, -LL: 3.75829, prior: 0.82439, aleatoric unc.: 9.80728\n",
      "Epoch 232/500  total: 3.70966, -LL: 3.63882, prior: 0.82492, aleatoric unc.: 9.80583\n",
      "Epoch 233/500  total: 3.71351, -LL: 3.61270, prior: 0.82613, aleatoric unc.: 9.81784\n",
      "Epoch 234/500  total: 3.70172, -LL: 3.62794, prior: 0.81822, aleatoric unc.: 9.79805\n",
      "Epoch 235/500  total: 3.71109, -LL: 3.64488, prior: 0.82053, aleatoric unc.: 9.80066\n",
      "Epoch 236/500  total: 3.70431, -LL: 3.62616, prior: 0.82161, aleatoric unc.: 9.78883\n",
      "Epoch 237/500  total: 3.70279, -LL: 3.68337, prior: 0.82063, aleatoric unc.: 9.77969\n",
      "Epoch 238/500  total: 3.71613, -LL: 3.67027, prior: 0.82166, aleatoric unc.: 9.79706\n",
      "Epoch 239/500  total: 3.70064, -LL: 3.66745, prior: 0.82222, aleatoric unc.: 9.78118\n",
      "Epoch 240/500  total: 3.70537, -LL: 3.60819, prior: 0.82710, aleatoric unc.: 9.77992\n",
      "Epoch 241/500  total: 3.71476, -LL: 3.61006, prior: 0.82356, aleatoric unc.: 9.79421\n",
      "Epoch 242/500  total: 3.71145, -LL: 3.64876, prior: 0.82434, aleatoric unc.: 9.79779\n",
      "Epoch 243/500  total: 3.70802, -LL: 3.58574, prior: 0.82809, aleatoric unc.: 9.79796\n",
      "Epoch 244/500  total: 3.70571, -LL: 3.65710, prior: 0.82588, aleatoric unc.: 9.79101\n",
      "Epoch 245/500  total: 3.70188, -LL: 3.62964, prior: 0.82486, aleatoric unc.: 9.77658\n",
      "Epoch 246/500  total: 3.72030, -LL: 3.63991, prior: 0.82122, aleatoric unc.: 9.80154\n",
      "Epoch 247/500  total: 3.71523, -LL: 3.61676, prior: 0.82447, aleatoric unc.: 9.81099\n",
      "Epoch 248/500  total: 3.71168, -LL: 3.59765, prior: 0.82207, aleatoric unc.: 9.81821\n",
      "Epoch 249/500  total: 3.71399, -LL: 3.63747, prior: 0.82239, aleatoric unc.: 9.82253\n",
      "Epoch 250/500  total: 3.70465, -LL: 3.64624, prior: 0.82184, aleatoric unc.: 9.81008\n",
      "Epoch 251/500  total: 3.69921, -LL: 3.60426, prior: 0.82150, aleatoric unc.: 9.78902\n",
      "Epoch 252/500  total: 3.71118, -LL: 3.67592, prior: 0.82288, aleatoric unc.: 9.79504\n",
      "Epoch 253/500  total: 3.70237, -LL: 3.62898, prior: 0.82680, aleatoric unc.: 9.78291\n",
      "Epoch 254/500  total: 3.70794, -LL: 3.64745, prior: 0.82541, aleatoric unc.: 9.78084\n",
      "Epoch 255/500  total: 3.70302, -LL: 3.62780, prior: 0.82535, aleatoric unc.: 9.77530\n",
      "Epoch 256/500  total: 3.71729, -LL: 3.63795, prior: 0.82601, aleatoric unc.: 9.79276\n",
      "Epoch 257/500  total: 3.70993, -LL: 3.63274, prior: 0.82741, aleatoric unc.: 9.79693\n",
      "Epoch 258/500  total: 3.71243, -LL: 3.65305, prior: 0.82601, aleatoric unc.: 9.80389\n",
      "Epoch 259/500  total: 3.70296, -LL: 3.64940, prior: 0.82313, aleatoric unc.: 9.79133\n",
      "Epoch 260/500  total: 3.71093, -LL: 3.59715, prior: 0.82558, aleatoric unc.: 9.79233\n",
      "Epoch 261/500  total: 3.71045, -LL: 3.63395, prior: 0.82771, aleatoric unc.: 9.79831\n",
      "Epoch 262/500  total: 3.69963, -LL: 3.67210, prior: 0.82712, aleatoric unc.: 9.77961\n",
      "Epoch 263/500  total: 3.71113, -LL: 3.65016, prior: 0.82726, aleatoric unc.: 9.78695\n",
      "Epoch 264/500  total: 3.70665, -LL: 3.60633, prior: 0.83064, aleatoric unc.: 9.78443\n",
      "Epoch 265/500  total: 3.71054, -LL: 3.65116, prior: 0.83137, aleatoric unc.: 9.79059\n",
      "Epoch 266/500  total: 3.69886, -LL: 3.60721, prior: 0.83100, aleatoric unc.: 9.77077\n",
      "Epoch 267/500  total: 3.70686, -LL: 3.65023, prior: 0.83398, aleatoric unc.: 9.77222\n",
      "Epoch 268/500  total: 3.69995, -LL: 3.71522, prior: 0.83159, aleatoric unc.: 9.75908\n",
      "Epoch 269/500  total: 3.70539, -LL: 3.64799, prior: 0.83221, aleatoric unc.: 9.75858\n",
      "Epoch 270/500  total: 3.70420, -LL: 3.63578, prior: 0.83041, aleatoric unc.: 9.75445\n",
      "Epoch 271/500  total: 3.70999, -LL: 3.68182, prior: 0.82908, aleatoric unc.: 9.76730\n",
      "Epoch 272/500  total: 3.70793, -LL: 3.63381, prior: 0.83376, aleatoric unc.: 9.76915\n",
      "Epoch 273/500  total: 3.70842, -LL: 3.64926, prior: 0.83353, aleatoric unc.: 9.77610\n",
      "Epoch 274/500  total: 3.70973, -LL: 3.62482, prior: 0.83395, aleatoric unc.: 9.77950\n",
      "Epoch 275/500  total: 3.71090, -LL: 3.60236, prior: 0.83533, aleatoric unc.: 9.78900\n",
      "Epoch 276/500  total: 3.70221, -LL: 3.67710, prior: 0.83294, aleatoric unc.: 9.77734\n",
      "Epoch 277/500  total: 3.70494, -LL: 3.64316, prior: 0.83875, aleatoric unc.: 9.77393\n",
      "Epoch 278/500  total: 3.71155, -LL: 3.61530, prior: 0.83769, aleatoric unc.: 9.78493\n",
      "Epoch 279/500  total: 3.72149, -LL: 3.63981, prior: 0.83667, aleatoric unc.: 9.81001\n",
      "Epoch 280/500  total: 3.70467, -LL: 3.62610, prior: 0.83533, aleatoric unc.: 9.80246\n",
      "Epoch 281/500  total: 3.70502, -LL: 3.66885, prior: 0.83573, aleatoric unc.: 9.79123\n",
      "Epoch 282/500  total: 3.70405, -LL: 3.63700, prior: 0.83748, aleatoric unc.: 9.78283\n",
      "Epoch 283/500  total: 3.70889, -LL: 3.63902, prior: 0.83531, aleatoric unc.: 9.78254\n",
      "Epoch 284/500  total: 3.71741, -LL: 3.60456, prior: 0.83570, aleatoric unc.: 9.80172\n",
      "Epoch 285/500  total: 3.71138, -LL: 3.68161, prior: 0.83478, aleatoric unc.: 9.80546\n",
      "Epoch 286/500  total: 3.70675, -LL: 3.59507, prior: 0.83560, aleatoric unc.: 9.80310\n",
      "Epoch 287/500  total: 3.70698, -LL: 3.61376, prior: 0.83594, aleatoric unc.: 9.79633\n",
      "Epoch 288/500  total: 3.70635, -LL: 3.60290, prior: 0.83656, aleatoric unc.: 9.78862\n",
      "Epoch 289/500  total: 3.71560, -LL: 3.64837, prior: 0.83419, aleatoric unc.: 9.80237\n",
      "Epoch 290/500  total: 3.70476, -LL: 3.65473, prior: 0.83240, aleatoric unc.: 9.79643\n",
      "Epoch 291/500  total: 3.70503, -LL: 3.67415, prior: 0.83116, aleatoric unc.: 9.78742\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 292/500  total: 3.69757, -LL: 3.58311, prior: 0.82735, aleatoric unc.: 9.77046\n",
      "Epoch 293/500  total: 3.70371, -LL: 3.64588, prior: 0.82783, aleatoric unc.: 9.76296\n",