optimizer-compare-visualization.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Optimizer Comparison Visualization for Single Parameter\n",
    "\n",
    "Interactive plot showing cumulative updates for a single parameter. The gradients for the parameter are random values with a normal distribution. The optimizers are SGD + momentum, Adam, and Adamax. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "from matplotlib.widgets import Button, Slider"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Adam(object):\n",
    "    \"\"\"Calculate single paramter Adam/Adamax updates.\"\"\"\n",
    "    \n",
    "    def __init__(self, beta_1=0.9, beta_2=0.999, epsilon=1e-08):\n",
    "        self.beta_1 = beta_1\n",
    "        self.beta_2 = beta_2\n",
    "        self.epsilon = epsilon\n",
    "        self.m = 0 # 1st moment vector\n",
    "        self.v = 0 # 2nd moment vector\n",
    "        self.v_max = 0 # exponentially weighted infinity norm\n",
    "        self.t = 0 # timestep\n",
    "    \n",
    "    def update(self, gradient, lr, use_denominator=True):\n",
    "        \"\"\"Adam and Adamax update for single parameter.\n",
    "        \n",
    "        # Arguments\n",
    "            gradient: float\n",
    "            lr: float, learning rate\n",
    "            \n",
    "        Returns tuple with Adam update first.\n",
    "        \"\"\"      \n",
    "        \n",
    "        self.t += 1\n",
    "        self.m = (self.beta_1 * self.m) + (1. - self.beta_1) * gradient\n",
    "        self.v = (self.beta_2 * self.v) + (1. - self.beta_2) * np.square(gradient)\n",
    "        self.v_max = np.maximum((self.beta_2 * self.v_max), np.abs(gradient))\n",
    "        m_hat = self.m / (1. - self.beta_1**self.t) # bias correction \n",
    "        v_hat = self.v / (1. - self.beta_2**self.t) # bias correction\n",
    "        \n",
    "        adam = -lr * m_hat / (np.sqrt(v_hat) + self.epsilon)\n",
    "        adamax = -lr * m_hat / (self.v_max + self.epsilon)\n",
    "\n",
    "        return (adam, adamax)\n",
    "    \n",
    "    \n",
    "class SGD(object):\n",
    "    \"\"\"Calculate single paramter SGD updates with optional momentum.\"\"\"\n",
    "    \n",
    "    def __init__(self, momentum=0):\n",
    "        self.momentum = momentum\n",
    "        self.prev_update = 0\n",
    "    \n",
    "    def update(self, gradient, lr):\n",
    "        \"\"\"Returns SGD update for single parameter.\n",
    "        \n",
    "        # Arguments\n",
    "            gradient: float\n",
    "            lr: float, learning rate\n",
    "        \"\"\"\n",
    "        \n",
    "        update = self.momentum * self.prev_update - lr * gradient\n",
    "        self.prev_update = update\n",
    "        return update  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\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('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",
       "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 = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(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 (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.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 = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\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 nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\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",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option)\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\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",
       "\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",
       "\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]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.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, 0, fig.canvas.width, fig.canvas.height);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\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",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\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(\"No handler for the '\" + msg_type + \"' message type: \", msg);\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(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\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",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\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",
       "    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",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\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",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\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,\n",
       "                             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",
       "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\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"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\";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 = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\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.get(0);\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",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\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).html('<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/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<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 () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\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) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('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",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\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",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        event.shiftKey = false;\n",
       "        // Send a \"J\" for go to next cell\n",
       "        event.which = 74;\n",
       "        event.keyCode = 74;\n",
       "        manager.command_mode();\n",
       "        manager.handle_keydown(event);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\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('matplotlib', mpl.mpl_figure_comm);\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=\"800\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# initial conditions\n",
    "scale = 0.2 # gradient standard deviation\n",
    "sgd_lr = 0.05\n",
    "momentum = 0.9\n",
    "adam_lr = 0.05\n",
    "beta_1 = 0.9\n",
    "beta_2 = 0.999\n",
    "view_epoch = 1\n",
    "ylim = 5.\n",
    "line_width = 1.\n",
    "epochs = 5\n",
    "steps_per_epoch = 1000\n",
    "\n",
    "# static\n",
    "iterations = epochs * steps_per_epoch\n",
    "\n",
    "plt.rcParams['figure.figsize'] = (8.0, 8.0)\n",
    "fig, ax = plt.subplots(nrows=1)\n",
    "plt.subplots_adjust(left=0.1, right=0.99, bottom=0.43, hspace=0)\n",
    "\n",
    "ax.axis([0, steps_per_epoch + 1, -ylim, ylim])\n",
    "ax.grid(axis='y', color='0.9', linestyle='--')\n",
    "ax.hlines(0, 0, steps_per_epoch + 1, color='0.3', linewidth=1)\n",
    "ax.set_ylabel('Cumulative Update', fontsize='small')\n",
    "ax.tick_params(bottom=False, labelbottom=False, labelsize='small')\n",
    "\n",
    "# updatable\n",
    "gradients = np.random.normal(scale=scale, size=iterations)\n",
    "#gradients = np.random.uniform(low=-1, high=1, size=iterations)\n",
    "\n",
    "sgd = SGD(momentum=momentum)\n",
    "updates = [sgd.update(g, sgd_lr) for g in gradients]\n",
    "updates = np.cumsum(updates)\n",
    "sgd_steps, = ax.plot(\n",
    "    np.arange(1, steps_per_epoch + 1, 1), \n",
    "    updates[steps_per_epoch*(view_epoch-1):steps_per_epoch*view_epoch], \n",
    "    color='0.6', label='SGD + momentum', \n",
    "    linewidth=0.8, marker='.', markersize=3)\n",
    "\n",
    "optimizer = Adam(beta_1=beta_1, beta_2=beta_2)\n",
    "adam, adamax = zip(*[optimizer.update(g, adam_lr) for g in gradients])\n",
    "adam = np.cumsum(adam)\n",
    "adamax = np.cumsum(adamax)\n",
    "adam_steps, = ax.plot(\n",
    "    np.arange(1, steps_per_epoch + 1, 1), \n",
    "    adam[steps_per_epoch*(view_epoch-1):steps_per_epoch*view_epoch], \n",
    "    label='Adam', linewidth=0.8, marker='.', markersize=3)\n",
    "adamax_steps, = ax.plot(\n",
    "    np.arange(1, steps_per_epoch + 1, 1), \n",
    "    adamax[steps_per_epoch*(view_epoch-1):steps_per_epoch*view_epoch], \n",
    "    label='Adamax', linewidth=0.8, marker='.', markersize=3)\n",
    "\n",
    "# legends\n",
    "ax.set_title(\"Epoch \" + str(view_epoch) + \n",
    "             \" (\" + str(steps_per_epoch) + \" steps per epoch)\" +\n",
    "             \" | Gradient SD = \" + str(round(scale, 4)), fontsize='small')\n",
    "ax.legend(fontsize='small')\n",
    "\n",
    "# controls\n",
    "axcolor = 'lightgoldenrodyellow'\n",
    "top = 0.41\n",
    "slider_width = 0.71\n",
    "\n",
    "ax_sgd_lr = plt.axes([0.2, top - 0.04, slider_width, 0.03], facecolor=axcolor)\n",
    "ax_momentum = plt.axes([0.2, top - 2*0.04, slider_width, 0.03], facecolor=axcolor)\n",
    "ax_adam_lr = plt.axes([0.2, top - 3*0.04, slider_width, 0.03], facecolor=axcolor)\n",
    "ax_beta_1 = plt.axes([0.2, top - 4*0.04, slider_width, 0.03], facecolor=axcolor)\n",
    "ax_beta_2 = plt.axes([0.2, top - 5*0.04, slider_width, 0.03], facecolor=axcolor)\n",
    "ax_epoch = plt.axes([0.2, top - 6*0.04, slider_width, 0.03], facecolor=axcolor)\n",
    "ax_ylim = plt.axes([0.2, top - 7*0.04, slider_width, 0.03], facecolor=axcolor)\n",
    "ax_adam = plt.axes([0.2, top - 8*0.04 - 0.03, slider_width / 3, 0.05], facecolor=axcolor)\n",
    "ax_adamax = plt.axes([0.2 + slider_width / 3, top - 8*0.04 - 0.03, slider_width / 3, 0.05], facecolor=axcolor)\n",
    "ax_grad = plt.axes([0.2 + 2 * slider_width / 3, top - 8*0.04 - 0.03, slider_width / 3, 0.05], facecolor=axcolor)\n",
    "\n",
    "s_sgd_lr = Slider(ax_sgd_lr, ' SGD lr', 0.001, 1.0, valstep=0.001, valinit=sgd_lr, valfmt='%1.3f')\n",
    "s_momentum = Slider(ax_momentum, 'momentum', 0.0, 0.99, valstep=0.01, valinit=momentum)\n",
    "s_adam_lr = Slider(ax_adam_lr, 'Adam(ax) lr', 0.001, 1.0, valstep=0.001, valinit=adam_lr, valfmt='%1.3f')\n",
    "s_beta_1 = Slider(ax_beta_1, 'beta_1', 0.0, 0.99, valstep=0.01, valinit=beta_1)\n",
    "s_beta_2 = Slider(ax_beta_2, 'beta_2', 0.0, 0.999, valstep=0.001, valinit=beta_2, valfmt='%1.3f')\n",
    "s_epoch = Slider(ax_epoch, 'View Epoch', 1, epochs, valstep=1, valinit=view_epoch, valfmt='%d')\n",
    "s_ylim = Slider(ax_ylim, 'y Limit', 0.1, 50, valstep=0.1, valinit=ylim, valfmt='%1.1f')\n",
    "b_adam = Button(ax_adam, 'Adam', color='0.9', hovercolor='0.8')\n",
    "b_adamax = Button(ax_adamax, 'Adamax', color='0.9', hovercolor='0.8')\n",
    "b_grad = Button(ax_grad, 'New Gradients', color='0.9', hovercolor='0.8')\n",
    "\n",
    "def new_gradients(val):\n",
    "    global gradients \n",
    "    global scale\n",
    "    scale = np.random.uniform(0.0, 0.3)\n",
    "    gradients = np.random.normal(scale=scale, size=iterations)\n",
    "    update_opt(val)    \n",
    "    \n",
    "def update_opt(val):\n",
    "    global updates\n",
    "    global adam\n",
    "    global adamax\n",
    "    \n",
    "    sgd_lr = s_sgd_lr.val\n",
    "    momentum = s_momentum.val\n",
    "    adam_lr = s_adam_lr.val\n",
    "    beta_1 = s_beta_1.val\n",
    "    beta_2 = s_beta_2.val    \n",
    "    \n",
    "    sgd = SGD(momentum=momentum)\n",
    "    updates = [sgd.update(g, sgd_lr) for g in gradients] \n",
    "    optimizer = Adam(beta_1=beta_1, beta_2=beta_2)    \n",
    "    adam, adamax = zip(*[optimizer.update(g, adam_lr) for g in gradients])\n",
    "    updates = np.cumsum(updates)\n",
    "    adam = np.cumsum(adam)\n",
    "    adamax = np.cumsum(adamax)\n",
    "    \n",
    "    view_epoch(val)\n",
    "    \n",
    "def view_epoch(val):\n",
    "    e = int(s_epoch.val)\n",
    "    ax.set_title(\"Epoch \" + str(e) + \n",
    "             \" (\" + str(steps_per_epoch) + \" steps per epoch)\" +\n",
    "             \" | Gradient SD = \" + str(round(scale, 4)), fontsize='small')\n",
    "    sgd_steps.set_ydata(updates[steps_per_epoch*(e-1):steps_per_epoch*e])\n",
    "    adam_steps.set_ydata(adam[steps_per_epoch*(e-1):steps_per_epoch*e])\n",
    "    adamax_steps.set_ydata(adamax[steps_per_epoch*(e-1):steps_per_epoch*e])\n",
    "    fig.canvas.draw_idle()     \n",
    "    \n",
    "def draw_adam(val):\n",
    "    adam_steps.set_visible(not adam_steps.get_visible())\n",
    "    fig.canvas.draw_idle()\n",
    "    \n",
    "def draw_adamax(val):\n",
    "    adamax_steps.set_visible(not adamax_steps.get_visible())\n",
    "    fig.canvas.draw_idle()\n",
    "    \n",
    "def zoom(val):\n",
    "    ylim = s_ylim.val\n",
    "    ax.set_ylim(top=ylim, bottom=-ylim)\n",
    "    fig.canvas.draw_idle()\n",
    "  \n",
    "s_sgd_lr.on_changed(update_opt)\n",
    "s_momentum.on_changed(update_opt)\n",
    "s_adam_lr.on_changed(update_opt)\n",
    "s_beta_1.on_changed(update_opt)\n",
    "s_beta_2.on_changed(update_opt)\n",
    "s_epoch.on_changed(view_epoch)\n",
    "s_ylim.on_changed(zoom)\n",
    "b_grad.on_clicked(new_gradients)\n",
    "b_adam.on_clicked(draw_adam)\n",
    "b_adamax.on_clicked(draw_adamax)\n",
    "\n",
    "plt.suptitle('Single Parameter Update', x=0.1, y=0.95, ha='left')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Notes\n",
    "\n",
    "- New gradients are sampled from a normal distribution with mean 0 and standard deviation sampled from unif(0, 0.3). \n",
    "- SGD + momentum is heavily influenced by 'large' gradients, and will shoot off to extreme updates. Try new gradients or manually changing the standard deviation (`scale` in initial conditions) of the gradient's distribution to see this effect. On the other hand, for small gradients SGD + momentum doesn't have much movement compared to Adam/Adamax.\n",
    "- Generally, Adam updates have at least twice the magnitude of Adamax. This supports the default learning rate for Adamax being twice the rate of Adam's.\n",
    "- Adamax is more sensitive to changes in `beta_2` than Adam."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}