ga-linear-regression.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn import preprocessing\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "usd_gbp = pd.read_csv('USDGBP.csv', parse_dates=[0])\n",
    "usd_cny = pd.read_csv('USDCNY.csv', parse_dates=[0])\n",
    "usd_jpy = pd.read_csv('USDJPY.csv', parse_dates=[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Merge all datasets to the initial dataset that has most dates\n",
    "usd_dataset = usd_jpy.merge(right=usd_gbp, how='left', on='Date').merge(right=usd_cny, how='left', on='Date')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Drop dates where there is one value missing\n",
    "usd_dataset = usd_dataset.dropna(axis=0, how='any')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Add a Ticks column to the dataframe\n",
    "# usd_dataset['Ticks'] = range(len(usd_dataset.index.values), 0, -1)\n",
    "\n",
    "# Take into consideration only two currencies\n",
    "curr = 'USDJPY'\n",
    "curr2 = 'USDGBP'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# days = 360\n",
    "# usd_dataset = usd_dataset.sample(axis=0, frac=.2)\n",
    "# plt.scatter(usd_dataset['Ticks'][-days:], usd_dataset['USDGBP'][-days:], marker='o', color='blue')\n",
    "# plt.scatter(usd_dataset['Ticks'][-days:], usd_dataset['USDJPY'][-days:], marker='o', color='red')\n",
    "# plt.scatter(usd_dataset['Ticks'][-days:], usd_dataset['USDCNY'][-days:], marker='o', color='green')\n",
    "# plt.xlabel('Ticks')\n",
    "# plt.ylabel('USD/XXX')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0,0.5,'USDGBP')"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# usdgbp = usd_dataset['USDGBP'].rolling(center=False, window=5).mean()\n",
    "# usdjpy = usd_dataset['USDJPY'].rolling(center=False, window=5).mean()\n",
    "\n",
    "# Plot the graph of one currency in respect with the other one, NORMALIZED\n",
    "days = 180\n",
    "X = preprocessing.normalize(usd_dataset[curr].values.reshape(-1, 1)[-days:], axis=0, norm='max')\n",
    "y = preprocessing.normalize(usd_dataset[curr2].values.reshape(-1, 1)[-days:], axis=0, norm='max')\n",
    "plt.scatter(X, y, marker='o', color='blue', s=3)\n",
    "plt.xlabel(curr)\n",
    "plt.ylabel(curr2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Coefficient : 1.7007 \n",
      "Intercept : -0.6562\n"
     ]
    }
   ],
   "source": [
    "# Create Linear Regression model and fit the data\n",
    "from sklearn.linear_model import LinearRegression\n",
    "model = LinearRegression()\n",
    "model.fit(X, y)\n",
    "print('Coefficient :', np.round(model.coef_[0][0],decimals=4),\n",
    "      '\\nIntercept :', np.round(model.intercept_[0], decimals=4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0,0.5,'USDGBP')"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Predict the data with the found best fit line and plot it\n",
    "line = model.predict(X)\n",
    "plt.scatter(X, y, marker='o', color='blue', s=3)\n",
    "plt.plot(X, line, color='red')\n",
    "plt.xlabel(curr)\n",
    "plt.ylabel(curr2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# GA functions\n",
    "def fitness(solution):\n",
    "    '''Fitness function is the Ordinary Least Squares'''\n",
    "    return 1/len(X)*np.sum(np.power(y-np.concatenate((X,np.ones((X.shape[0],1))),axis=1).dot(solution.reshape(-1,1)),2))\n",
    "\n",
    "def genPopulation(size=400):\n",
    "    '''Generate population of size individuals'''\n",
    "    # Coefficient and intercept in the range [-1, 1] since all data has been normalized with maximum value\n",
    "    solutions = ((np.random.rand(size, 2) * 2) - 1)\n",
    "    return solutions\n",
    "\n",
    "def selectBest(solutions):\n",
    "    '''Return the best 20 solution for current population'''\n",
    "    fitnesses = np.apply_along_axis(fitness, 1, solutions)\n",
    "    return solutions[np.argsort(fitnesses, axis=0)[:20],:]\n",
    "\n",
    "def crossover(sol1, sol2):\n",
    "    '''Perform crossover between two solutions by exchanging the intercepts and maintaining the coefficient'''\n",
    "    offsprings = np.array([[sol1[0], sol2[1]]])\n",
    "    offsprings = np.vstack((offsprings, [[sol2[0], sol1[1]]]))\n",
    "    offsprings = np.vstack((offsprings, [sol2]))\n",
    "    return offsprings\n",
    "\n",
    "def mutation(sol):\n",
    "    '''Perform mutation on the solution'''\n",
    "    mutationProb = 0.15\n",
    "    if np.random.rand() < mutationProb:\n",
    "        sol = sol + (((np.random.rand(2) * 2) - 1) * 0.1)\n",
    "    return sol"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "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\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\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=\"576\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib nbagg\n",
    "\n",
    "# Perform epochs while executing the genetic algorithm\n",
    "size = 400\n",
    "solutions = genPopulation(size)\n",
    "epochs = 400\n",
    "best = []\n",
    "inter_sol = []\n",
    "fig = plt.figure(figsize=(8, 6))\n",
    "#fig.set_tight_layout(True)\n",
    "ax = fig.add_subplot(111)\n",
    "plt.ion()\n",
    "fig.show()\n",
    "fig.canvas.draw()\n",
    "\n",
    "for i in range(epochs):\n",
    "    bestSols = selectBest(solutions)\n",
    "    if i != 0 and fitness(bestSols[0]) < fitness(best):\n",
    "        best = bestSols[0]\n",
    "    else:\n",
    "        best = bestSols[0]\n",
    "    predict = np.concatenate((X, np.ones((X.shape[0],1))), axis=1).dot(best.transpose())\n",
    "    inter_sol.append(predict)\n",
    "    ax.clear()\n",
    "    plt.scatter(X, y, marker='o', color='blue', s=3)\n",
    "    plt.plot(X, line, color='red', label='Regression')\n",
    "    plt.plot(X, predict, color='green', label='GA')\n",
    "    plt.xlabel(curr)\n",
    "    plt.ylabel(curr2)\n",
    "    plt.legend(loc='best')\n",
    "    fig.canvas.draw()\n",
    "    # Elitism\n",
    "    newPopulation = np.array(best)\n",
    "    for j in range(len(bestSols)-1):\n",
    "        newPopulation = np.vstack((newPopulation, crossover(bestSols[j], bestSols[j+1])))\n",
    "    newPopulation = np.apply_along_axis(mutation, 1, newPopulation)\n",
    "    solutions = newPopulation\n",
    "#print(best)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f4f3bf65ef0>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "# Use the best candidate solution to predict the data and plot the GA found line\n",
    "predict = np.concatenate((X, np.ones((X.shape[0],1))), axis=1).dot(best.transpose())\n",
    "plt.scatter(X, y, marker='o', color='blue', s=3)\n",
    "plt.plot(X, line, color='red', label='Regression')\n",
    "plt.plot(X, predict, color='green', label='GA')\n",
    "plt.xlabel(curr)\n",
    "plt.ylabel(curr2)\n",
    "plt.legend(loc='best')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### We use FuncAnimation and ImageMagick to generate a gif file of the approximation procedure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f4f3c025080>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import animation, rc\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "rc('animation', html='html5')\n",
    "\n",
    "ax.scatter(X, y, marker='o', color='blue', s=3)\n",
    "ax.plot(X, line, color='red', label='Regression')\n",
    "ga_line, = ax.plot([], [], color='green', label='GA')\n",
    "ax.legend(loc='best')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solver(i):\n",
    "    ga_line.set_data(X, inter_sol[i])\n",
    "    ax.set_xlabel('epoch {0}'.format(i))\n",
    "    return ga_line, ax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "anim = animation.FuncAnimation(fig, solver, frames=np.arange(0, 400), interval=80, repeat=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "anim.save('ga_regression.gif', dpi=80, writer='imagemagick')"
   ]
  }
 ],
 "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.5.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}